数据结构-常见排序算法总结

Sort Algorithm（ASC）

[TOC] //怎么生成目录，纠结ing

插入排序

每一趟排序都将待排元素插入到已有序的序列中，但不能保证该元素的插入位置是全局有序的。

Insertion Sort

直接插入排序

• 最好情况：$O(n)$
• 最坏情况：$O(n^2)$
• 平均情况：$O(n^2)$
• 辅助空间：O(1)
• 稳定性：稳定
• 每一趟排序只能保证当前有序，并不能保证全局有序

1. 核心思想
   数组中的每一个待排元素与已部分有序的元素依次比较，如果待排元素小于当前已有序的元素，则交换两者位置，并继续向前比较。

2. 程序示例

   public static void insertionSort(int[] arr){
       for (int i=1;i=0;j--){
               if (arr[j]>arr[j+1]){
                   swap(arr,j,j+1);
               }
           }
       }
   }
   public static void  swap(int[] arr,int i,int j){
       int tmp=arr[i];
       arr[i]=arr[j];
       arr[j]=tmp;
   }
   

3. 程序分析
   直接插入排序采用两层循环：

   • 外层循环用来跟踪每一个待排元素，从1到 n-1，刚开始arr[0]是默认有序的。
   • 内层循环负责当前待排元素与已部分有序的元素进行逐一比较，确定当前待排元素的最终插入位置。

4. 优化分析*
   在内层循环中，每当逆序（已有序元素大于待排元素时）的情况出现时，就执行一次 swap 操作，交换两元素的位置，这样会导致交换次数较多。可以考虑通过比较确定最后的插入位置，然后将交换操作推迟到最后进行。这样只需要进行一次交换操作，但已有序元素的移动次数是不会改变的。

Shell Sort

希尔排序（缩小增量排序）

• 步长+直接插入排序
• 最好情况：$O(n)$
• 最坏情况：$O(n^2)$
• 平均情况：$O(n^{1.3})$
• 辅助空间：O(1)
• 稳定性：不稳定
• 每一趟排序只能保证当前有序，并不能保证全局有序

1. 核心思想
   希尔排序，又称缩小增量排序，使用步长来确定每一次的待排子序列，然后使用直接插入排序对当前待排子序列进行排序。在完成步长为 h 的排序后，通过证明可以保证，对于每一个 i 与 i+h 元素都是有序的。然后缩小步长，再次使用直接插入排序。直到最后步长为1，最后一次序列已经基本有序，最后采用一次直接插入排序后就可以得到最终的有序数组。

