程序博客网 > java extends

面试算法之排序算法集锦

来源：互联网 发布：java extends 编辑：程序博客网 时间：2024/06/07 02:29

排序算法在面试过程中是经常会考的，这是很基础的，面试官觉得你应该很熟悉这些东西，如果你半个小时内写不出来，那基本就给跪了，因为这真的是狠基础狠基础的东西，所以我们得对一些基本的排序算法烂熟于胸，对这些排序思想，效率了如指掌，才能让面试官觉得你还行。基本的排序算法有：直接插入排序，冒泡排序，简单选择排序，shell排序，归并排序，快速排序，堆排序。其中归并，快速，堆排序是面试时候比较喜欢考的，因为这三个排序算法都是很重要的算法，会有很多实际的应用。下面就简单的介绍这些排序算法，并给出代码。

1.直接插入排序

直接插入排序的思想很简单，就是从排序序列开始，依次将每个元素插入到前面已经排序好的序列中，最终使整个序列有序，直接插入排序的时间复杂度O(n^2)，空间复杂度为O(1)，代码如下：

  1. /** 
  2. * Time Complexity:O(n^2)
  3. * Space Complexity:O(1)
  4. * 
  5. * sorted data ; array[low...high]
  6. */
  7. template <typename Type>
  8. void DirectInsertSort(Type array[], int low, int high)
  9. {
  10.     if (array == NULL || low >= high || low < 0)
  11.     {
  12.         return;
  13.     }

  15.     Type exchange;
  16.     int j;

  18.     for (int i = low + 1; i <= high; ++i)
  19.     {
  20.         exchange = array[i];
  21.         
  22.         for (j = i - 1; j >= low; --j)
  23.         {
  24.             if (exchange < array[j])
  25.             {
  26.                 array[j + 1] = array[j];
  27.             }
  28.             else
  29.             {
  30.                 break;
  31.             }
  32.         }

  34.         array[j + 1] = exchange;
  35.     }
  36. }
复制代码
2.冒泡排序我们对冒泡排序应该都比较深，因为这个名字很形象很好记 。排序的思想就是每个冒泡一遍序列，找出一个最大或最小的元素，放到它排序后的位置上直到序列有序。时间复杂度O(n^2)，空间复杂度为O(1)，代码如下：
  1. /** 
  2. * Time Complexity:O(n^2)
  3. * Space Complexity:O(1)
  4. *
  5. * sorted data: array[low...high]
  6. */
  7. template <typename Type>
  8. void BubbleSort(Type array[], int low, int high)
  9. {
  10.     if (array == NULL || low >= high || low < 0)
  11.     {
  12.         return;
  13.     }

  15.     Type exchange;
  16.     bool change = false;

  18.     for (int i = low; i < high; ++i)
  19.     {
  20.         for (int j = low; j < high - i + low; ++j)
  21.         {
  22.             if (array[j] > array[j + 1])
  23.             {
  24.                 exchange = array[j + 1];
  25.                 array[j + 1] = array[j];
  26.                 array[j] = exchange;

  28.                 change = true;
  29.             }
  30.         }

  32.         if (!change)
  33.         {//如果冒泡过程中没有发生交换，则视序列已经排好序，减少无谓的比较
  34.             return;
  35.         }
  36.         change = false;
  37.     }
  38. }
复制代码
3.简单选择排序简单选择排序的思想就是每次在未排序的序列中选取一个最小（或最大）的元素，放到最终的位置上，时间复杂度O(n^2)，空间复杂度为O(1)，代码如下：
  1. /** 
  2. * Time Complexity:O(n^2)
  3. * Space Complexity:O(1)
  4. * 
  5. * sorted data ; array[low...high]
  6. */
  7. template <typename Type>
  8. void SelectSort(Type array[], int low, int high)
  9. {
  10.     if (array == NULL || low >= high || low < 0)
  11.     {
  12.         return;
  13.     }

  15.     int index;
  16.     Type exchange;

  18.     for (int i = low; i < high; ++i)
  19.     {
  20.         index = i;

  22.         for (int j = i + 1; j <= high; ++j)
  23.         {
  24.             if (array[j] < array[index])
  25.             {
  26.                 index = j;
  27.             }
  28.         }

  30.         exchange = array[i];
  31.         array[i] = array[index];
  32.         array[index] = exchange;
  33.     }
  34. }
