排序算法（1）

先赞后看，养成习惯！！！ ^ _ ^ ❤️ ❤️ ❤️
码字不易，大家的支持就是我坚持下去的动力，点赞后不要忘记关注我哦

个人主页：伯明翰java

文章专栏：数据结构和算法

如有错误，请您指正批评 ^ _ ^

什么是排序

排序：所谓排序，就是使⼀串记录，按照其中的某个或某些关键字的⼤⼩，递增或递减的排列起来的

操作
稳定性 ：如果待排序的一组数据中，有多个相同的数据，经过排序后如果这些相同数据的相对次序不变就是稳定排序，如果相对次序发生变化就是不稳定排序
注：如果这个排序算法是稳定的，它可以变成不稳定排序，如果是不稳定排序，它变不成稳定排序

常见的排序算法

常见排序算法实现

插入排序

直接插⼊排序是⼀种简单的插⼊排序法，其基本思想是：把待排序的记录按其关键码值的⼤⼩逐个插⼊到⼀个已经排好序的有序序列中，直到所有的记录插⼊完为⽌，得到⼀个新的有序序列。

当插⼊第i(i>=1)个元素时，前⾯的array $0$ ,array $1$ ,R,array $i-1$ 已经排好序，此时⽤array $i$ 的排序码

与array $i-1$ ,array $i-2$ ,R的排序码顺序进⾏⽐较，找到插⼊位置即将array $i$ 插⼊，原来位置上的元素

顺序后移

java 复制代码

/**
     * 直接插入排序
     * 时间复杂度O(n^2)
     * 稳定排序
     * 空间复杂度O(1）
     * @param arr
     */
    public static void insetSort(int[] arr){
       int j;
       for (int i=1;i<arr.length;i++){
           int temp = arr[i];
           for (j=i-1;j>=0&&arr[j]>temp;j--){
               arr[j+1]=arr[j];

           }
           arr[j+1]=temp;
       }

    }

特点

元素集合越接近有序，直接插⼊排序算法的时间效率越⾼
时间复杂度：O(N^2
空间复杂度：O(1)，它是⼀种稳定的排序算法
稳定性：稳定

希尔排序

希尔排序法⼜称缩⼩增量法。希尔排序法的基本思想是：先选定⼀个整数，把待排序⽂件中所有记录

分成多个组，所有距离为的记录分在同⼀组内，并对每⼀组内的记录进⾏排序。然后，取，重复上述

分组和排序的⼯作。当到达=1时，所有记录在统⼀组内排好序。

java 复制代码

 /**
     * 希尔排序
     * 时间复杂度O(n^3/2)
     * 稳定排序
     * 空间复杂度O(1)
     * @param array
     */
    public static void shellSort(int[] array){
        int d=array.length;
        while (d>1){
            d=d/2;
            for (int i=d;i<array.length;i++){
                int temp = array[i];
                int j=i-d;
                while (j>=0&&array[j]>temp){
                    array[j+d]=array[j];
                    j-=d;
                    array[j+d]=temp;
                }
            }
        }

    }

特点

希尔排序是对直接插⼊排序的优化
当gap > 1时都是预排序，⽬的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这
样就会很快。这样整体⽽⾔，可以达到优化的效果。我们实现后可以进⾏性能测试的对⽐。

选择排序

每⼀次从待排序的数据元素中选出最⼩（或最⼤）的⼀个元素，存放在序列的起始位置，直到全部待

排序的数据元素排完。

直接选择排序

在元素集合array $i$ --array $n-1$ 中选择关键码最⼤(⼩)的数据元素

• 若它不是这组元素中的最后⼀个(第⼀个)元素，则将它与这组元素中的最后⼀个（第⼀个）元素交

换

• 在剩余的array $i$ --array $n-2$ （array $i+1$ --array $n-1$ ）集合中，重复上述步骤，直到集合剩余1个

元素

java 复制代码

 /**x
     *  选择排序
     *  时间复杂度O(n^2)
     *  不稳定排序
     *  空间复杂度O(1)
     * @param array
     */
    public static void selectSort(int[] array){
        for (int i=0;i<array.length;i++){
            int mindex=i;
            for (int j=i+1;j<array.length;j++){
                if (array[j]<array[mindex]){
                    mindex=j;
                }

            }
            swep(array,i,mindex);
        }
    }

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

特点：

直接选择排序思考⾮常好理解，但是效率不是很好。实际中很少使⽤
时间复杂度：O(N^2)
空间复杂度：O(1)
稳定性：不稳定

堆排序

堆排序(Heapsort)是指利⽤堆积树（堆）这种数据结构所设计的⼀种排序算法，它是选择排序的⼀

种。它是通过堆来进⾏选择数据。需要注意的是排升序要建⼤堆，排降序建⼩堆。

java 复制代码

/**
     * 时间复杂度O(nlogn)
     * 堆排序
     *空间复杂度O(1)
     * 不稳定排序
     * @param array
     */
    public static void heapSort(int[] array ){
        creatHeap(array);
        int end=array.length-1;
        while (end>0){
            swep(array,0,end);
            siftDown(array,0,end);
            end--;
        }

    }

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

    /**
     *
     * @param array
     * @param parent 每颗子树的根节点
     * @param length 每颗子树调整结束节点
     */
    private static void siftDown(int[] array, int parent, int length) {

        int child=parent*2+1;
        while (child<length){
            if(child+1<length && array[child]<array[child+1]){
                child++;
            }
            if (array[child]>array[parent]){
                swep(array,parent,child);
                parent=child;
                child=parent*2+1;
            }else {
                break;
            }
        }
    }

特点：

堆排序使⽤堆来选数，效率就⾼了很多
时间复杂度：O(N*logN)
空间复杂度：O(1)
稳定性：不稳定