内部排序算法思路与实现【附图解&复杂度分析】

---

内部排序

  排序也称排序算法(Sort Algorithm)，排序是将一组数据，依指定的顺序进行排列的过程。排序算法分为两类：

1. 内部排序：将需要处理的所有数据都加载到内部存储器中进行排序。
2. 外部排序：数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。

  排序算法根据稳定性可以分为：

1. 稳定排序：相同元素在排序后的前后相对顺序保持不变。比如{5’,2,5’’}，排序后为{2,5’,5’’}，{5’} 与{5’’} 相对顺序没有改变。
2. 非稳定排序： 相同元素在排序后的前后相对顺序可能发生了变化。比如{5’,2,5’’}，排序后为{2,5’’,5’}，{5’’} 与{5’} 相对顺序发生了改变。

---

1. 直接插入排序

插入排序包括直接插入排序和希尔排序。
对于插入排序，特征是进行元素间的比较。

算法思想：
  对于待排序的数组，构建有序序列，对于无序序列中的每个元素，在有序序列中从后向前寻找到相应的位置进行插入。
  例如，对于有序序列 {38,49,65,97} ，要插入元素 56，显然 56 要插入在 65 之前，则将 {65} , {97} 向后移动一位，将 {56} 插入在 {65} 之前，排序后数组为 {38,49,56,65,97}。

算法图解：对数组 [4,2,2,78,5,45] 进行直接插入排列：

算法稳定性：在直接插入排序中，对于相同的数据，可以设置条件确定插入位置，不必改变先后顺序。比如上例中，两个元素2的相对前后顺序没有变化。算法稳定。

代码实现：

	/**
     * 简单插入排序：稳定排序
     * @param arr 传入的数组
     */
    public static void insertSort(int[] arr){
   
   
        int len=arr.length;
        for(int i=1;i<len;i++){
   
   
            int cur=arr[i];
            //在有序序列中查找合适的插入位置
            int j;
            for(j=i-1;j>=0&&arr[j]>cur;j--){
   
   
                arr[j+1]=arr[j];
            }
            //插入该元素
            arr[j+1]=cur;
        }
    }

复杂度分析：

时间复杂度 O(N²)
  最好情况为数组升序排列，只需要比较 n-1 次即可，时间复杂度 O(N)。
  最坏情况为数组降序排列，需要比较 1+2+…+(n-1)=n×(n-1)/2 次，交换 n-1 次,时间复杂度为 O(N²)。
  插入排序的平均时间复杂度为 O(N²)。

空间复杂度 O(1)
  直接插入排序使用常数级别的额外空间。

算法特征：

1. 适合少量数据的排序；算法稳定。
2. 插入排序在对几乎已经排好序的数据操作时，效率高，可以达到线性排序的效率。
3. 插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位。

---

2. 希尔排序

算法思想：
  希尔排序又称缩小增量排序，是插入排序的改进形式。
  考虑到直接插入排序在序列几乎排好序时效率达到线性排序级别，希尔排序依据不断递减的步长将待排序序列划分为若干子序列，对每个子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全部记录依次进行直接插入排序。

算法图解：对数组 [49’,38,65,97,76,13,27,49’’,55,04] 进行希尔排序：

算法稳定性：一次插入排序是稳定的，但是希尔排序对数据进行分组处理，分别进行插入排序，相同元素可能划分在不同组中，从而相对前后顺序会发生改变。比如上例中49’’ 与49’ 划分在不同组中，排序后顺序发生了变化。希尔排序不稳定。

代码实现：

    /**
     * 希尔排序：缩小增量排序，步长每次模2递减
     * @param arr 待排序数组
     */
    public static void shellSort(int[] arr){
   
   
        int len=arr.length;
        int gap=len/2;
        //步长递减
        while(gap>=1) {
   
   
            /* 每次分为gap组 */
            for (int i = 0; i < gap; i++) {
   
   
                //对于每一组，进行直接插入排序
                for (int j = i + gap; j < len; j += gap) {
   
   
                    int cur = arr[j];
                    int pre = j - gap;
                    while (pre >= 0 && arr[pre] > cur) {
   
   
                        arr[pre + gap] = arr[pre];
                        pre -= gap;
                    }
                    arr[pre+gap] = cur;
                }
            }
            gap/=2;
        }
    }

复杂度分析：

时间复杂度 O(N log² N)
  希尔排序可以取不同的增量序列，相应的时间复杂度也不同；希尔排序最后一轮的增量必须为 1，保证排序完成后数组一定有序。
  步长序列为 n/2ⁱ 时，最坏情况下退化为直接插入排序，时间复杂度为 O(N²)。
  步长序列为 2^k-1 时，最坏情况下时间复杂度为 O(N^3/2)。
  步长序列为 2ⁱ3^j 时，最坏情况下时间复杂度为 O(N log² N)。
  希尔排序的渐进时间复杂度为O(N log² N)。