复制代码

  1. /** 
  2. * Time Complexity:O(n^2)
  3. * Space Complexity:O(1)
  4. * 
  5. * sorted data ; array[low...high]
  6. */
  7. template <typename Type>
  8. void SelectSort(Type array[], int low, int high)
  9. {
  10.     if (array == NULL || low >= high || low < 0)
  11.     {
  12.         return;
  13.     }

  15.     int index;
  16.     Type exchange;

  18.     for (int i = low; i < high; ++i)
  19.     {
  20.         index = i;

  22.         for (int j = i + 1; j <= high; ++j)
  23.         {
  24.             if (array[j] < array[index])
  25.             {
  26.                 index = j;
  27.             }
  28.         }

  30.         exchange = array[i];
  31.         array[i] = array[index];
  32.         array[index] = exchange;
  33.     }
  34. }
复制代码
4.折半插入排序折半插入排序和直接插入排序的差别就是在查找插入位置的方式上，直接插入排序是顺序查找插入位置，折半插入式通过二分搜索的思想来查找插入位置。总体来说直接插入排序的比较次数为1+2+3...+(n-1) ~ O(n^2)，二折半查找的比较次数在lg(n-1)+lg(n-2)+...1~O(lg(n!)) ~O(nlgn)（stirling公式）。所以折半查找的优势是减少了比较次数。代码如下：
  1. /** 
  2. * Time Complexity:O(n^2)
  3. * Space Complexity:O(1)

  5. * sorted data ; array[low...high]
  6. */
  7. template <typename Type>
  8. void BinaryInsertSort(Type array[], int low, int high)
  9. {
  10.     if (array == NULL || low >= high || low < 0)
  11.     {
  12.         return;
  13.     }

  15.     int left, right, mid, j;
  16.     Type exchange;

  18.     for (int i = low + 1; i <= high; ++i)
  19.     {
  20.         left = low;
  21.         right = i - 1;
  22.       
  23.         while (left <= right)
  24.         {
  25.             mid = (left + right) / 2;
  26.             
  27.             if (array[i] < array[mid])
  28.                 right = mid - 1;
  29.             else
  30.                 left = mid + 1;
  31.         }
  32.     
  33.         exchange = array[i];

  35.         j = i;
  36.         while (j > left)
  37.         {
  38.             array[j] = array[j - 1];
  39.             --j;
  40.         }

  42.         array[left] = exchange;

  44.     }
  45. }
复制代码
5.shell排序shell排序本身是一种插入排序，它是插入排序的一种改进，排序的思想是：开始按照一定的步长d将序列分成d组，每组内部进行直接插入排序，然后逐步减少步长d，直到步长为1，对整个序列进行一次直接插入排序，使序列最终有序。如下图所示是一个步长为3的初始分组图（取自网络）。shell排序在开始时步长d较大，分组较多，但每组的元素较少，故各组内直接插入较快，后来步长d逐渐缩小，分组数逐渐减少，而各组的元素数目逐渐增多，但由于之前排过序，使序列较接近于有序状态，所以新的一趟排序过程也较快。因此，shell排序在效率上较直接插人排序有较大的改进。shell排序很关键的一点就是步长序列的选定，步长序列的选定决定着排序的效率。一般的建议是d(1) = [ n / 2 ]，d(i+1) = [ (d(i) - 1) / 3 ]，一般认为d都取奇数且互素为好，但这并没有得到理论上的证明。最后一个步长一定为1，这是必然的。关于shell排序的时间复杂度据说很难分校，理论上没用具体结论，只是提出大致为O(nlgn)~O(n^2)之间，大概为O(n^1.3)。。。下面是代码：
  1. /** 
  2. * Time Complexity:between O(nlgn)~O(n^2), about O(n^1.3)
  3. * Space Complexity:O(1)
  4. * 
  5. * sorted data ; array[low...high]
  6. */
  7. template <typename Type>
  8. void ShellSort(Type array[], int low, int high)
  9. {
  10.     int gap, len;
  11.     Type exhange;

  13.     len = high - low + 1;
  14.     gap = len / 2;

  16.     while(gap >= 1)
  17.     {
  18.         for (int i = low; i < low + gap; ++i)
  19.         {
  20.             for (int j = i + gap; j <= high; j += gap)
  21.             {
  22.                 exhange = array[j];
  23.                 int k = j;

  25.                 while (k > i && exhange < array[k - gap])
  26.                 {
  27.                     array[k] = array[k - gap];
  28.                     k -= gap;
  29.                 }

  31.                 array[k] = exhange;
  32.             }
  33.         }

  35.         if(gap == 2 || gap == 3)
  36.             gap = 1;
  37.         else
  38.             gap = (gap - 1) / 3;
  39.     }
  40. }
