十大排序算法

1、十大排序算法自己根据算法思想，自己编程实现十大排序算法，当然其中也有借鉴别人的地方，所有的程序都是自己经过检验测试没有问题才放出来的。一 算法介绍1 选择排序选择排序的思想就是：从当前数中选出一个最大或者最小的值排在最前面，然后从剩下的数中选出剩下数的最值排在已经排序的数的后面，算法时间复杂度O(n2)，在实际工作中这种排序算法不可取。2 冒泡排序冒泡排序的思想就是：比如说要升序排列，那么就依次相邻两个数比较大小，然后把大的数放在后面，依次类推。冒泡排序时间复杂度O(n2)，在实际工作中这种排序算法不可取。3 插入排序插入排序思想就是：依次遍历数组，假设前面已经有一部分排过序的，当前待排数字跟

2、前面的数字依次比较大小，将其插在对应顺序位置，算法时间复杂度O(n2)，在实际工作中这种排序算法不可取。4 希尔排序希尔排序的思想就是：希尔排序是对插入排序的改进，可以把当前数据分组，每个分组都有一定间隔，比如说原来数组的小标范围是0,1,2,3,4,5,6,7,8,9.我们把它们分成两组，0-4一组，5-9一组，这样的话，间隔就是5，我们令0,5,；1,6；2,7；3,8；4,9,它们两两比较大小。然后再减小间隔范围，或者说增多分组个数，比如此时，间隔为2，那么比较下标为0,2,4,6,8的大小，然后比较下标为1,3,5,7,9的大小。到最后间隔变为1，就变成了完全的插入排序了。希尔排序的算

3、法时间复杂度O(n2)。5 快速排序快速排序利用分治的思想，在数组中设置一个游标，从数组的两端来遍历数组，将元素和游标相比，意图达到两组数据一边游标小，一边比游标大。那么此时的游标就处于两组数组的中间。然后依次对前后两组数据排序，此时当然可以利用递归了。时间平均复杂度是O(n*logn)，排序算法貌似是公认最实用最好的排序算法，在大多数情况下都能解决问题，提高效率，当然也有糟糕的时候，此时的算法时间复杂度达到O(n2)。6 归并排序归并排序的思想就是把数组分成两组，前后两组分别排序，两组排完序后再把两组合并起来，当然可以利用递归的思想来实现归并排序，算法时间复杂度是O(n*logn)。7 堆排

4、序首先说明什么是堆，堆其实就一个二叉树，其中要满足父节点大于或者小于子节点。把数组中元素按照堆来遍历，修正堆后，那么最大或者最小的元素就在根节点上了。我们把根节点移除，按照相同的方法再次得到最值，依次类推，直到剩下一个元素位置。算法时间复杂度是O(n*logn)。8 基数排序基数排序和后面要说的计数排序，桶排序都是非比较排序，因此他们能够突破比较排序的时间上限O(n*logn)，达到时间复杂度为)O(n)的程度，但是这几种排序都有限制性条件，不能看到他们的时间复杂付貌似比别的低一个等级就觉得他们是最好的排序算法了。三者的思想类似，都是用到了桶的概念。基数排序针对的是非负整数，将所有的数字依次比

5、较个位，十位，百位，直到最高位，每一次比较都能得到一个排序，由于越往高位，这个位上数字影响权重越大，所以能够起到对前面顺序的修正。9 计数排序计数排序的思想也很简单，就是针对所有的整数。取一个从最小值到最大值的间隔，然后遍历数组，把当前元素放在下标为（当前元素值 - 最小值）的位置。是不是很简单啊，编程玩的就是思想，没有思想的程序员就不是真正的程序员。10 桶排序说到最后最后终于说到桶排序了。桶排序的思想就是先把数据分成一个个分组，这一个个分组就是一个个桶，当然这些桶是有顺序的，要不然桶排序作为非比较排序算法，连唯一的顺序都没有并且也不比较还排什么序啊。对于首次分桶后的数据可以采用递归或者其他

6、的排序算法实现对每个桶内数据排序。最后按照桶号将所有数据依次连接就是拍完顺序的数据了。二 算法实现常言道光说不练假把式，这里肯定要把实现代码贴出来了。1 选择排序void selectsort(int *pData,int left,int right)int i,j,temp;int tb;for(i=left;i<right-1;i+)temp = i;for(j=i+1;j<right;j+)if(pDataj<pDatatemp)temp = j;if(i != temp )tb = pDatatemp;pDatatemp = pDatai;pDatai = tb;2

