排序的简单理解（上）

1. 排序的概念及引用

1.1 排序的概念

        排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作（按照我们的需求能够有序的将数据信息排列起来）。

        稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持 不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳 定的；否则称为不稳定的（如果一份数据中有多个相同的数据，在经过排序后这几个数据的先后逻辑顺序没有发生改变就称为该算法稳定性强）。

        

        内部排序：数据元素全部放在内存中的排序。

        外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

1.2 常见的排序算法

        我们本次学习主要学习一下四类七种排序算法；

        下文我们将详细的介绍不同的排序算法及实现 

2. 插入排序

2.1 直接插入排序

         直接插入排序是一种简单的插入排序法，其基本思想是： 把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。实际中我们玩扑克牌时，就用了插入排序的思想

                                                 

2.1.1 详细思路与图解分析

        把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素（默认），无序表中包含n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码从后往前一一进行比较，将它插入到有序表中的适当位置，使之成为一个新的有序表。

        以序列：{55, 85, 21, 12, 5} 为例， 图解如下：

        

        红色部分为每轮认定的有序部分，其余颜色为认定的无序部分。绿色标识为每轮遍历的无序序列的位置，将该位置的元素逐一与有序部分进行比较，找到合适的位置进行顺序表的插入操作。 

        代码一：

 public static void insertSort(int[] array){
        //判断数组为空，无法排序
        if (array.length <1){
            return;
        }
        for (int i = 1; i < array.length; i++) {
            //定义待插入位置和待插入的数值
            int insertIndex = i-1;//arr[i]前面的位置,便于插入
            int insertValue = array[i];//现将待插入的数值保存到变量中
            //给insertValue找到待插入的位置
            //1.insertIndex > 0防止越界
            //2.insertValue < arr[insertIndex] 说明还未找到待插入的位置，
            // 还要继续与前面的那个位置进行比较，直到insertValue > arr[insertIndex]
            //说明找到了要插入的点的索引
                while (insertIndex >= 0 && insertValue < array[insertIndex]){
                    array[insertIndex+1] = array[insertIndex];
                    insertIndex--;
                }
                if (insertIndex != i){
                    //要插入的位置insertindex与刚开始的该元素存放的位置不一样
                    //我们比insertindex位置大，所以要插到他后面，所以加一
                    array[insertIndex+1] = insertValue; //插入
                }
                System.out.println("第" + i + "轮: " + Arrays.toString(array));
            }
        }

        测试代码如下：

public static void main(String[] args) {
            int[] array = {55, 85, 21, 12, 5};
            System.out.println("排序前: " + Arrays.toString(array));
            insertSort(array);
            System.out.println("排序后: " + Arrays.toString(array));
        }

         实现效果如下：

          

        代码二展示（简单易理解）：

 public static void instersort(int[] arr){
        for (int i = 1; i <arr.length ; i++) {
            int tmp=arr[i];
            int j = i-1;
            for (; j>=0 ; j--) {
                if(arr[j]>tmp){
                    arr[j+1]=arr[j];
                }else{
                    break;
                }
                
            }
            arr[j+1]=tmp;
        }
    }

        结果展示：

          

2.2.2 分析与总结

/**
 * 时间复杂度：
 *    最坏情况下：O(n^2)  5   4   3   2   1
 *    最好情况下：O(n)   当前数据越有序，排序越快   1  2  3  4  5
 *    适用于：待排序序列  已经基本上趋于有序了！
 * 空间复杂度： O(1)
 * 稳定性：稳定的
 */

以下是动图展示：

2.2 希尔排序( 缩小增量排序 )

2.2.1 详细思路与图解分析

        希尔排序法又称缩小增量法。

        希尔排序是基于插入排序的以下两点性质而提出改进方法的：

• 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；
• 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位；

        希尔排序法的基本思想是：把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至 1 时，整个文件恰被分成一组，算法便终止。希尔排序是非稳定排序算法。

        以序列: {8, 9, 1, 7, 2, 3, 5, 6, 4, 0} 为例

1、初始步长gap = length/2 ＝ 5，意味着将整个数组分为了5组，即[8，3]，[9，5]，[1，6]，[7，4]，[2，0]，对每组进行插入排序，得到序列：{3，5，1，4，0，8，9，6，7，2}，可以看到：3，5，4，0这些小元素都被提到前面了

2、缩小增量gap = 5/2 = 2，数组被分为两组，即[3，1，0，9，7]，[5，4，8，6，2]，对这两组分别进行直接插入排序，可以看到，整个数组的有序程度更进一步了

3、再次缩小增量，gap = 2/2 = 1，此时整个数组为[0，2，1，4，3，5，7，6，9，8]，进行一次插入排序，即可实现数组的有序化（仅需要简单微调，而无需大量移动操作）

        代码一实现如下：