复制代码
6.快速排序快速排序是一个很牛逼的排序算法，在现实中有很多应用，有很多算法都是借鉴快速排序的思想来实现的。虽然快排的最坏时间复杂度为O(n^2)，但它的平均性能很好，为O(nlgn)。快排的思想是分治法。每次排序都将序列通过一个主元划分成左右两部分，右部分的元素都比主元大，左边的元素都比主元小，然后分别递归进行左右两部分的排序。快排的主程序结构都如下所示：
  1. /** 
  2. * sorted data ; array[low...high]
  3. */
  4. template <typename Type>
  5. void QuickSort(Type array[], int low, int high)
  6. {
  7.     if (low >= high)
  8.     {
  9.         return;
  10.     }

  12.     int pivot = QuickSort_Partition(array, low, high);
  13.     QuickSort(array, low, pivot - 1);
  14.     QuickSort(array, pivot + 1, high);
  15. }
复制代码
对于划分部分partition，有几种不同的算法，下面介绍三种不同的算法。6.1一种简单partition最简单的一种partition算法如下图所示：选取第一个元素为主元，作为划分的标准（下面几个partition默认同样的选取主元的方法）。索引i，j初始初始化为序列开始，然后索引j依次后移，如果遇到A[j] <= x，那么就交互A[i + 1]和A[j]，直到索引j移动到末尾，这样结果是索引i左侧的元素都<=x，右侧的元素都>x。达到了partition的目的，这种算法很简单，代码如下：
  1. template <typename Type>
  2. int QuickSort_Partition(Type array[], int low, int high)
  3. {
  4.     Type pivotData = array[low];

  6.     int littleIndex = low;
  7.     Type exchange;
  8.     
  9.     for (int largerIndex = low + 1; largerIndex <= high; ++largerIndex)
  10.     {
  11.         if (array[largerIndex] <= pivotData)
  12.         {
  13.             ++littleIndex;

  15.             exchange = array[littleIndex];
  16.             array[littleIndex] = array[largerIndex];
  17.             array[largerIndex] = exchange;
  18.         }
  19.     }

  21.     exchange = array[littleIndex];
  22.     array[littleIndex] = array[low];
  23.     array[low] = exchange;

  25.     return littleIndex;
  26.   
  27. }
复制代码
6.2 Hoare partition快排的发明者，我们的Hoare爵士，采用的partition算法是，在从序列两端开始扫描，如下图所示：索引i从左端开始扫描，直到找到第一个大于主元x的元素，索引j从右端开始扫描，直到找到第一个小于等于x的元素，然后将这两个索引对应的元素进行交换。继续上面的操作，直到i > j。代码如下：
  1. template <typename Type>
  2. int QuickSort_Hoare_Partition(Type array[], int low, int high)
  3. {
  4.     Type pivotData = array[low];

  6.     int littleIndex = low + 1;
  7.     int largerIndex = high;

  9.     Type exchange;

  11.     while (littleIndex <= largerIndex)
  12.     {
  13.         while(littleIndex <= largerIndex && array[littleIndex] <= pivotData)
  14.             ++littleIndex;

  16.         while(littleIndex <= largerIndex && array[largerIndex] >= pivotData)
  17.             --largerIndex;

  19.         //through above two while, littleIndex couldn't equal to largerIndex
  20.         if (littleIndex < largerIndex)
  21.         {
  22.             exchange = array[littleIndex];
  23.             array[littleIndex] = array[largerIndex];
  24.             array[largerIndex] = exchange;

  26.             --largerIndex;
  27.             ++littleIndex;
  28.         }
  29.     }

  31.     exchange = array[largerIndex];
  32.     array[largerIndex] = pivotData;
  33.     array[low] = exchange;

  35.     return largerIndex;
  36.         
  37. }
