12种排序算法：原理、图解、动画视频演示、代码以及笔试面试题目中的应用

从这一部分开始直接切入我们计算机互联网笔试面试中的重头戏算法了，初始的想法是找一条主线，比如数据结构或者解题思路方法，将博主见过做过整理过的算法题逐个分析一遍(博主当年自己学算法就是用这种比较笨的刷题学的，囧)，不过又想了想，算法这东西，博主自己学的过程中一直深感，基础还是非常重要的，很多难题是基础类数据结构和题目的思想综合发散而来。比如说作为最基本的排序算法就种类很多，而事实上笔试面试过程中发现掌握的程度很一般，有很多题目，包括很多算法难题，其母题或者基本思想就是基于这些经典算法的，比如说快排的partition算法，比如说归并排序中的思想，比如说桶排序中桶的思想。
        这里对笔试面试最常涉及到的12种排序算法(包括 插入排序、二分插入排序、希尔排序、选择排序、冒泡排序、鸡尾酒排序、快速排序、堆排序、归并排序、桶排序、计数排序和基数排序 )进行了详解。每一种算法都有 基本介绍、算法原理分析、图解/flash演示/视频演示、算法代码、笔试面试重点分析、笔试面试题 等板块，希望能帮助大家真正理解这些排序算法，并能使用这些算法的思想解决一些题。不多说了，下面就进入正题了。

一、插入排序

1）算法简介

        插入排序（Insertion Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

2）算法描述和分析

    一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

    1、从第一个元素开始，该元素可以认为已经被排序

    2、取出下一个元素，在已经排序的元素序列中从后向前扫描

    3、如果该元素（已排序）大于新元素，将该元素移到下一位置

    4、重复步骤3，直到找到已排序的元素小于或者等于新元素的位置

    5、将新元素插入到该位置后

    6、重复步骤2~5

        如果目标是把n个元素的序列升序排列，那么采用插入排序存在最好情况和最坏情况。最好情况就是，序列已经是升序排列了，在这种情况下，需要进行的比较操作需(n-1)次即可。最坏情况就是，序列是降序排列，那么此时需要进行的比较共有n(n-1)/2次。插入排序的赋值操作是比较操作的次数减去(n-1)次。平均来说插入排序算法复杂度为O(n^2)。因而，插入排序不适合对于数据量比较大的排序应用。但是，如果需要排序的数据量很小，例如，量级小于千，那么插入排序还是一个不错的选择。 插入排序在工业级库中也有着广泛的应用，在STL的sort算法和stdlib的qsort算法中，都将插入排序作为快速排序的补充，用于少量元素的排序（通常为8个或以下）。

3）算法图解、flash演示、视频演示

图解：

Flash：

http://www.tjbpi.com/jpk/shujujiegou/flash/%B5%DA%CA%AE%D2%BB%D5%C2%20%C5%C5%D0%F2/%D6%B1%BD%D3%B2%E5%C8%EB%C5%C5%D0%F2.swf

视频：插入排序舞蹈

http://v.youku.com/v_show/id_XMjU4NTY5MzEy.html

4）算法代码

 void insertion_sort(int array[], int first, int last)
  {
         int i,j;
         int temp;
         for (i = first+1; i<=last;i++)
         {
                 temp = array[i];
                 j=i-1;

                 //与已排序的数逐一比较，大于temp时，该数后移
                 while((j>=first) && (array[j] > temp))  //当first=0，j循环到-1时，由于[[短路求值]]，不会运算array[-1]
                 {
                         array[j+1] = array[j];
                         j--;
                 }
                 array[j+1] = temp;      //被排序数放到正确的位置

         }
  }

 5）考察点，重点和频度分析

        把插入排序放在第一个的原因是因为其出现的频度不高，尤其是这里提到的直接排序算法，基本在笔试的选择填空问时间空间复杂度的时候才可能出现。毕竟排序速度比较慢，因此算法大题中考察的次数比较比较少。

6）笔试面试例题

例题1、

请写出链表的插入排序程序

 template<typename T>
 struct list_node
 {
     struct list_node *next;
     T value;
 };
 template<typename T>
 struct _list
 {
     struct list_node *head;
     int size;
 };
 template<typename T>
 void SortLink(struct _list * link) {
     struct list_node *pHead,*pRear,*p,*tp;
     if (!link) return;
     for (pHead=link->head,pRear=0;pHead;pHead=pHead->next) {
         for (tp=pHead,p=pHead->next;p;tp=p,p=p->next)
             if (pHead->value>=p->value)
                 tp->next=p->next,p->next=pHead,pHead=p,p=tp;
         if (!pRear) link->head=pHead;
         else pRear->next=pHead;
         pRear=pHead;
     }
 }