public static void shellSort(int[] arr){
        //设定步长
        for (int gap = arr.length / 2; gap > 0; gap /= 2){
            //将数据分为arr.length/gap组，逐个对其所在的组进行插入排序
            //按照分组一直进行下面的每组直接插入，直到整个元素集合分为一组
            for (int i = gap; i < arr.length; i++) {
                //遍历各组中的所有元素，步长为gap
                int j = i;//每一组的元素个数定义为j
                int temp = arr[j]; //记录待插入的值
                while (j - gap >= 0 && temp < arr[j-gap]){
                    //移动
                    arr[j] = arr[j-gap];
                    j -= gap;
                }
                //找到位置，进行插入
                arr[j] = temp;
            }
            System.out.println(Arrays.toString(arr));
        }
    }

        代码二（较易理解）：

    public void straightInsertion(int[] array,int gap) {
        int len = array.length;
        for(int i = gap; i < len ; i++) {
            int count = array[i];
            int j = i - gap;
            for( ; j >= 0; j-=gap) {
                if(count < array[j]) {
                    array[j + gap] = array[j];
                } else {
                    break;
                }
            }
            array[j + gap] = count;
        }
    }
    public void shellSort(int[] arrary) {
        int gap = arrary.length;
        while(gap  > 0) {
            gap = gap /2;
            straightInsertion(arrary,gap);
        }
    }

          测试代码及结果如下：

 public static void main(String[] args) {
        int[] arr = {8, 9, 1, 7, 2, 3, 5, 6, 4, 0};
        System.out.println("排序前: " + Arrays.toString(arr));
        shellSort(arr);
        System.out.println("排序后: " + Arrays.toString(arr));
    }

         

2.2.2 分析与总结

1. 希尔排序是对直接插入排序的优化。
2. 当 gap > 1 时都是预排序，目的是让数组更接近于有序。当 gap == 1 时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
3. 希尔排序的时间复杂度不好计算，因为 gap 的取值方法很多，导致很难去计算，因此在好些书中给出的希尔排序的时间复杂度都不固定。（时间复杂度不固定）
4. 稳定性：不稳定

3 选择排序

        基本思想：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。

3.1 直接选择排序

        动态图解如下图所示：

3.1.1 详细思路与图解分析

第一次：从arr[0]~arr[n-1]中选取最小值，与arr[0]进行交换；
第二次：从arr[1]~arr[n-1]中选取最小值，与arr[1]进行交换；
第三次：从arr[2]~arr[n-1]中选取最小值，与arr[2]进行交换；
…
第 i 次：从arr[i]~arr[i-1]中选取最小值，与arr[i]进行交换；
总共通过n-1次，可以得到从小到大的有序序列。

以序列：{8, 3, 2, 1, 7, 4, 6, 5} 为例！分步骤图解如下：              

综上所述：

1. 在每趟排序时，都默认当前位置的元素为最小值，如果在遍历过程中发现有比当前位置元素还小的值，则替换最小值。（先将最小值记录，此趟遍历完成再替换）
2. 选择排序一共有arr.length-1次趟排序。

        代码一如下实现：

  public static void selectSort(int[] arr){
        //选择排序过程
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i; //假定最小索引，最小值为第一个元素
            int min = arr[minIndex];
            for (int j = i + 1; j < arr.length; j++) {
                if (min > arr[j]){
                    //更新最小值
                    min = arr[j];
                    minIndex = j;
                }
            }
            //将最小值放进arr[i]
            if (i != minIndex){
                arr[minIndex] = arr[i];
                arr[i] = min;
            }
            //输出每轮排序后的结果
            System.out.println("第" + (i+1) + "趟: " + Arrays.toString(arr));
        }
    }

        代码二（更易理解）：

    public static void selectSort(int[] array) {
        for (int i = 0; i < array.length; i++) {
            int minIndex = i;
            int j = i+1;
            for (; j < array.length; j++) {
                if(array[j] < array[minIndex]) {
                    minIndex = j;
                }
            }
            swap(array,i,minIndex);
        }
    }

    private static void swap(int[] array,int i,int j) {
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }

        测试代码及结果：

public static void main(String[] args) {
        int[] array = {8, 3, 2, 1, 7, 4, 6, 5};
        System.out.println("排序前: " + Arrays.toString(array));
        selectSort(array);
        System.out.println("排序后: " + Arrays.toString(array));
    }

       

3.1.2 直接选择排序的特性总结

1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用

2. 时间复杂度：O(N^2)

3. 空间复杂度：O(1)

4. 稳定性：不稳定

3.2 堆排序

        堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。（关于堆的相关详细知识见于前面相应章节）分为两种方法：        

        大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；

        小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；

3.2.1 详细思路与图解分析

        图解如下图所示： 

由上图所示，该方法思路如下所示：

1. 创建一个堆 H[0……n-1]；

2. 把堆首（最大值）和堆尾互换；

3. 把堆的尺寸缩小 1，并调用相应方法，目的是把新的数组顶端数据调整到相应位置；

4. 重复步骤 2，直到堆的尺寸为 1

代码实现如下：

    private  void swap(int[] array,int i,int j) {
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }
    public  void heapSort(int[] array) {
        createBigHeap(array);
        int end = array.length-1;
        while (end > 0) {
            swap(array,0,end);
            shiftDown(array,0,end);
            end--;
        }
    }

    private  void createBigHeap(int[] array) {
        for (int parent = (array.length-1-1)/2; parent >= 0 ; parent--) {
            shiftDown(array,parent,array.length);
        }
    }

    private  void shiftDown(int[] array,int parent,int len) {
        int child = 2*parent+1;
        while (child < len) {
            if(child+1 < len && array[child] < array[child+1]) {
                child++;
            }
            if(array[child] > array[parent]) {
                swap(array,child,parent);
                parent = child;
                child = 2*parent+1;
            }else {
                break;
            }
        }
    }

3.2.2 分析与总结

1. 堆排序使用堆来选数，效率就高了很多。

2. 时间复杂度：O(N*logN)

3. 空间复杂度：O(1)

4. 稳定性：不稳定

ps：本次的学习就到这里了，如果喜欢的话就请一键三连哦~~~