复制代码
Hoare的partition算法相比上面6.1的算法，在平均交换次数上明显较少。特别是在待排序序列中有很多重复元素的时候。6.3 另一种partition还有一种partition算法，其思想和前面Hoare partition算法类似，都是从两端开始进行双向划分。但是不同的是这种partition两个方向不是同时进行的，相当于半双工的概念，如下图所示：具体思路：索引i指向主元的位置，索引j先从右端开始向左扫描，直到遇到第一个<= x主元的元素，然后将该元素移动到索引i所指的位置，然后索引i从当前下一个元素开始向右扫描，直到遇到一个>x的元素，将该指辅导索引j所指的位置。如次循环，直到i = j，主元存放到该位置。代码如下：
  1. template <typename Type>
  2. int QuickSort_Another_Partition(Type array[], int low, int high)
  3. {
  4.    Type pivotData = array[low];

  6.    int littleIndex = low;
  7.    int largerIndex = high;

  9.    while (littleIndex < largerIndex)
  10.    {
  11.         while (littleIndex < largerIndex && array[largerIndex] >= pivotData)
  12.             --largerIndex;
  13.         
  14.         if (littleIndex < largerIndex)
  15.             array[littleIndex++] = array[largerIndex];

  17.         while (littleIndex < largerIndex && array[littleIndex] <= pivotData)
  18.             ++littleIndex;

  20.         if (littleIndex < largerIndex)
  21.             array[largerIndex--] = array[littleIndex];
  22.    }

  24.    array[largerIndex] = pivotData;

  26.    return largerIndex;
  27. }
复制代码
7.归并排序归并排序和快速排序一样都是很重要的算法，在面试过程中，面试官也是很喜欢考的。归并的思想也是采用分治法，这里所说的归并是采用两路归并，依次将序列从中间划分为两部分，直到序列中元素个数为1，然后进行两两归并，直到最终递归结束。归并排序的时间复杂度是严格的O(nlgn)，空间复杂度为O(n)。代码如下：
  1. /** 
  2. * Time Complexity:O(nlgn)
  3. * Space Complexity:O(n)
  4. * 
  5. * sorted data ; array[low...high]
  6. */
  7. template <typename Type>
  8. void SubMergeSort(Type *inputArray, Type *tempArray, int lowIndex, int midIndex, int highIndex)
  9. {
  10.     int index1 = lowIndex, index2 = midIndex + 1;
  11.     int destIndex = lowIndex;

  13.     while(index1 <= midIndex && index2 <= highIndex)
  14.     {
  15.         if(inputArray[index1] < inputArray[index2])
  16.         {
  17.             tempArray[destIndex++] = inputArray[index1++];
  18.         }
  19.         else
  20.         {
  21.             tempArray[destIndex++] = inputArray[index2++];
  22.         }
  23.     }

  25.     //indicate the first half data have move to 'tempArray'
  26.     while(index2 <= highIndex)
  27.         tempArray[destIndex++] = inputArray[index2++];

  29.     //indicate the later half data have move to 'tempArray'
  30.     while(index1 <= midIndex)
  31.         tempArray[destIndex++] = inputArray[index1++];

  33.     for (int i = lowIndex; i <= highIndex; ++i)
  34.     {
  35.         inputArray[i] = tempArray[i];
  36.     }
  37. }

  39. template <typename Type>
  40. void MergeSort_Part(Type *array, Type *tempArray, int low, int high)
  41. {

  43.     if (low < high)
  44.     {
  45.         int mid = (low + high) / 2;
  46.         
  47.         MergeSort_Part(array, tempArray, low, mid);
  48.         MergeSort_Part(array, tempArray, mid + 1, high);
  49.         SubMergeSort(array, tempArray, low, mid, high);
  50.     }
  51. }

  53. template <typename Type>
  54. void MergeSort(Type *array, int len)
  55. {
  56.     Type *tempArray = new Type[len];

  58.     MergeSort_Part(array, tempArray, 0, len - 1);

  60.     delete [] tempArray;
  61. }