例题2、

下列排序算法中最坏复杂度不是n(n-1)/2的是 D

A.快速排序     B.冒泡排序   C.直接插入排序   D.堆排序

二、二分插入排序

1）算法简介

       二分（折半）插入（Binary insert sort)排序是一种在直接插入排序算法上进行小改动的排序算法。其与直接排序算法最大的区别在于查找插入位置时使用的是二分查找的方式，在速度上有一定提升。

2）算法描述和分析

    一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

    1、从第一个元素开始，该元素可以认为已经被排序

    2、取出下一个元素，在已经排序的元素序列中二分查找到第一个比它大的数的位置

    3、将新元素插入到该位置后

    4、重复上述两步

        1）稳定

        2）空间代价：O(1)

        3）时间代价：插入每个记录需要O(log i)比较，最多移动i+1次，最少2次。最佳情况O(n log n)，最差和平均情况O(n^2)。

        二分插入排序是一种稳定的排序。当n较大时，总排序码比较次数比直接插入排序的最差情况好得多，但比最好情况要差，所元素初始序列已经按排序码接近有序时，直接插入排序比二分插入排序比较次数少。二分插入排序元素移动次数与直接插入排序相同，依赖于元素初始序列。

3）算法图解、flash演示、视频演示

图解：

                                                          

视频：二分插入排序

http://v.youku.com/v_show/id_XMTA1MTkwMTEy.html

