void bubbleSort(int A[], int n)
{
bool change = true;//标识是否交换了，若是已经排好序了，那么可以马上停下来
int i, j;
for(i = n-1; i >= 1 && change;i--){
change = false;
for(j = 0; j < i; j++){
if(A[j] > A[j+1]){
swap(&A[j], &A[j+1]);
change = true;
}
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//快速排序
void quickSort(int A[], int p, int q)
{
int i;
if(p < q){
i = partition(A, p, q);
quickSort(A, p, i-1);
quickSort(A, i+1, q);
}
}
//快速排序中的划分
int partition(int A[], int p, int q)
{
int x = A[q];//把最后一个元素做为“轴”
//最坏情况下会蜕变成冒泡排序，可采用随机化方法改进：k = rand(q+1),然后交换A[k]与A[q]，再x = A[q]
int i = p-1, j;
for(j = p; j <=q-1; j++){//A[p..i]小区; A[i+1...q]大区
if(A[j] <= x){
i++;
swap(&A[i], &A[j]);
}
}
swap(&A[i+1], &A[q]);
return i+1;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <limits.h>//int的无穷大INT_MAX在这个头文件里
#include <stdlib.h>
#include "sort.h"
//归并排序
void mergeSort(int A[], int p, int q)
{
int r;
if(p < q){
r = (p+q)/2;
mergeSort(A, p, r);
mergeSort(A, r+1, q);
merge(A, p, r, q);
}
}
//归并排序中的合并
//把排好序的a[p...r]和a[r+1 ... q],合并成有序的a[p...q]
void merge(int A[], int p, int r, int q)
{
int n1 = r-p+1, n2 = q -r;
int i, j, k;
int *L, *R;
L = (int *)malloc(n1 * sizeof(int));//创建临时数组
R = (int *)malloc(n2 * sizeof(int));
for(i = 0; i < n1; i++)//把A[p...r]拷到L[]中
L[i] = A[p+i];
for(j = 0; j < n2; j++)//把A[r+1...q]拷到L[]中
R[j] = A[r+j+1];
L[n1] = INT_MAX;//设置哨兵
R[n2] = INT_MAX;
i = 0;
j = 0;
for(k = p; k <= q; k++){//从小到大排序A[p...q]
if(L[i] <= R[j]){
A[k] = L[i];
i++;
}
else{
A[k] = R[j];
j++;
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include<stdlib.h>
#include<stdio.h>
//桶排序
typedef struct LNode{
int data;
struct LNode *next;
}LNode, *LinkList;
//输出
void Output(LinkList L){
LinkList p;
p=L->next;
while(p){
printf("%d ",p->data);
p=p->next;
}
}
//桶内排序递增
void listSort(LinkList &L){
LinkList p,q,r;
p=L->next;
if(p){ //L有一个或以上的结点
r=p->next; //r保存p结点的后继结点
p->next=NULL; //构造只含一个数据结点的有序表
p=r;
while(p){
r=p->next;
q=L;
while(q->next!=NULL&&q->next->data < p->data)
q=q->next; //在有序表中插入*p的前驱结点*q
p->next=q->next;
q->next=p;
p=r; //扫描原单链表余下的结点
}
}//if
}
void bucketSort(int A[], int n, int flag)
{
LinkList bucket[10];
LinkList p;
int i, key, j;
for(i = 0; i < 10; i++){//初始化桶对应的链表
bucket[i]=(LinkList)malloc(sizeof(LNode));
bucket[i]->next=NULL;
}
for(i = 0; i < n; i++){//将数据放入对应桶中
key = A[i];
j = key/100;//桶号
p = (LinkList)malloc(sizeof(LNode));//生成新结点
p->data = key;
p->next = bucket[j]->next;
bucket[j]->next = p;
}
for(i = 0; i < 10; i++){
listSort(bucket[i]);
}
if(flag == 1){//打印输出
for(i = 0; i < 10; i++){
Output(bucket[i]);
}
printf("\n");
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//插入排序
void insertSort(int A[], int n)
{
int i, j, key;
for(j = 1; j < n; j++){
key = A[j];
i = j-1;
while(i >= 0 && A[i] > key){//把A[j]插入到A[0...j-1]
A[i+1] = A[i];
i--;
}
A[i+1] = key;
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//一趟希尔排序子过程
void shellInsert(int A[], int n, int dk)//dk是增量
{
int i, j, temp;
for(i = dk; i < n; i++){
if(A[i] < A[i-dk]){
temp = A[i];
for(j = i-dk; j >= 0 && (temp < A[j]); j -= dk){
A[j +dk] = A[j];
}
A[j + dk] = temp;
}
}
}
//希尔排序
void shellSort(int A[], int n, int data[], int t)
{
//按增量序列data[0...t-1]对数组排序
int k;
for(k = 0; k < t; k++)
shellInsert(A,n,data[k]);//一趟增量为K的插入排序
}