复制代码
8.堆排序堆排序也是常用排序之一，和快速排序，归并排序可谓是排序三剑客，在面试和实际应用中都随处可见，特别是在大数据处理中。面试中也会结合大数据来考堆排序的。堆排序的思想主要分为两部分：建堆和堆调整。下面以建大根堆为例：
建堆的过程：从第[n / 2]个节点开始依次向下进行筛选，将较大的元素上移，直到堆满足大根堆的要求。实际上建堆的过程是堆调整的过程；退调整过程：对已经建立的大根堆，输出堆顶元素，然后对剩下的元素进行调整，使其仍然满足大根堆的要求；堆排序建堆的过程时间复杂度为O(n)（在堆排序中建堆过程的时间复杂度O(n)的证明中已经证明），堆调整过程的时间复杂度为O(nlgn)，建立大根堆的代码如下所示：
  1. /** 
  2. * Time Complexity:O(nlgn)
  3. * Space Complexity:O(1)
  4. * 
  5. * sorted data ; array[low...high]
  6. */
  7. template <typename Type>
  8. void BigRootHeapAdjust(Type *array, int low, int high)
  9. {
  10.     int j, k;
  11.     Type temp;

  13.     temp = array[low];
  14.     k = low;

  16.     for (j = low * 2 + 1; j <= high; j = j * 2 + 1)
  17.     {
  18.         if (j < high && array[j] < array[j + 1])
  19.             j += 1;

  21.         if (temp > array[j])
  22.             break;

  24.         array[k] = array[j];

  26.         k = j;         
  27.     }

  29.     array[k] = temp;
  30. }

  32. template <typename Type>
  33. void BigRootHeapSort(Type *array, int len)
  34. {
  35.     if (array == NULL ||  len <= 0)
  36.     {
  37.         return;
  38.     }

  40.     for (int i = len / 2 - 1; i >= 0; --i)
  41.     {
  42.         BigRootHeapAdjust(array, i, len - 1);
  43.     }

  45.     Type exchange;
  46.     for (int i = len - 1; i > 0; --i)
  47.     {
  48.         exchange = array[i];
  49.         array[i] = array[0];
  50.         array[0] = exchange;

  52.         BigRootHeapAdjust(array, 0, i - 1);
  53.     }
  54. }
复制代码
9.各种排序算法性能的比较下图表是各种排序算法的各种比较，可以很好的进行对比。
java extends java extends
原创粉丝点击
热门IT博客
unity3d小游戏源代码unity3d小游戏源代码
梦幻花园无法加载 网络梦幻花园无法加载 网络
如何找淘宝客户资料
mac excel powerview
java socket 心跳机制
留学生做饭 知乎
济南直销软件开发
linux修改host
爬虫软件官方下载
java获取数组长度
大数据分布式存储
淘宝口令失效怎么设置
导入mac的照片存在哪里
琼瑶 小三 知乎
皮皮跑胡子 湖南网络
将数组转换成字符串
维也纳工业大学 知乎
windows 7怎么更改只读
如果世上不再有猫 知乎
帝国cms教程
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 乡村春事顺子和贵玉 乡村顺子续集 联通顺子号多少钱 同花大还是顺子大 顺子dear friend 顺子烧烤电话 顺子好听的歌 顺子回家原版 顺字拼音 顺字组词 顺字图片 顺字五笔怎么打 文从字顺 及字笔画顺 顺字成语 顺字有几画 顺字几画 顺字书法图片 顺字成语大全 顺字多少笔画 顺字笔画顺序 顺字隶书 了字几画笔顺怎么写 顺字开头的成语 百衣百顺哪个字错了 顺的形近字 顺字开头的成语接龙 带顺字的成语 顺字 顺峰 顺峰山庄 顺差逆差 顺差 逆差顺差 外贸顺差 逆差与顺差 贸易顺差与逆差 国际收支顺差 贸易顺差和贸易逆差 什么是贸易顺差和逆差 顺差是出口大于进口吗

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里