几种排序算法

 

第一种：冒泡排序法

算法思想：首先将第一个记录的关键字与第二个记录的关键字进行比较，若为逆序，则交换这两个记录的值，然后比较第二个记录和第三个记录的关键字，以此类推，直至第n-1个和第n个记录的关键字比较过为止；至此第一趟冒泡排序完成，对前n-1个记录的关键字按照第一趟的冒泡排序排序，依次循环，直到最后缩到第一个为止

void SelectSort(int data[],int n)  

1. {  
2.     int i , j , temp;  
3.     for( i = 0;i<n;i++)  
4.         for(j = 0;j<n-i-1;j++)  
5.         {  
6.             if(data[j]>data[j+1])  
7.             {  
8.                 temp = data[j];  
9.                 data[j] = data[j+1];  
10.                 data[j+1] = temp;  
11.             }  
12.         }  
13. }  

第二种：简单排序法

算法思想：通过n-i次关键字之间的比较，从n-i+1个记录中选出最小关键字的记录，并和第i个记录进行交换，当i=n时所有记录有序排列

void SelectSort(int data[] , int n)  

1. {  
2.     int i,j,k,temp;  
3.     for(i = 0;i<n-1;i++)  
4.     {  
5.         k = i;  
6.         for(j=i+1;j<n;j++)  
7.             if(data[j]<data[k])  
8.                 k = j;  
9.             if(k!=i)  
10.             {  
11.                 temp = data[i];  
12.                 data[i] = data[k];  
13.                 data[k] = temp;  
14.             }  
15.     }  
16. }  

第三种：希尔排序法,又称“缩小增量排序法”

算法思想：先将整个待排记录分成若干序列，然后分别进行直接插入排序，待整个序列中的记录基本有序时，再对全体记录进行一次直接插入排序。

程序源码：

view plain copy to clipboard print ?

1. void ShellSort(int data[],int n)  
2. {  
3.     int *delta , k,i,t,dk,j;  
4.     k = n;  
5.     /*从k=n开始，重复k=k/2运算，直到k=0，所得k值的序列作为增量序列存入delta*/  
6.     delta = (int*)malloc(sizeof(int)*(n/2));  
7.     i = 0;  
8.     do  
9.     {  
10.         k = k/2;  
11.         delta[i++] = k;  
12.     }while(k>0);  
13.     i = 0;  
14.     while((dk=delta[i])>0)  
15.     {  
16.         for(k=delta[i];k<n;k++)  
17.             if(data[k]<data[k-dk])/*将元素data[k]插入有序增量子表中*/  
18.             {                       
19.                 t = data[k];      /*备份待插入的元素，空出一个元素位置*/  
20.                 for(j = k-dk;j>=0&&t<data[i];j-=dk)  
21.                     data[j+dk] = data[j];/*寻找插入位置的同时元素后移*/  
22.                 data[j+dk] = t;/*找到插入位置，插入元素*/  
23.             }  
24.             ++i;                /*取下一个增量值*/  
25.     }  
26. }  

第四种：快速排序法

算法思想：通过一趟排序将待排的记录分割成独立的两个部分，其中一部分记录的关键字不大于（或不小于）另一部分记录的任意关键字，然后再分别对着两部分记录继续进行排序，以达到整个序列有序

程序源码：

view plain copy to clipboard print ?

1. void QuickSort(int data[],int low , int high)  
2. {  
3.  int i,prvotkey,j;  
4.  if(low<high)  
5.  {  
6.         prvotkey = data[low];//以数组的第一个元素作为基本元素进行划分   
7.   i = low;  
8.   j = high;  
9.   while(i<j)//从数组两端交替的向中间扫描   
10.   {  
11.    while(i<j&&data[j]>=prvotkey)  
12.     j--;  
13.    if(i<j)  
14.    data[i++] = data[j];//比基准元素小的移到低下标段   
15.    while(i<j&&data[i]<=prvotkey)  
16.     i++;  
17.    if(i<j)  
18.     data[j--] = data[i];//比基准元素大的移到高下标段   
19.   }  
20.   
21.   data[i] = prvotkey;  //移动基准元素到正确位置   
22.         QuickSort(data , low , i-1);//对前半个子表递归排序   
23.   QuickSort(data , j+1 , high);//对后半个子表递归排序   
24.  }  

这几种算法中，希尔排序法虽然从代码上看好像比较繁琐，但是实际上时间复杂度最低，运行速度最快，时间复杂度为O(n^1.3);