7、 冒泡排序void bubblesort(int *pData,int left,int right)int i,j;int temp;for(i=left;i<right-1;i+)for(j=left;j<right-i-1;j+)if(pDataj+1<pDataj)temp = pDataj+1;pDataj+1 = pDataj;pDataj = temp;3 插入排序void insertsort(int *pData,int left,int right)int i,j;int temp;for(i=left+1;i<right;i+)temp = pDa

8、tai;j = i;while(-j>=left && pDataj>temp)pDataj+1 = pDataj;pDataj+1 =temp;4 希尔排序void shellsort(int *pData,int left,int right)int i,j,gap;int temp;for(gap=right/2;gap>0;gap/=2)for(i=gap;i<right;i+)temp = pDatai;for(j=i-gap;(j>=0)&&pDataj>temp;j-=gap)pDataj+gap = pData

9、j;pDataj+gap = temp;5 快速排序三种实现方式（1）游标为最左边元素void quicksort(int *pData,int left,int right) int i,j,middle,temp; middle = pDataleft; i = left + 1; j = right - 1; do  while( i<right && pDatai<middle)   i+;  while( j>left &&

10、amp; pDataj>middle)   j-;  if(i >= j)   break;  temp = pDatai;  pDatai = pDataj;  pDataj = temp;  i+;  j-; while(i<=j); pDataleft = pDataj; pDataj = middle; if(left<j-1) 

11、60;quicksort(pData,left,j); if(right>j+1)  quicksort(pData,j+1,right);（2）游标为中间元素void quicksort2(int *pData,int left,int right)int i,j,middle,temp;i = left;j = right - 1;middle = pData(i + j)/2;dowhile(i<right && pDatai<middle)i+;while(j>left && pDataj>mi

12、ddle)j-;if(i>=j)break;temp = pDatai;pDatai = pDataj;pDataj = temp;i+;j-;while(i<j);if(left<i-1)quicksort2(pData,left,i);if(right>i+2)quicksort2(pData,i,right);（3）游标为最后元素 void quicksort3(int *pData,int left,int right)int i,j,last;int temp,end;i = left;j = left;last = right - 1;end =

13、pDatalast;/分配初始的i，jif(pDataleft<end)while( pData+j<end );if(j = last)quicksort3(pData,left,right-1);return;elsei = j-1;elsewhile( pData+j>end );temp = pDataj;pDataj = pDataleft;pDataleft = temp;if(j = last)quicksort3(pData,left+1,right);return;/分治排序while(j<last-1)j+;if(pDataj<end)temp

14、 = pDataj;pDataj = pData+i;pDatai = temp;temp = end;pDatalast = pDatai+1;pDatai+1 = temp;if(left<i)quicksort3(pData,left,i+1);if(right>i+3)quicksort3(pData,i+2,right);6 归并排序（1）递归法实现void mergesort2(int *pData,int *Des,int left,int right)int first = left;int last  = right-1;if(first<last

15、)int mid = (first + last)/2;mergesort2(pData,Des,first,mid+1);mergesort2(pData,Des,mid+1,right);merges(pData,Des,first,mid,last);void merges(int *pData,int *Des,int first,int mid,int last)int i = first;int j = mid + 1;int k = first;while(i<=mid&&j<=last)if(pDatai<pDataj)Desk+ = pDat

16、ai+;elseDesk+ = pDataj+;while(i<=mid)Desk+ = pDatai+;while(j<=last)Desk+ = pDataj+;for(k=first;k<=last;k+)pDatak = Desk; （2）非递归法实现void mergesort3(int *list,int length)int i, left_min, left_max, right_min, right_max, next;    int *tmp = (int*)malloc(sizeof(int) * length); 

17、;   if (tmp = NULL)        fputs("Error: out of memoryn", stderr);        abort();        for (i = 1; i < length; i *= 2)            for (left_min = 0; left_min < length - i; left_min = rig

18、ht_max)                 right_min = left_max = left_min + i;                right_max = left_max + i;                if (right_max > length)        

19、0;               right_max = length;                next = 0;                while (left_min < left_max && right_min < right_max)           

20、            tmpnext+ = listleft_min > listright_min ? listright_min+ : listleft_min+;                while (left_min < left_max)                        list-right_m

21、in = list-left_max;                while (next > 0)                        list-right_min = tmp-next;                free(tmp); 7 堆排序void HeapAdjust(int

22、 array, int i, int nLength)int nchild;int ntemp;while(i>=0)nchild = 2 * i + 1;ntemp = arrayi;if (arraynchild<ntemp)ntemp = arraynchild;arraynchild = arrayi;arrayi = ntemp;if (nchild < nLength - 1)nchild+;if (arraynchild<ntemp)ntemp = arraynchild;arraynchild = arrayi;arrayi = ntemp;i-;/ 堆

