常用排序方法

冒泡排序

算法思想很简单，通过两两比较，不断把较大的那个挤向边沿，形成有序序列。

是稳定的排序，即排序后相同数值的元素间的序列不变。

实现简单，所需空间小，时间复杂度O(N^2)，但交换频繁。

  1. //  冒泡  升序  
  2. void bubbleSort(int* array, int len){  
  3.     for(int i = 0 ; i < len ; i++){  
  4.         for(int j = 1; j < len-i ; j++){  
  5.             if(array[j-1] > array[j]){  
  6.                 int temp = array[j-1];      //  替换  
  7.                 array[j-1] = array[j];  
  8.                 array[j] = temp;  
  9.             }  
  10.         }  
  11.     }  
  12. } 

选择排序

通过遍历未排序的序列，找出最大的元素的索引，将其与边沿的元素交换。

因为存在边沿元素被交换至前边的可能，所以该算法不是稳定的。

思想很简单，最符合人的思维模式。所需空间小，时间复杂度O(N^2)，交换次数小。

  1. // 选择 升序  
  2. void selectionSort(int* array, int len){  
  3.     for(int i = 0 ; i < len ; i++){  
  4.         int maxIndex = 0 ;                  //  索引  
  5.         for(int j = 1; j < len - i ; j++){  
  6.             if(array[j] > array[maxIndex]){  
  7.                 maxIndex = j;  
  8.             }  
  9.         }  
  10.         if(maxIndex != len - i - 1){  
  11.             int temp = array[len-i-1];      //  替换  
  12.             array[len-i-1] = array[maxIndex];  
  13.             array[maxIndex] = temp;  
  14.         }  
  15.     }  
  16. }  

插入排序

通过将待排序的序列一个个地插入到已排序序列合适的位置实现的算法。

按照顺序插入，能够保证相同数值元素间的序列不变，是稳定的。

所需空间小，时间复杂度O(N^2)，但交换次数多，需频繁挪动已排序的序列。

  1. //  插入  升序  
  2. void insertionSort(int* array, int len){  
  3.     for(int i = 1 ; i < len ; i++){  
  4.         for(int j = i ; j > 0 ; j--){  
  5.             if(array[j] >= array[j-1]){  
  6.                 break;  
  7.             }  
  8.             int temp;                        //  向前  插入  
  9.             temp = array[j];  
  10.             array[j] = array[j-1];  
  11.             array[j-1] = temp;  
  12.         }  
  13.     }  
  14. }  

计数排序

顾名思义，该算法是基于计数而非比较的。通过将具有相同数值的元素个数计算起来，再从头重构起整一个已排序序列。

局限性大，只能排列整数序列，需要明确知道序列的范围大小，且范围不能太大。

但在范围较小的整数序列中，优势很明显，就是快。空间复杂度O(M)（M为范围大小），时间复杂度O(N+M)。

  1. //  计数 升序  
  2. //  排序 数值范围[0, 99]  
  3. int countingArray[100];  
  4. void countingSort(int* array, int len){  
  5.     //  每次调用需保证countArray 数组元素均为0  
  6.     for(int i = 0 ; i < len ; i++){  
  7.         countingArray[array[i]]++;           //  计数  
  8.     }  
  9.     int index = 0 ;  
  10.     for(int i = 0 ; i < 100; ){  
  11.         if(countingArray[i]){                //  重构  
  12.             array[index++] = i ;  
  13.             countingArray[i]--;  
  14.             if(index == len)  
  15.                 break;  
  16.         }else{  
  17.             i++;  
  18.         }  
  19.     }  
  20. }  

基数排序 

非基于比较，通过元素的每一位基数不断调整序列的算法。

基本思想为：对于每一位基数进行排序，前一位基数较大的将在以后的位数排序都处在较后的位置，直到最后一位排列完，序列将呈升序序列。

优势是快，但实现较为复杂，空间开销大，每一个基数桶子需保证能够装下整一个序列。

以下实现不具有通用性，不能随意切换radix，仅考虑使用位运算而采用二进制。

  1. //  基数 升序  
  2. //  二进制  即只有 0 1 两个桶  
  3. int radixs[2][100];  
  4. int lens[2];  
  5. void radixSort(int* array, int len){  
  6.     bool stop = false;  
  7.     int radix = 1;  
  8.     int bits = 0 ;  
  9.     while(!stop){  
  10.         stop = true;  
  11.         for(int i = 0 ; i < len ; i++){      //  分类  
  12.             int itsRadix = (array[i] & radix) >> bits;  
  13.             radixs[itsRadix][lens[itsRadix]++] = array[i];  
  14.             stop = array[i] > (1 << bits) ? false:stop;             //  退出  
  15.         }  
  16.         int index = 0;  
  17.         for(int i = 0; i < 2 ; i++){        //  重构  
  18.             for(int j = 0 ; j < lens[i]; j++){  
  19.                 array[index++] = radixs[i][j];  
  20.             }  
  21.             lens[i] = 0;  
  22.         }  
  23.         radix *= 2;  
  24.         bits++;  
  25.     }  
  26. }  

 

堆排序 

基于堆的概念：小根堆——父节点永远不比子节点大。

算法两个很重要的步骤：建堆，把新来的元素放在堆的最后，然后调整堆，不断比较与父节点的大小，如果比父节点小则交换，如此操作直到不比父节点小或已到达堆顶；出堆，把处在堆顶的元素取下，把堆最后一个元素放在堆顶，然后调整堆，与最小子节点比较，若比子节点小则交换，直到符合父节点不比子节点小或没有子节点。