2. 程序示例

   public static void shellSort(int[] arr){
       //第一层循环控制步长
       for (int gap=arr.length/2;gap>0;gap=gap/2){
           //第二层循环控制满足步长的所有子序列
           for (int i=gap;i

3. 程序分析
   希尔排序采用三层循环：

   • 第一层循环负责确定每一趟的步长，并按一定的规则（这里采用/2折半的规则），循环减小步长到1。
   • 第二层循环针对当前步长，依次确定满足该步长的待排子序列。
   • 第三层循环针对当前确定的待排子序列，采用直接插入排序的方法进行排序。

选择排序

基本思想：比较+交换

Selection Sort

简单选择排序

• 最好情况：$O(n^2)$
• 最坏情况：$O(n^2)$
• 平均情况：$O(n^2)$
• 辅助空间：O(1)
• 稳定性：不稳定
• 每一趟排序保证全局有序

1. 核心思想
   简单选择排序，是选择排序中的一种，遵循其基本思想：比较+交换。即通过依次比较确定当前趟最小元素，并根据情况与当前待排元素交换。具体做法是在每趟排序中，通过将当前待排元素与与剩余所有元素比较，找到最小的元素并与当前元素交换（如果当前待排元素就是最小，则不用交换）。

2. 程序示例

   public static void selectionSort(int[] arr){
       for (int i=0;i

3. 程序分析
   简单选择排序，采用两层循环：

   • 外层循环用于控制当前待排元素及其待排位置。
   • 内存循环用于基于当前待排位置和待排元素，循环依次与序列中剩余其它元素比较，如果存在元素小于当前待排元素，则采用一个临时变量始终标记符合该条件的元素。在退出内层循环后，判断经过一趟完整比较后，最小元素是否为当前待排元素，如果是，说明当前待排元素是当前趟的最小值，当前位置即全局有序位置，不交换；如果不是，则采用 swap 交换。

Heap Sort

堆排序

• 最好情况：$O(nlog_2n)$
• 最坏情况：$O(nlog_2n)$
• 平均情况：$O(nlog_2n)$
• 辅助空间：O(1)
• 稳定性：不稳定
• 每一趟排序保证全局有序

1. 核心思想
   堆排序，先根据父节点与子节点下标关系（i，2i+1，2i+2）将待排序列构造为大顶堆（实际上还是在数组中存储）。然后执行循环操作：每次将顶点元素与最后一个元素swap，交换后，当前最大元素已经位于数组的末尾，因为原来的末尾元素到了顶点位置，有可能破坏堆的性质，则通过堆调整来修正堆性质。循环执行这一组操作，直到堆中只有一个元素的时候，该待排序列已然有序。

2. 程序示例

   public static void heapSort(int[] arr){
       buildHeap(arr);
       int length=arr.length;
       while (length>0){
           swap(arr,0,length-1);
           length--;
           adjustToHeap(arr,length,0);
       }
   
   }
   
   public static void buildHeap(int[] arr){
       for (int i=0;iarr[indexOfMax]){
               indexOfMax=leftIndex;
           }
           if (rightIndexarr[indexOfMax]){
               indexOfMax=rightIndex;
           }
           if (indexOfMax!=index){
               swap(arr,index,indexOfMax);
               index=indexOfMax;
               continue;
           }
           else {
               break;
           }
       }
   }
   
   public static int getLeftChild(int i){
       return 2*i+1;
   }
   
   public static int getRightChild(int i){
       return 2*i+2;
   }
   
   public static void  swap(int[] arr,int i,int j){
       int tmp=arr[i];
       arr[i]=arr[j];
       arr[j]=tmp;
   }
   

3. 程序分析
   在采用堆排序前，需要对待排序列构造大顶堆。具体构造方式，稍后详述。

   • 在生成大顶堆后，满足大顶堆的性质，第一个元素 arr[0]是当前0~arr.length-1中的最大值。接下来对该大顶堆进行 N-1 次的交换和调整。
   • 具体做法是，在每次交换和调整中，将堆顶的最大值与堆尾元素互换，这样，该最大值就位于正确顺序位置上。因为互换后有可能破坏大顶堆顺序，因此必须在互换后调用 adjustToHeap 进行堆性质修正。

交换排序

Bubble Sort

冒泡排序

• 最好情况：$O(n^2)$
• 最坏情况：$O(n^2)$
• 平均情况：$O(n^2)$
• 辅助空间：O(1)
• 稳定性：稳定
• 每一趟排序保证全局有序

1. 核心思想
   冒泡排序，在每一趟排序中，都依次比较左右两个元素，如果不符合大小关系，则交换位置，并继续比较下一个坐标位置。在一趟比较结束后，当前趟最大的元素会沉底。

2. 程序示例

   public static void bubbleSort(int[] arr){
       //对于 N 个元素的序列,需要 N-1 趟排序
       for (int i=1;iarr[j+1]){
                   swap(arr,j,j+1);
               }
           }
       }
   }
   
   public static void  swap(int[] arr,int i,int j){
       int tmp=arr[i];
       arr[i]=arr[j];
       arr[j]=tmp;
   }
   

3. 程序分析
   冒泡排序采用两层循环，对于 N 个元素的冒泡排序，需要进行 N-1 趟排序，第 i 趟排序需要比较 N-i 次。

   • 第一层循环控制冒泡排序的趟数，从1到 N-1趟冒泡排序。
   • 第二层循环控制每一趟的冒泡排序，因为经过第 i-1 趟的排序，第 N-i+1 个位置已经有序，所以在第 i 趟的冒泡排序中，只需要从第一个元素一直比较到第 N-i 个元素。

4. 优化分析
   针对最好情况为$O(n)$的情形，可以在外层循环中设置一个变量用来检查上一趟是否存在交换操作，在内层循环中，发生 swap 操作则置该变量为 true，否则默认为 false。在退出内层循环后，外层逻辑会判断如果变量为 true 说明上一趟待排序列不满足顺序条件，继续本趟排序；如果为 false 说明在上一趟中待排序列所有元素已经有序。因此在本趟排序可以直接 break，已经提前完成了序列排序。

Quick Sort

快速排序

• 最好情况：$O(nlog_2n)$
• 最坏情况：$O(n^2)$
• 平均情况：$O(nlog_2n)$
• 辅助空间：$O(nlog_2n)$
• 稳定性：不稳定
• 每一趟排序保证轴 key 全局有序

1. 核心思想
   循环比较交换+分而治之的思想。在每一趟的排序操作中，当 i不等于j 的时候，将大于 key 的元素都交换在 key 的右边，小于 key 的元素都交换在 key 的左边。当 i等于j 的时候，就是 key 的最终有序位置。但是经过一趟排序操作，仅保证了当前 key 位于正确有序的位置 i，但对于start~i-1和 i+1~end 是无序的，因此需要在这两段上递归调用刚刚的排序操作。

2. 程序示例

   public static void quickSort(int[] arr,int start,int end){
       if (start=key){
                   j--;
               }
               //将该元素替换到 key 的左边
               if (i

3. 程序分析
   快速排序在每一趟排序中，先选定一个轴，通过交换来确定轴的最终位置，在一趟排序后，大于或小于该轴的元素会位于该轴的两侧。

   • 外层循环用来控制这趟排序是否结束，当 i 等于 j 的时候，说明待排序列的比较已经结束，该位置即为轴 key 的最终有序位置。
   • 在第一个内层循环中，先从后向前循环查找第一个小于 key 的元素，如果存在则退出循环并将该元素交换至 key 的 i 位置，然后再进入第二个内层循环。如果没有存在一个小于 key 的元素，说明在从后向前的查找中，key 后面的元素都大于 key，因此，说明 key 就是在正确的有序位置。
   • 在第二个内层循环中，从前向后循环查找第一个大于 key 的元素，如果存在则退出循环并交换至当前 j 位置，然后退出该循环，判断 i 是否等于 j，不等于则说明该趟还没比较结束，继续从第一个内层循环开始，继续排序操作。直至 i 等于 j。

4. 优化分析
   快速排序对于越无序的序列效果越好，但对于基本有序序列，在选定 key 后，有可能剩余的 N-1个元素均大于或小于 key，导致分而治之的效果不明显，没有明显的均分待排序列，使得效率接近于插入排序$O(n^2)$的效果。改善这样的情况，可以尝试采用随机 key 的方式，每一趟排序，均在当前 start~end 中随机选取 key 作为轴，而不是始终设定为 arr[start]为轴，尽可能通过随机化减少有序影响，实现或接近分治效果。