23、排序算法void HeapSort(int array,int length)int i,temp;for (int nL = length; nL>0;nL-)i = nL/2 - 1;HeapAdjust(array,i,nL);temp = array0;array0 = arraynL-1;arraynL-1 = temp;8 基数排序#include <iostream>using namespace std;const int base=10;struct wxint num;wx *next;wx()next=NULL;wx *headn,*curn,*boxb

24、ase,*curboxbase;void basesort(int t)int i,k=1,r,bn;/ k,r 分别表示10的幂次方，用来得到相应位上的单个数字，比如 k=10，r=100，数字207，则 十位上 0 = /(207/r)%10 for(i=1;i<=t;i+)k*=base;r=k*base;/curbox和box中的指针指向相同的位置，当curbox中有新元素时，curbox指向会发生变化，形成box元素为/头指针，curbox元素相当于滑动指针，这样可以通过比较两者的不同来判断指针的走向。for(i=0;i<base;i+)curboxi

25、=boxi; for(curn=headn->next;curn!=NULL;curn=curn->next)                 bn=(curn->num%r)/k;               / bn表示元素相应位上的值，curboxbn->ne

26、xt=curn;             /curboxi的next指向相应位为i的元素curboxbn=curboxbn->next;    /此时curboxi向后移位，以boxi为首的链表长度增加curn=headn;for(i=0;i<base;i+)if(curboxi!=boxi)curn->next=boxi->next;curn=curboxi;    &#

27、160;   /curn此时指向了在box中具有相同值的链表的最后一个，例如 123，/33，783，67，56，在3开头的 元素链表中，此时cur指向了783。curn->next=NULL;void printwx()for(curn=headn->next;curn!=NULL;curn=curn->next)cout<<curn->num<<' 'cout<<endl;int main()int i,n,z=0,maxn=0;curn=headn=new wx;cin>>n;fo

28、r(i=0;i<base;i+)curboxi=boxi=new wx;for(i=1;i<=n;i+)curn=curn->next=new wx;cin>>curn->num;maxn=max(maxn,curn->num);while(maxn/base>0)maxn/=base;z+;for(i=0;i<=z;i+)basesort(i);printwx();return 0; 9 计数排序void CountSort(int array,int nLength)int nMin,nMax;nMin = INT_MAX;n

29、Max = 0;for(int i=0;i<nLength;i+)if (nMax<arrayi)nMax = arrayi;if (nMin>arrayi)nMin = arrayi;int nSize = nMax - nMin + 1;int *Count = NULL;int *Sort  = NULL;Count = (int *)malloc( sizeof(int) * nSize );Sort  = (int *)malloc( sizeof(int) * nLength);int j;for (j=0;j<nSize;j+)Coun

30、tj  = 0;for (j=0;j<nLength;j+)Countarrayj - nMin+;for (j=0;j<nSize-1;j+)Countj+1 += Countj;for (j=nLength-1;j>=0;j-)SortCount arrayj-nMin -1 = arrayj;Countarrayj - nMin-;for (j=0;j<nLength;j+)arrayj = Sortj;free(Count);free(Sort); 10 桶排序 /文件1#ifndef D_BUCKET_H#define D_BUC

31、KET_H#include<cstdlib>#include<climits>using namespace std;void BucketSort(int array,int nLength,int nDivide);struct bucketint key;bucket *next;#endif/文件2#include"bucket.h"void BucketSort(int arr,int nLength,int nDivide)bucket *Box = (bucket*)malloc( sizeof(bucket*) * nDivide )

32、;for(int i =0;i<nDivide;i+)Boxi = (bucket*)malloc( sizeof(bucket) );Boxi->key = 0;Boxi->next = NULL;/ Find the Max and Min in the arrayint nMin = INT_MAX;int nMax = INT_MIN;int nPie,nLeft;for(int i = 0;i<nLength;i+)nMin = (nMin<arri)?nMin:arri;nMax = (nMax>arri)?nMax:arri;nLeft = (

33、nMax - nMin + 1) % nDivide;if(nLeft = 0)nPie = (nMax - nMin + 1) / nDivide;elsenPie = (nMax - nMin + 1) /(nDivide - 1);/Insert the element in bucketfor(int i = 0;i<nLength;i+)bucket *node = (bucket*)malloc(sizeof(bucket);node->key = arri;node->next = NULL;int nId = (arri - nMin) / nPie;if(BoxnId->key = 0)BoxnId->next = node;BoxnId->key+;elsebucket *p = BoxnId->next;bucket *cu