由于堆中最后一个元素会频繁置换到堆顶，所以不能保证稳定性。

空间复杂度O(N)，时间复杂度O(N*log(N))

 

  1. //  堆  
  2. //  小根堆  
  3. int heap[100];  
  4. void heapSort(int* array, int len){  
  5.     for(int i = 0; i < len ; i++){  
  6.         int last = i+1;  
  7.         heap[last] = array[i];               //  建堆  
  8.         while(last>>1){  
  9.             if(heap[last] < heap[last>>1]){  
  10.                 int temp = heap[last];       //  替换  
  11.                 heap[last] = heap[last>>1];  
  12.                 heap[last>>1] = temp;  
  13.             }  
  14.             last = last >> 1;  
  15.         }  
  16.     }  
  17.   
  18.     int heapLen = len;  
  19.     for(int i = 0 ; i < len; i++){  
  20.         array[i] = heap[1];                  //  出堆  
  21.         heap[1] = heap[heapLen--];  
  22.         int last = 1;  
  23.         while((last << 1) <= heapLen){  
  24.             int max = last << 1;  
  25.             if(max+1<=heapLen && heap[max] > heap[max+1]){  
  26.                 max++;                      //  最小子节点  
  27.             }  
  28.             if(heap[last] > heap[max]){  
  29.                 int temp = heap[last];  
  30.                 heap[last] = heap[max];  
  31.                 heap[max] = temp;  
  32.                 last = last << 1;  
  33.             }else{  
  34.                 break;  
  35.             }  
  36.         }  
  37.     }  
  38.   
  39. }  

 

归并排序

如果对递归非常了解的话，该排序思想是十分简单明了的。

通过将序列分成两部分，各自分给下级完成那部分的排序工作，当两部分都完成后，再在这级将两部分合并成有序序列，交付给上级。

由于两部分都是有序序列，所以合并起来的时候能够减少很多比较，从而节省了时间，并且保证稳定性。

时间复杂度O(N*log(N))

 

 
  1. //  归并  
  2. void mergeSort(int* array, int len){  
  3.     if(len == 1){  
  4.         return;  
  5.     }else if(len == 2){  
  6.         if(array[0] > array[1]){  
  7.             int temp = array[0];  
  8.             array[0] = array[1];  
  9.             array[1] = temp;  
  10.         }  
  11.         return;  
  12.     }else{  
  13.         int leftLen = len / 2 ;  
  14.         mergeSort(array,leftLen);                  //  递归   左  
  15.         mergeSort(&array[leftLen],len-leftLen);    //  右  
  16.   
  17.         //合并  
  18.         int* tempArray = new int[len];  
  19.         int left = 0;  
  20.         int right = leftLen;  
  21.         for(int i = 0 ; i < len; i++){             //  合并  
  22.             if(array[left] > array[right]){  
  23.                 tempArray[i] = array[right++];  
  24.                 if(right == len){  
  25.                     for(int j = left ; j < leftLen; j++){  
  26.                         tempArray[++i] = array[j];  
  27.                     }  
  28.                 }  
  29.             }else{  
  30.                 tempArray[i] = array[left++];  
  31.                 if(left == leftLen){  
  32.                     for(int j = right; j < len ; j++){  
  33.                         tempArray[++i] = array[j];  
  34.                     }  
  35.                 }  
  36.             }  
  37.         }  
  38.   
  39.         for(int i = 0 ; i < len ; i++)             //  copy  
  40.             array[i] = tempArray[i];  
  41.   
  42.         delete [] tempArray;  
  43.     }  
  44. }  

 快速排序

与归并排序类似的思想，但实现却相反的算法。在序列中选定一个pivotpos索引，然后将该序列逐一与该pivotpos索引下的数值比较，比它小放置在左边，比它大的放置右边，pivotpos放置在中间（非绝对中间，比它小的元素和比它大的元素的中间），然后将左边和中间的序列交给下级，右边的交给另一个下级。

时间复杂度为O(N*log(N))，但相比归并，快排的递归放在尾部，因此对栈的压力比归并大。但是在进行序列操作的时候，快排显得更自然，而归并在合并两个序列的时候，逻辑会更复杂一些。

 

    1. //  快排  
    2. void quickSort(int* array, int len){  
    3.     if(len == 1 || len == 0){  
    4.         return;  
    5.     }else if(len == 2){  
    6.         if(array[0] > array[1]){  
    7.             int temp = array[0];  
    8.             array[0] = array[1];  
    9.             array[1] = temp;  
    10.         }  
    11.         return;  
    12.     }else{  
    13.         int pivotpos = 0;  
    14.         int last = len-1;  
    15.         int* tempArray = new int[len];  
    16.         for(int i = 1; i < len ; i ++){  
    17.             if(array[i] > array[0] ){        //  分类  
    18.                 tempArray[last--] = array[i];  
    19.             }else{  
    20.                 tempArray[pivotpos++] = array[i];  
    21.             }  
    22.         }  
    23.         tempArray[pivotpos] = array[0];     //基点  
    24.   
    25.         for(int i = 0 ; i < len ; i++){  
    26.             array[i] = tempArray[i];  
    27.         }  
    28.         delete [] tempArray;  
    29.         quickSort(array,pivotpos+1);                     //  左  
    30.         quickSort(&array[pivotpos+1],len-pivotpos-1);      //  右  
    31.     }  
    32. }  

 

posted @ 2017-06-29 10:47  florence1995  阅读(545)  评论(1)    收藏  举报