4）算法代码

 void BinInsertSort(int a[], int n)
 {
         int key, left, right, middle;
         for (int i=1; i
         {
                 key = a[i];
                 left = 0;
                 right = i-1;
                 while (left<=right)
                 {
                         middle = (left+right)/2;
                         if (a[middle]>key)
                                 right = middle-1;
                         else
                                 left = middle+1;
                 }

                 for(int j=i-1; j>=left; j--)
                 {
                         a[j+1] = a[j];
                 }

                 a[left] = key;
         }
 }

 5）考察点，重点和频度分析

        这个排序算法在笔试面试中出现的频度也不高，但毕竟是直接排序算法的一个小改进算法，同时二分查找又是很好的思想，有可能会在面试的时候提到，算法不难，留心一下就会了。

6）笔试面试例题

例题1、

下面的排序算法中，初始数据集的排列顺序对算法的性能无影响的是（B）

A、二分插入排序         B、堆排序         C、冒泡排序            D、快速排序

例题2、

写出下列算法的时间复杂度。

(1)冒泡排序；(2)选择排序；(3)插入排序；(4)二分插入排序；(5)快速排序；(6)堆排序；(7)归并排序；

三、希尔排序

1）算法简介

希尔排序，也称递减增量排序算法，因DL．Shell于1959年提出而得名，是插入排序的一种高速而稳定的改进版本。

2）算法描述

    1、先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组。

    2、所有距离为d1的倍数的记录放在同一个组中，在各组内进行直接插入排序。

    3、取第二个增量d2

    4、直至所取的增量dt=1(dt

          希尔排序的时间复杂度与增量序列的选取有关，例如希尔增量时间复杂度为O(n^2)，而Hibbard增量的希尔排序的时间复杂度为O(N^(5/4))，但是现今仍然没有人能找出希尔排序的精确下界。

3）算法图解、flash演示、视频演示

图解：

Flash：

http://ds.fzu.edu.cn/fine/resources/FlashContent.asp?id=92

视频：希尔排序Shell Sort 舞蹈

http://v.youku.com/v_show/id_XMjU4NTcwMDIw.html

4）算法代码

 #include

 int main()
 {
      const int n = 5;
      int i, j, temp;
      int gap = 0;
      int a[] = {5, 4, 3, 2, 1};
      while (gap<=n)
      {
           gap = gap * 3 + 1;
      }
      while (gap > 0)
      {
          for ( i = gap; i < n; i++ )
          {
              j = i - gap;
              temp = a[i];
              while (( j >= 0 ) && ( a[j] > temp ))
              {
                  a[j + gap] = a[j];
                  j = j - gap;
              }
              a[j + gap] = temp;
          }
          gap = ( gap - 1 ) / 3;
      }
  }

5）考察点，重点和频度分析

        事实上希尔排序算法在笔试面试中出现的频度也不比直接插入排序高，但它的时间复杂度并不是一个定值，所以偶尔会被面试官问到选择的步长和时间复杂度的关系，要稍微有点了解吧。算法大题中使用该方法或者其思想的题也不多。

6）笔试面试例题

例题1、

写出希尔排序算法程序，并说明最坏的情况下需要进行多少次的比较和交换。

    程序略，需要O(n^2)次的比较

例题2、

设要将序列（Q, H, C, Y, P, A, M, S, R, D, F, X）中的关键码按字母序的升序重新排列，则：

冒泡排序一趟扫描的结果是       H, C, Q, P, A, M, S, R, D, F, X ,Y      ；

初始步长为4的希尔（shell）排序一趟的结果是   P, A, C, S, Q, D, F, X , R, H,M, Y     ；

二路归并排序一趟扫描的结果是   H, Q, C, Y，A, P, M, S, D, R, F, X   ；

快速排序一趟扫描的结果是     F, H, C, D, P, A, M, Q, R, S, Y，X     ；

堆排序初始建堆的结果是   A, D, C, R, F, Q, M, S, Y，P, H, X   。

四、选择排序

1）算法简介

       选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

2）算法描述和分析

       n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果：

       1、初始状态：无序区为R[1..n]，有序区为空。

       2、第i趟排序(i=1,2,3...n-1)

第i趟排序开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

       3、前n-1趟结束，数组有序化了

        选择排序的交换操作介于0和(n-1)次之间。选择排序的比较操作为n(n-1)/2次之间。选择排序的赋值操作介于0和3(n-1)次之间。比较次数O(n^2),比较次数与关键字的初始状态无关，总的比较次数N=(n-1)+(n-2)+...+1=n*(n-1)/2。 交换次数O(n),最好情况是，已经有序，交换0次；最坏情况是，逆序，交换n-1次。 交换次数比冒泡排序少多了，由于交换所需CPU时间比比较所需的CPU时间多，n值较小时，选择排序比冒泡排序快。

最差时间复杂度	О(n²)
最优时间复杂度	О(n²)
平均时间复杂度	О(n²)
最差空间复杂度	О(n) total, O(1)

3）算法图解、flash演示、视频演示

图解：

Flash：

http://ds.fzu.edu.cn/fine/resources/FlashContent.asp?id=85

视频：选择排序Select Sort排序舞蹈

http://v.youku.com/v_show/id_XMjU4NTY5NTcy.html

4）算法代码

 void selection_sort(int *a, int len)
 {
     register int i, j, min, t;
     for(i = 0; i < len - 1; i ++)
     {
         min = i;
         //查找最小值
         for(j = i + 1; j < len; j ++)
             if(a[min] > a[j])
                 min = j;
         //交换
         if(min != i)
         {
             t = a[min];
             a[min] = a[i];
             a[i] = t;
         }
     }
 }

5）考察点，重点和频度分析

        就博主看过的笔试面试题而言，选择算法也大多出现在选择填空中，要熟悉其时间和空间复杂度，最好最坏的情况分别是什么，以及在那种情况下，每一轮的比较次数等。

6）笔试面试例题

例题1、

在插入和选择排序中，若初始数据基本正序，则选用 插入排序（到尾部）   ；若初始数据基本反序，则选用   选择排序     。

例题2、

 下述几种排序方法中，平均查找长度（ASL）最小的是
Ａ. 插入排序      Ｂ.快速排序        Ｃ. 归并排序       Ｄ. 选择排序

五、冒泡排序

1）算法简介

        冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

2）算法描述

      1、比较相邻的元素。如果第一个比第二个大，就交换他们两个。

      2、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

      3、针对所有的元素重复以上的步骤，除了最后一个。

      4、持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

       冒泡排序是与插入排序拥有相等的执行时间，但是两种法在需要的交换次数却很大地不同。在最坏的情况，冒泡排序需要O(n^2)次交换，而插入排序只要最多O(n)交换。冒泡排序的实现（类似下面）通常会对已经排序好的数列拙劣地执行（O(n^2)），而插入排序在这个例子只需要O(n)个运算。因此很多现代的算法教科书避免使用冒泡排序，而用插入排序取代之。冒泡排序如果能在内部循环第一次执行时，使用一个旗标来表示有无需要交换的可能，也有可能把最好的复杂度降低到O(n)。在这个情况，在已经排序好的数列就无交换的需要。若在每次走访数列时，把走访顺序和比较大小反过来，也可以稍微地改进效率。有时候称为往返排序，因为算法会从数列的一端到另一端之间穿梭往返。

最差时间复杂度	O(n^2)
最优时间复杂度	O(n)
平均时间复杂度	O(n^2)
最差空间复杂度	总共O(n)，需要辅助空间O(1)

3）算法图解、flash演示、视频演示

图解：

Flash：

http://student.zjzk.cn/course_ware/data_structure/web/flashhtml/maopaopaixu.htm

视频：舞动的排序算法 冒泡排序

http://v.youku.com/v_show/id_XMzMyOTAyMzQ0.html

4）算法代码

 #include
 void bubbleSort(int arr[], int count)
   {
       int i = count, j;
       int temp;

       while(i > 0)
       {
          for(j = 0; j < i - 1; j++)
          {
              if(arr[j] > arr[j + 1])
              {   temp = arr[j];
                  arr[j] = arr[j + 1];
                  arr[j + 1] = temp;
              }
          }
          i--;
      }

  }

  int main()
  {
      //测试数据
      int arr[] = {5, 4, 1, 3, 6};
      //冒泡排序
      bubbleSort(arr, 5);
      //打印排序结果
      int i;
      for(i = 0; i < 5; i++)
          printf("%4d", arr[i]);
 }

5）考察点，重点和频度分析

       一般我们学到的第一个排序算法就是冒泡排序，不得不说，这个还真是一个很常见的考点，平均时间空间复杂度，最好最坏情况下的时间空间复杂度，在不同情况下每一趟的比较次数，以及加标志位减少比较次数等，都是需要注意的地方。

6）笔试面试例题

例题1、

对于整数序列100，99，98，…3，2，1，如果将它完全倒过来，分别用冒泡排序，它们的比较次数和交换次数各是多少？
     答：冒泡排序的比较和交换次数将最大，都是1+2+…+n-1=n(n-1)/2＝50×99=4545次。

例题2、

   把一个字符串的大写字母放到字符串的后面，各个字符的相对位置不变，不能申请额外的空间。

      事实上，这道题放到冒泡排序这里不知道是不是特别合适，只是有一种解法是类似冒泡的思想，如下解法一

      解法一、

每次遇到大写字母就往后冒，最后结果即为所求

 #include
 #include
 //题目以及要求：把一个字符串的大写字母放到字符串的后面，
 //各个字符的相对位置不变，不能申请额外的空间。
 //判断是不是大写字母
 int isUpperAlpha(char c){
 if(c >= 'A' && c <= 'Z'){
 return 1;
 }
 return 0;
 }
 //交换两个字母
 void swap(char *a, char *b){
 char temp = *a;
 *a = *b;
 *b = temp;
 }
 char * mySort(char *arr, int len){
 if(arr == NULL || len <= 0){
 return NULL;
 }
 int i = 0, j = 0, k = 0;
 for(i = 0; i < len; i++){
 for(j = len - 1 - i; j >= 0; j--){
 if(isUpperAlpha(arr[j])){
 for(k = j; k < len - i - 1; k++){
 swap(&arr[k], &arr[k + 1]);
 }
 break;
 }
 //遍历完了字符数组，但是没发现大写字母，所以没必要再遍历下去
 if(j == 0 && !isUpperAlpha(arr[j])){
 //结束;
                            return arr;
 }
 }
 }
 //over:
 return arr;
 }
 int main(){
 char arr[] = "aaaaaaaaaaaaaaaaaaaaaaaAbcAdeBbDc";
 printf("%s\n", mySort(arr, strlen(arr)));
 return 0;
 }

解法二。

步骤如下

1、两个指针p1和p2，从后往前扫描

2、p1遇到一个小写字母时停下， p2遇到大写字母时停下，两者所指向的char交换

3、p1， p2同时往前一格

代码如下：

 #include
 #include
 //判断是不是大写字母
 int isUpperAlpha(char c){
 if(c >= 'A' && c <= 'Z'){
 return 1;
 }
 return 0;
 }
 //交换两个字母
 void swap(char *a, char *b){
 char temp = *a;
 *a = *b;
 *b = temp;
 }
 char * Reorder(char *arr, int len){
 if(arr == NULL || len <= 0){
 return NULL;
 }
 int *p1 = arr;
 int *p2 = arr;
 While(p1
 While( isUpperAlpha(*p1) ){
 P1++;
 }
 While( !isUpperAlpha(*p2) ){
 P2++;
 }
 swap(p1, p2)
 }
 //结束
 return arr;
 }
 int main(){
 char arr[] = "aaaaaaaaaaaaaaaaaaaaaaaAbcAdeBbDc";
 printf("%s\n", Reorder(arr, strlen(arr)));
 return 0;
 }

六、鸡尾酒排序/双向冒泡排序

1）算法简介

        鸡尾酒排序等于是冒泡排序的轻微变形。不同的地方在于从低到高然后从高到低，而冒泡排序则仅从低到高去比较序列里的每个元素。他可以得到比冒泡排序稍微好一点的效能，原因是冒泡排序只从一个方向进行比对(由低到高)，每次循环只移动一个项目。

2）算法描述和分析

     1、依次比较相邻的两个数，将小数放在前面，大数放在后面；

     2、第一趟可得到：将最大数放到最后一位。

     3、第二趟可得到：将第二大的数放到倒数第二位。

     4、如此下去，重复以上过程，直至最终完成排序。

    鸡尾酒排序最糟或是平均所花费的次数都是O(n^2)，但如果序列在一开始已经大部分排序过的话，会接近O(n)。

最差时间复杂度	O(n^2)
最优时间复杂度	O(n)
平均时间复杂度	O(n^2)

3）算法图解、flash演示、视频演示

图解：

Flash：

参见http://zh.wikipedia.org/zh-cn/%E9%B8%A1%E5%B0%BE%E9%85%92%E6%8E%92%E5%BA%8F右侧flash动画

4）算法代码

 void CocktailSort(int *a,int nsize)
 {
     int tail=nsize-1;
     for (int i=0;i
     {
         for (int j=tail;j>i;--j) //第一轮，先将最小的数据排到前面
         {
             if (a[j]
             {
                 int temp=a[j];
                 a[j]=a[j-1];
                 a[j-1]=temp;
             }
         }
         ++i;                    //原来i处数据已排好序，加1
         for (j=i;j//第二轮，将最大的数据排到后面
         {
             if (a[j]>a[j+1])
             {
                 int temp=a[j];
                 a[j]=a[j+1];
                 a[j+1]=temp;
             }
         }
         tail--;                 //原tail处数据也已排好序，将其减1
     }
 }

5）考察点，重点和频度分析

        鸡尾酒排序在博主印象中出现的频度也不高，用到它的算法题大题很少，选择填空出现的话多以双向冒泡排序的名称出现，注意注意时间空间复杂度，理解理解算法应该问题就不大了。

6）笔试面试例题

   考点基本类似冒泡排序，请参考上一节

七、快速排序

       恩，重头戏开始了，快速排序是各种笔试面试最爱考的排序算法之一，且排序思想在很多算法题里面被广泛使用。是需要重点掌握的排序算法。

1）算法简介

       快速排序是由东尼·霍尔所发展的一种排序算法。其基本思想是基本思想是，通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

2）算法描述和分析

快速排序使用分治法来把一个串（list）分为两个子串行（sub-lists）。

步骤为：

     1、从数列中挑出一个元素，称为 "基准"（pivot），

     2、重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。

     3、递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

    递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

算法伪代码描述：

function quicksort(q)

     var list less, pivotList, greater

     if length(q) ≤ 1 {

         return q

     } else {

         select a pivot value pivot from q

         for each x in q except the pivot element

             if x < pivot then add x to less

             if x ≥ pivot then add x to greater

         add pivot to pivotList

         return concatenate(quicksort(less), pivotList, quicksort(greater))

     }

在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n^2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。

最差时间复杂度	O(n^2)
最优时间复杂度	O(n log n)
平均时间复杂度	O(n log n)
最差空间复杂度	根据实现的方式不同而不同

3）算法图解、flash演示、视频演示

图解：

        快速排序会递归地进行很多轮，其中每一轮称之为快排的partition算法，即上述算法描述中的第2步，非常重要，且在各种笔试面试中用到该思想的算法题层出不穷，下图为第一轮的partition算法的一个示例。

Flash：

可一步步参见http://ds.fzu.edu.cn/fine/resources/FlashContent.asp?id=86中的快排过程

视频 舞动的排序算法

http://v.youku.com/v_show/id_XMzMyODk4NTQ4.html

4）算法代码

        事实上，这个地方需要提一下的是，快排有很多种版本。例如，我们“基准数”的选择方法不同就有不同的版本，但重要的是快排的思想，我们熟练掌握一种版本，在最后的笔试面试中也够用了，我这里罗列几种最有名的版本C代码。

1、版本一

我们选取数组的第一个元素作为主元，每一轮都是和第一个元素比较大小，通过交换，分成大于和小于它的前后两部分，再递归处理。

代码如下

 /**************************************************
   函数功能：对数组快速排序
   函数参数：指向整型数组arr的首指针arr；
             整型变量left和right左右边界的下标
   函数返回值：空
 /**************************************************/
 void QuickSort(int *arr, int left, int right)
 {
   int i,j;
   if(left
   {
     i=left;j=right;
     arr[0]=arr[i]; //准备以本次最左边的元素值为标准进行划分，先保存其值
     do
     {
       while(arr[j]>arr[0] && i
         j--;        //从右向左找第1个小于标准值的位置j
       if(i//找到了，位置为j
       {
         arr[i] = arr[j];
         i++;
       }           //将第j个元素置于左端并重置i
       while(arr[i]
         i++;      //从左向右找第1个大于标准值的位置i
       if(i//找到了，位置为i
       {
         arr[j] = arr[i];
         j--;
       }           //将第i个元素置于右端并重置j
     }while(i!=j);
     arr[i] = arr[0];         //将标准值放入它的最终位置,本次划分结束
     quicksort(arr, left, i-1);     //对标准值左半部递归调用本函数
     quicksort(arr, i+1, right);    //对标准值右半部递归调用本函数
   }
 }

2、版本二 

随机选基准数的快排

 //使用引用，完成两数交换
 void Swap(int& a , int& b)
 {
  int temp = a;
  a = b;
  b = temp;
 }
 //取区间内随机数的函数
 int Rand(int low, int high)
 {
  int size = hgh - low + 1;
  return  low + rand()%size;
 }
     //快排的partition算法，这里的基准数是随机选取的
 int RandPartition(int* data, int low , int high)
 {
  swap(data[rand(low,high)], data[low]);//
  int key = data[low];
  int i = low;

  for(int j=low+1; j<=high; j++)
  {
   if(data[j]<=key)
   {
    i = i+1;
    swap(data[i], data[j]);
   }
  }
  swap(data[i],data[low]);
  return i;
 }
 //递归完成快速排序
 void QuickSort(int* data, int low, int high)
 {
  if(low
  {
   int k = RandPartition(data,low,high);
   QuickSort(data,low,k-1);
   QuickSort(data,k+1,high);
  }
 }

5）考察点，重点和频度分析

       完全考察快排算法本身的题目，多出现在选择填空，基本是关于时间空间复杂度的讨论，最好最坏的情形交换次数等等。倒是快排的partition算法需要特别注意！频度极高地被使用在各种算法大题中！详见下小节列举的面试小题。

6）笔试面试例题

   这里要重点强调的是快排的partition算法，博主当年面试的时候就遇到过数道用该思路的算法题，举几道如下：

例题1、

最小的k个数，输入n个整数，找出其中最下的k个数，例如输入4、5、1、6、2、7、3、8、1、2，输出最下的4个数，则输出1、1、2、2。

        当然，博主也知道这题可以建大小为k的大顶堆，然后用堆的方法解决。

        但是这个题目可也以仿照快速排序，运用partition函数进行求解，不过我们完整的快速排序分割后要递归地对前后两段继续进行分割，而这里我们需要做的是判定分割的位置，然后再确定对前段还是后段进行分割，所以只对单侧分割即可。代码如下：

 void GetLeastNumbers_by_partition(int* input, int n, int* output, int k)
 {
     if(input == NULL || output == NULL || k > n || n <= 0 || k <= 0)
         return;
     int start = 0;
     int end = n - 1;
     int index = Partition(input, n, start, end);
     while(index != k - 1)
     {
         if(index > k - 1)
         {
             end = index - 1;
             index = Partition(input, n, start, end);
         }
         else
         {
             start = index + 1;
             index = Partition(input, n, start, end);
         }
     }
     for(int i = 0; i < k; ++i)
         output[i] = input[i];
 }

例题2、

判断数组中出现超过一半的数字

     当然，这道题很多人都见过，而且最通用的一种解法是数对对消的思路。这里只是再给大家提供一种思路，快排partition的方法在很多地方都能使用，比如这题。我们也可以选择合适的判定条件进行递归。代码如下：

 bool g_bInputInvalid = false;
 bool CheckInvalidArray(int* numbers, int length)
 {
     g_bInputInvalid = false;
     if(numbers == NULL && length <= 0)
         g_bInputInvalid = true;
     return g_bInputInvalid;
 }
 bool CheckMoreThanHalf(int* numbers, int length, int number)
 {
     int times = 0;
     for(int i = 0; i < length; ++i)
     {
         if(numbers[i] == number)
             times++;
     }
     bool isMoreThanHalf = true;
     if(times * 2 <= length)
     {
         g_bInputInvalid = true;
         isMoreThanHalf = false;
     }
     return isMoreThanHalf;
 }
 int MoreThanHalfNum_Solution1(int* numbers, int length)
 {
     if(CheckInvalidArray(numbers, length))
         return 0;
     int middle = length >> 1;
     int start = 0;
     int end = length - 1;
     int index = Partition(numbers, length, start, end);
     while(index != middle)
     {
         if(index > middle)
         {
             end = index - 1;
             index = Partition(numbers, length, start, end);
         }
         else
         {
             start = index + 1;
             index = Partition(numbers, length, start, end);
         }
     }
     int result = numbers[middle];
     if(!CheckMoreThanHalf(numbers, length, result))
         result = 0;
     return result;
 }

例题3、

有一个由大小写组成的字符串，现在需要对他进行修改，将其中的所有小写字母排在大写字母的前面(不要求保持原顺序)

        这题可能大家都能想到的方法是：设置首尾两个指针，首指针向后移动寻找大写字母，尾指针向前移动需找小写字母，找到后都停下，交换。之后继续移动，直至相遇。这种方法在这里我就不做讨论写代码了。

        但是这题也可以采用类似快排的partition。这里使用从左往后扫描的方式。字符串在调整的过程中可以分成两个部分：已排好的小写字母部分、待调整的剩余部分。用两个指针i和j，其中i指向待调整的剩余部分的第一个元素，用j指针遍历待调整的部分。当j指向一个小写字母时，交换i和j所指的元素。向前移动i、j，直到字符串末尾。代码如下：

 #include
 using namespace std;
 void Proc( char *str )
 {
 int i = 0;
 int j = 0;
 //移动指针i, 使其指向第一个大写字母
 while( str[i] != '\0' && str[i] >= 'a' && str[i] <= 'z' ) i++;
 if( str[i] != '\0' )
 {
 //指针j遍历未处理的部分，找到第一个小写字母
 for( j=i; str[j] != '\0'; j++ )
 {
 if( str[j] >= 'a' && str[j] <= 'z' )
 {
 char tmp = str[i];
 str[i] = str[j];
 str[j] = tmp;
 i++;
 }
 }
 }
 }
 int main()
 {
 char data[] = "SONGjianGoodBest";
 Proc( data );
 return 0;
 }

八、堆排序

        不得不说，堆排序太容易出现了，选择填空问答算法大题都会出现。建堆的过程，堆调整的过程，这些过程的时间复杂度，空间复杂度，以及如何应用在海量数据Top K问题中等等，都是需要重点掌握的。

1）算法简介

        堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

2）算法描述

       我们这里介绍几个问题，一步步推到堆排序的算法。

1、什么是堆？

      我们这里提到的堆一般都指的是二叉堆，它满足二个特性：

           1---父结点的键值总是大于或等于（小于或等于）任何一个子节点的键值。

           2---每个结点的左子树和右子树都是一个二叉堆（都是最大堆或最小堆）。

     如下为一个最小堆(父结点的键值总是小于任何一个子节点的键值)

2、什么是堆调整(Heap Adjust)？

        这是为了保持堆的特性而做的一个操作。对某一个节点为根的子树做堆调整，其实就是将该根节点进行“下沉”操作(具体是通过和子节点交换完成的)，一直下沉到合适的位置，使得刚才的子树满足堆的性质。

       例如对最大堆的堆调整我们会这么做：

              1、在对应的数组元素A[i], 左孩子A[LEFT(i)], 和右孩子A[RIGHT(i)]中找到最大的那一个，将其下标存储在largest中。

              2、如果A[i]已经就是最大的元素，则程序直接结束。

              3、否则，i的某个子结点为最大的元素，将A[largest]与A[i]交换。

              4、再从交换的子节点开始，重复1,2,3步，直至叶子节点，算完成一次堆调整。

       这里需要提一下的是，一般做一次堆调整的时间复杂度为log(n)。

       如下为我们对4为根节点的子树做一次堆调整的示意图，可帮我们理解。

3、如何建堆

         建堆是一个通过不断的堆调整，使得整个二叉树中的数满足堆性质的操作。在数组中的话，我们一般从下标为n/2的数开始做堆调整，一直到下标为0的数(因为下标大于n/2的数都是叶子节点，其子树已经满足堆的性质了)。下图为其一个图示：

        很明显，对叶子结点来说，可以认为它已经是一个合法的堆了即20，60， 65， 4， 49都分别是一个合法的堆。只要从A[4]=50开始向下调整就可以了。然后再取A[3]=30，A[2] = 17，A[1] = 12，A[0] = 9分别作一次向下调整操作就可以了。

4、如何进行堆排序

        堆排序是在上述3中对数组建堆的操作之后完成的。

        数组储存成堆的形式之后，第一次将A[0]与A[n - 1]交换，再对A[0…n-2]重新恢复堆。第二次将A[0]与A[n-2]交换，再对A[0…n-3]重新恢复堆，重复这样的操作直到A[0]与A[1]交换。由于每次都是将最小的数据并入到后面的有序区间，故操作完成后整个数组就有序了。

如下图所示：

最差时间复杂度	O(n log n)
最优时间复杂度	O(n log n)
平均时间复杂度	O(n log n)
最差空间复杂度	O(n)

3）算法图解、flash演示、视频演示

图解：

   略，见上一节。

Flash：

可参见http://ds.fzu.edu.cn/fine/resources/FlashContent.asp?id=88中的flash动画，帮助理解

视频 堆排序

http://v.youku.com/v_show/id_XMzQzNzAwODQ=.html

4）算法代码

   直接上代码吧，重点注意HeapAdjust，BuildHeap和HeapSort的实现。

 #include
 #include
 #include
 using namespace std;

 int parent(int);
 int left(int);
 int right(int);
 void HeapAdjust(int [], int, int);
 void BuildHeap(int [], int);
 void print(int [], int);
 void HeapSort(int [], int);

 /*返回父节点*/
 int parent(int i)
 {
     return (int)floor((i - 1) / 2);
 }

 /*返回左孩子节点*/
 int left(int i)
 {
     return (2 * i + 1);
 }

 /*返回右孩子节点*/
 int right(int i)
 {
     return (2 * i + 2);
 }

 /*对以某一节点为根的子树做堆调整(保证最大堆性质)*/
 void HeapAdjust(int A[], int i, int heap_size)
 {
     int l = left(i);
     int r = right(i);
     int largest;
     int temp;
     if(l < heap_size && A[l] > A[i])
     {
         largest = l;
     }
     else
     {
         largest = i;
     }
     if(r < heap_size && A[r] > A[largest])
     {
         largest = r;
     }
     if(largest != i)
     {
         temp = A[i];
         A[i] = A[largest];
         A[largest] = temp;
         HeapAdjust(A, largest, heap_size);
     }
 }

 /*建立最大堆*/
 void BuildHeap(int A[]，int heap_size)
 {
     for(int i = (heap_size-2)/2; i >= 0; i--)
     {
         HeapAdjust(A, i, heap_size);
     }
 }

 /*输出结果*/
 void print(int A[]， int heap_size)
 {
     for(int i = 0; i < heap_size;i++)
     {
         printf("%d ", A[i]);
     }
     printf("\n");
 }

 /*堆排序*/
 void HeapSort(int A[], int heap_size)
 {
     BuildHeap(A, heap_size);
     int temp;
     for(int i = heap_size - 1; i >= 0; i--)
     {
         temp = A[0];
         A[0] = A[i];
         A[i] = temp;
         HeapAdjust(A, 0, i);
     }
     print(A, heap_size);
 }

 /*测试，对给定数组做堆排序*/
 int main(int argc, char* argv[])
 {
     const int heap_size = 13;
     int A[] = {19, 1, 10, 14, 16, 4, 7, 9, 3, 2, 8, 5, 11};
     HeapSort(A, heap_size);
     system("pause");
     return 0;
 }

5）考察点，重点和频度分析

        堆排序相关的考察太多了，选择填空问答算法大题都会出现。建堆的过程，堆调整的过程，这些过程的时间复杂度，空间复杂度，需要比较交换多少次，以及如何应用在海量数据Top K问题中等等。堆又是一种很好做调整的结构，在算法题里面使用频度很高。

6）笔试面试题

例题1、

编写算法，从10亿个浮点数当中，选出其中最大的10000个。

   典型的Top K问题，用堆是最典型的思路。建10000个数的小顶堆，然后将10亿个数依次读取，大于堆顶，则替换堆顶，做一次堆调整。结束之后，小顶堆中存放的数即为所求。代码如下(为了方便，这里直接使用了STL容器)：

 #include "stdafx.h"
 #include
 #include
 #include
 #include  // for greater<>
 using namespace std;
 int _tmain(int argc, _TCHAR* argv[])
 {
   vector<