常用排序算法

排序算法                最好时间        平均时间        最坏时间        辅助空间    稳定性

 

直接插入排序           O(n)             O(n^2)        O(n^2)         O(1)         稳定

希尔排序                                    O(n^1.3)                         O(1)         不稳定

 

直接选择排序           O(n^2)         O(n^2)        O(n^2)         O(1)         不稳定

堆排序                   O(n x lbn)      O(n x lbn)    O(n x lbn)    O(1)          不稳定

 

冒泡排序                O(n)              O(n^2)        O(n^2)         O(1)         稳定

快速排序                O(n x lbn)      O(n x lbn)    O(n x lbn)     O(lbn)       不稳定

 

归并排序                O(n x lbn)      O(n x lbn)     O(n x lbn)     O(n)        不稳定

 

基数排序(基于链式队列) O(mxn)     O(mxn)        O(mxn)          O(n)        稳定

基数排序(基于顺序队列) O(mxn)     O(mxn)        O(mxn)          O(mxn)    稳定

#include <string.h>


void printData(int data[],int len)
{
for(int i = 0; i < len; i++)
{
printf("%3d ",data[i]);
}
printf("\n");
}
//1.选择排序
//2.插入排序
//3.冒泡排序
//4.快速排序
//5.归并排序
//6.堆排序
//7.希尔排序






//1.选择排序
void sort1(int data[],int len)
{
for(int i = 0; i < len - 1; i++)
{
int n = 0, m = 0;
for(int j = i + 1; j < len; j++)
{
if(n < data[j])
{
n = data[j];
m = j;
}
}
if(data[i] < n)
{
data[m] = data[i];
data[i] = n;
}
}
}


//2.插入排序
void sort2(int data[],int len)
{
for(int i = 1; i < len; i++)
{
for(int j = 0; j < i; j++)
{
if(data[i] > data[j])
{
int n = data[i];
for(int k = i; k > j; k--)
{
data[k] = data[k - 1];
}
data[j] = n;
}
}
}
}


//3.冒泡排序
void sort3(int data[],int len)
{
for(int i = 0; i < len - 1; i++)
{
for(int j = len - 1; j > i; j--)
{
if(data[j] > data[j - 1])
{
int n = data[j];
data[j] = data[j - 1];
data[j - 1] = n;
}
}
}
}


void sortPart(int data[],int start,int end)
{
if(start >= end)
{
return;
}
int k = start;
int fi = start + 1;
int ti = end;
while(fi < ti)
{
while(data[fi] < data[start])
{
fi++;
}
while(data[ti] > data[start])
{
ti--;
}
if(fi < ti)
{
int n = data[fi];
data[fi] = data[ti];
data[ti] = n;
ti--;
fi++;
}
}
if(data[start] > data[ti])
{
int m = data[start];
data[start] = data[ti];
data[ti] = m;
k = ti;
}
sortPart(data, start, k - 1);
sortPart(data, k + 1, end);
}


//4.快速排序
void sort4(int data[],int len)
{
sortPart(data, 0, len - 1);
}




void sort5Part(int *data,int *dataTemp,int start,int end)
{
if(start >= end)
{
return;
}


int mid = (start + end) / 2;

if(mid > start && mid < end)
{
sort5Part(data,dataTemp,start,mid);
sort5Part(data,dataTemp,mid+1,end);
}
printf("s=%d m=%d e=%d  ",start,mid,end);

int i = start,total = end;
int fi = start,si = mid + 1;
while(i <= total)
{
if(fi <= mid && si <= end)
{
if(data[fi] < data[si])
{
dataTemp[i] = data[fi];
fi++;
}
else
{
dataTemp[i] = data[si];
si++;
}
i++;
}
else if(fi > mid && si <= end)
{
while(si <= end)
{
dataTemp[i] = data[si];
si++;
i++;
}
break;
}
else if(fi <= mid && si > end)
{
while(fi <= mid)
{
dataTemp[i] = data[fi];
fi++;
i++;
}
break;
}
}


memcpy(data+start,dataTemp+start,(end-start+1)*(sizeof(int)));
printData(data,10);
}


//5.归并排序
void sort5(int data[],int len)
{
int* dataTemp = new int[len];
   sort5Part(data,dataTemp,0,len-1);
   delete []dataTemp;
}


void sortHeap(int data[],int id,int len)
{
int left = id * 2 + 1;
if(left >= len)//没有子节点
{
return;
}
int right = left + 1;
int mid,k;
if(right < len)//有左右子节点
{
if(data[left] >= data[right])
{
mid = data[left];
k = left;
}
else
{
mid = data[right];
k = right;
}
}
else//只有左节点
{
mid = data[left];
k = left;
}
if(data[id] < mid)
{
data[k] = data[id];
data[id] = mid;
//调整了子节点，要对子节点的下层再次生成大（小）根堆
sortHeap(data,k,len);
}
}


//6.堆排序
void sort6(int data[],int len)
{
int m = len / 2 - 1;
if(m < 0)
{
return;
}
//生成大根堆
for(int i = m; i >= 0; i--)
{
sortHeap(data,i,len);
}


//每次都把顶部最大的一个放到尾部，剩余部分重新生成大根堆
for(i = len - 1; i > 0; i--)
{
int n = data[i];
data[i] = data[0];
data[0] = n;
sortHeap(data,0,i);
}
}


//7.希尔排序
void sort7(int data[],int len)
{
int k = len / 2;
while(k >= 1)
{
for(int i = 0; i + k < len; i++)
{
if(data[i] > data[i + k])
{
int n = data[i];
data[i] = data[i + k];
data[i + k] = n;
}
}
k = k / 2;
}
}


void test(int* data,int *src,int len)
{
int start = 4,n = 5;
memcpy(data + (start),src+(start),n*4);
}


int main(int argc, char* argv[])
{
int data[] = {71,18,151,138,160,63,174,169,79,78};


int len = sizeof(data)/4;
printData(data,len);
sort6(data,len);
printf("\nresult=\n");
printData(data,len);
printf("\nHello World!\n");
return 0;
}