空间复杂度 O(1)
  希尔排序使用常数级别的额外空间。

---

3. 简单选择排序

选择排序包简单选择排序和堆排序。
对于选择排序，特征是进行元素间的比较与交换。

算法思想：
  核心思想是比较，交换。在数组元素的比较中找到一个最小的元素，将其放在起始位置；之后每次从未排序序列中找到最小元素，将其放到已排序序列的末尾（即与未排序序列的首元素进行交换），直到所有元素均排序完毕。

算法图解：对数组 [4,5’,78,5’’,17,1] 进行简单选择排序：

算法稳定性：
  在寻找最小元素，进行元素交换的过程中，可能导致相同元素的前后顺序发生变换。
  例如：对于序列 (7) 2 5 9 3 4 [7] 1，用直接选择排序算法进行排序时候, (7) 和 1 调换, (7) 就跑到了 [7] 的后面了,原来的次序改变了,这样就不稳定了。如上例中的 5’ 与 5’’ 顺序改变。
  选择排序不稳定。

代码实现：

    /**
     * 简单选择排序，不稳定
     * @param arr 待排序数组
     */
    public static void selectSort(int[] arr){
   
   
        int len=arr.length;
        for(int i=0;i<len-1;i++){
   
   
            //已排序序列为[0,i),在未排序序列[i,len-1]中寻找最小元素下标
            int min=i;
            for(int j=i+1;j<len;j++){
   
   
                if(arr[j]<arr[min]){
   
   
                    min=j;
                }
            }
            //交换当前元素arr[i]与最小元素arr[min]
            if(i!=min){
   
   
                int temp=arr[i];
                arr[i]=arr[min];
                arr[min]=temp;
            }
        }
    }

复杂度分析：

时间复杂度 O(N²)
  无论初始序列如何，简单选择排序在每次寻找最小值的过程中总要与相邻元素进行比较，比较次数为 1+2+…+(n-1)= n×(n-1)/2，每次比较可能发生交换，最坏情况下交换次数为 n-1 。所以简单选择排序的时间复杂度为 O(N²)。

空间复杂度 O(1)
  简单选择排序使用常数级别的额外空间。

---

4. 堆排序

堆
  堆的结构为完全二叉树，分为大顶堆和小顶堆：

1. 大顶堆：每个结点的值都大于或等于其左右子结点的值，即 arr[i] ≥ arr[2×i+1] && arr[i] ≥ arr[2×i+2] ，在堆排序中用来实现升序排列。
2. 小顶堆：每个结点的值都小于或等于其左右子结点的值，即 arr[i] ≤ arr[2×i+1] && arr[i] ≤ arr[2×i+2] ，在堆排序中用来实现降序排列。

算法思想：
  堆排序属于选择排序。
  考虑将包含 N 个元素的数组进行升序排列，堆排序分为两步：

1. 建堆。先将待排序的数组建成大顶堆，使得每个父节点都大于等于它的左右子节点，时间复杂度为 O(N)。
2. 堆调整。将堆顶最大值与数组末尾元素交换，调整堆顶元素使得剩下的n-1个元素仍构成大顶堆，重复步骤2，直到得到一个有序序列，时间复杂度为 O(N log N)。

算法特征：首先构造大顶堆，之后进行 n-1 次循环，每次循环可以确定一个最大值放在当前序列末尾。

算法图解：对数组 [4,6,2,5,9’,9’’,1] 进行堆排序：

1.建堆
对于 N 个节点的完全二叉树，非叶子结点个数为 N/2 ，进行 N/2 次堆调整，最终构建的大顶堆为 [9’,6,9’’,5,4,2,1]。

2.堆调整
对于步骤1构建的大顶堆 [9’,6,9’’,5,4,2,1]，此时堆顶元素为整个数组最大值，将其与末尾元素交换，从堆顶开始维护堆，重新寻找剩余元素中的最大值，将其交换到堆顶。

算法稳定性：
  堆排序属于选择排序，特征是进行元素间的比较交换，在构造堆和调整堆的过程中，为了维护堆顶元素，可能导致相同元素的前后顺序发生变换。
  如上例中对于数组 [4,6,2,5,9’,9’’,1] 进行堆排序，在建堆后 9’ 为堆顶元素，进行第 1 次堆调整后，把 9’ 作为排好序的元素放在数组末尾，导致 9’ 与 9’’ 的相对顺序改变。
  堆排序不稳定。

代码实现：

    /**
     * 堆排序，不稳定排序
     * @param arr 待排序数组
     */
    public static void heapSort(int[] arr){
   
   
        //step1:建造大顶堆
        int len=arr.length;
        for(int start=len/2-1;start>=0;start--){
   
   
            maxHeapify(arr,start,len);