[数据结构]排序

目录

1、排序的概念

2、常见排序算法

3、直接插入排序

4、希尔排序

5、直接选择排序

6、堆排序

7、冒泡排序

---

1、排序的概念

排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作

稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持 不变，则称这种排序算法是稳 定的；否则称为不稳定的

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

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

2、常见排序算法

3、直接插入排序

逻辑：

1. 假设这组数据的第一个元素是有序的

2. 从第二个元素开始，依次和前面的元素进行比较找到合适的位置就进行插入

    /**
     * 时间复杂度：
     *    最坏情况下：O(n^2)  5   4   3   2   1
     *    最好情况下：O(n)   当数据越有序 排序越快   1  2  3  4  5
     *    适用于：待排序序列  已经基本上趋于有序了！
     * 空间复杂度：O(1)
     * 稳定性：稳定的
     * @param array
     */
    public static void insertSort(int[] array) {
        for (int i = 1; i < array.length; i++) {
            int tmp = array[i];
            int j = i-1;
            for (; j >= 0 ; j--) {
                // 这里加不加等号  和稳定有关系
                // 但是：本身是一个稳定的排序 可以实现为不稳定的排序
                // 本身是一个不稳定的排序 是不可能变成一个稳定的排序的
                if(array[j] > tmp) {
                    array[j+1] = array[j];
                }else {
                    break;
                }
            }
            array[j+1] = tmp;
        }
    }

直接插入排序的特性总结：

1. 元素集合越接近有序，直接插入排序算法的时间效率越高

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

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

4. 稳定性：稳定 

4、希尔排序

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

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

    // 希尔排序
    public static void shellSort(int[] array) {
        int gap = array.length;
        while (gap > 1) {
            gap /= 2;
            shell(array,gap);
        }
    }

    // 对每组进行插入排序
    public static void shell(int[] array,int gap) {
        for (int i = gap; i < array.length; i++) {
            int tmp = array[i];
            int j = i-gap;
            for (; j >= 0 ; j-=gap) {
                if(array[j] > tmp) {
                    array[j+gap] = array[j];
                }else {
                    break;
                }
            }
            array[j+gap] = tmp;
        }
    }

希尔排序的特性总结：
1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序了，这样会很快。对整体而言，可以达到优化的效果
3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此时间复杂度都不固定，严蔚敏版的数据结构教材给出的是 O(N^1.3) ~ O(N^1.5)

4. 稳定性：不稳定

5、直接选择排序

直接选择排序/简单选择排序：每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完

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

直接选择排序的特性总结
1. 直接选择排序非常好理解，但是效率不是很好。实际中很少使用
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)
4. 稳定性：不稳定

2. 双向选择排序

代码思想：遍历一遍数组，找到数组的最大最小值，将最大值交换到后面，最小值交换到前面，直到 left 和 right 相遇。

1. 定义两个变量 minIndex , maxIndex来记录遍历一次数组得到数组的最大值和最小值的下标

2.定义 left 引用指向数组的第一个元素，定义 right 引用指向数组的最后一个元素

3. 遍历一遍后将最小值交换到前面，最大值交换到后面。left 向后走，right 向前走

4. 注意，找到 minIndex , maxIndex 后，先交换 minIndex 和 left 的值，如果 maxIndex 的指向刚好是数组的 left 指向，在交换 maxIndex 和 right 之前要更新 maxIndex 指向

时间复杂度也是 O(N^2)

    public static void selectSort2(int[] array) {
        int left = 0;
        int right = array.length-1;
        while (left < right) {
            int minIndex = left;
            int maxIndex = left;
            for (int i = left+1; i <= right ; i++) {
                if(array[i] < array[minIndex]) {
                    minIndex = i;
                }
                if(array[i] > array[maxIndex]) {
                    maxIndex = i;
                }
            }
            swap(array,minIndex,left);
            //防止 第一个是最大值 ，如果和最小的一换，最大值就跑到了原来最小值的位置
            if(maxIndex == left) {
                maxIndex = minIndex;
            }
            swap(array,maxIndex,right);
            left++;
            right--;
        }
    }

6、堆排序

堆排序即利用堆的思想来进行排序，总共分为两个步骤：
1. 建堆
升序：建大堆
降序：建小堆
2. 利用堆删除思想来进行排序
建堆和堆删除中都用到了向下调整，因此掌握了向下调整，就可以完成堆排序

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

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

    /**
     * 时间复杂度：O(N*logN)
     * 空间复杂度：O(1)
     * 稳定性：不稳定的排序
     * @param array
     */
    public static void heapSort(int[] array) {
        createHeap(array);
        int end = array.length-1;
        while (end > 0) {
            swap(array,0,end);
            siftDown(array,0,end);
            end--;
        }
    }

堆排序的特性总结：

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

        建堆：O(N)

        排序：O(N*logN)

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

4. 稳定性：不稳定 

7、冒泡排序

基本思想：在待排序的一组数中，将相邻的两个数进行比较，若前面的数比后面的数大就交换两数，否则不交换；如此下去，直至最终完成排序 。由此可得，在排序过程中，大的数据往下沉，小的数据往上浮，就像气泡一样，于是将这种排序算法形象地称为冒泡排序

    public static void bubbleSort(int[] array) {
        //i代表的是趟数
        for (int i = 0; i < array.length-1; i++) {
            boolean flg = false;
            //j来比较 每个数据的大小
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j] > array[j+1]) {
                    swap(array,j,j+1);
                    flg = true;
                }
            }
            if(flg == false) {
                break;
            }
        }
    }

冒泡排序的特性总结
2. 时间复杂度：O(N^2) ，最好情况下 可以达到O(N)
3. 空间复杂度：O(1)
4. 稳定性：稳定 

由于篇幅有限，快速排序和归并排序放到下一小节