排序（希尔快排堆排归并）

前面我们讲了插入、选择、冒泡三种排序
下面我们来讲讲剩下的几种排序

希尔排序

原理
希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分
成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和
排序的工作。当到达=1时，所有记录在统一组内排好序。

1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，
   这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
   
   代码实现

 //不区分最好情况和最坏情况
    //时间复杂度: O(n^1.3 ~ 1.4)
    //空间复杂度: O(1)
    //不具备稳定性
    public static void shellSort(long[] array) {
        int group = array.length / 2;

        while (true) {
            insertSortWithGroup(array, group);
            if (group == 1) {
                break;
            }
            group = group / 2;
        }
    }

    private static void insertSortWithGroup(long[] array, int group) {
        for (int i = group; i < array.length; i++) {

            long key = array[i];
            int j;
            for (j = i - group; j >= 0 && array[j] > key; j -= group) {
                array[j + group] = array[j];
            }

            array[j + group] = key;
        }
    }

性能分析
不区分最好情况和最坏情况
时间复杂度: O(n^1.3 ~ 1.4)
空间复杂度: O(1)
不具备稳定性

堆排序

原理
基本原理也是选择排序，只是不在使用遍历的方式查找无序区间的最大的数，而是通过堆来选择无序区间的最大的数。
注意： 排升序要建大堆；排降序要建小堆。

代码实现

// 没有最好/平均/最坏的情况
    // 时间复杂度: O(n * log(n))
    // 空间复杂度: O(1)
    // 不具备稳定性
    public static void heapSort(long[] array) {
        createBigHeap(array);   // O(n * log(n))

        for (int i = 0; i < array.length - 1; i++) {    // O(n * log(n))
            // 交换之前：无序区间：[0, array.length - i)
            // 交换最大的数 [0] 和无序区间的最后一个数 [array.length - i - 1]
            swap(array, 0, array.length - i - 1);   // O(1)
            // 交换完成之后：无序区间：[0, array.length - i - 1)
            // 一共 array.length - i - 1 个元素
            adjustDown(array, array.length - i - 1, 0); // O(log(n))
        }
    }

    // 建 **大** 堆：堆中的元素是 array.length 个
    private static void createBigHeap(long[] array) {
        for (int i = (array.length - 2) / 2; i >= 0; i--) {
            adjustDown(array, array.length, i);
        }
    }

    private static void adjustDown(long[] array, int size, int index) {
        while (true) {
            int leftIndex = 2 * index + 1;
            if (leftIndex >= size) {
                return;
            }

            int rightIndex = 2 * index + 2;
            int maxIndex = leftIndex;
            if (rightIndex < size && array[rightIndex] > array[leftIndex]) {
                maxIndex = rightIndex;
            }

            if (array[index] >= array[maxIndex]) {
                return;
            }

            swap(array, index, maxIndex);

            index = maxIndex;
        }
    }

性能分析
没有最好/平均/最坏的情况
时间复杂度: O(n * log(n))
空间复杂度: O(1)
不具备稳定性

快速排序

原理

1. 从待排序区间选择一个数，作为基准值(pivot)；
2. Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基
   准值大的（可以包含相等的）放到基准值的右边；
3. 采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1，代表已经有序，
   或者小区间的长度 == 0，代表没有数据。
   
   
   代码实现

public static void quickSort(long[] array) {
        quickSortRange(array, 0, array.length - 1);
    }

    // [from]、[to] 的元素都包含在区间内
    private static void quickSortRange(long[] array, int from, int to) {
        int size = to - from + 1;
        if (size <= 1) {
            return;
        }

        int pivotIdx = partition3(array, from, to);
        // 通过基准值切割后的
        // 左边的区间: [from, pivotIdx - 1]
        // 右边的区间: [pivotIdx + 1, to]

        quickSortRange(array, from, pivotIdx - 1);
        quickSortRange(array, pivotIdx + 1, to);
    }

partition过程：

private static int partition1(long[] array, int from, int to) {
        long pivot = array[from];
        int left = from;
        int right = to;

        while (left < right) {  // 只要还有没有比较过的元素，就继续
            while (left < right && array[right] >= pivot) {
                right--;
            }

            while (left < right && array[left] <= pivot) {
                left++;
            }

            Swap.swap(array, left, right);
        }

        Swap.swap(array, from, left);
        return left;
    }



    private static int partition2(long[] array, int from, int to) {
        long pivot = array[from];
        int left = from;
        int right = to;

        while (left < right) {  // 只要还有没有比较过的元素，就继续
            while (left < right && array[right] >= pivot) {
                right--;
            }

            array[left] = array[right];

            while (left < right && array[left] <= pivot) {
                left++;
            }

            array[right] = array[left];
        }

        array[left] = pivot;

        return left;
    }

    // O(n)
    private static int partition3(long[] array, int from, int to) {
        long pivot = array[from];
        int s = from + 1;
        for (int i = from + 1; i <= to; i++) {
            if (array[i] < pivot) {
                Swap.swap(array, i, s);
                s++;
            }
        }

        Swap.swap(array, from, s - 1);

        return s - 1;
    }

性能分析
最好的情况：完全二叉树情况
最坏的情况：单支树情况
最好情况的时间复杂度：O(nlog(n))
最坏情况的时间复杂度：O(n ^ 2)
平均情况的时间复杂度：O(nlog(n))
能否保证稳定性：不能保证稳定性
最好情况的空间复杂度：O(log(n))
最坏情况的空间复杂度：O(n)

归并排序

原理
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

代码实现

public static void mergeSort(long[] array) {
        mergeSortRange(array, 0, array.length);
    }

    // [from, to)
    private static void mergeSortRange(long[] array, int from, int to) {
        int size = to - from;
        if (size <= 1) {
            return;
        }

        //int mid = (from + to) / 2;
        int mid = from + (to - from) / 2;
        // 左半边: [from, mid)
        // 右半边: [mid, to)

        // 先让左右区间各自有序
        mergeSortRange(array, from, mid);
        mergeSortRange(array, mid, to);

        // 合并两个有序区间 [from, mid) [mid, to)
        merge(array, from, mid, to);
    }

    private static void merge(long[] array, int from, int mid, int to) {
        // 需要额外空间，需要两个区间的大小之和
        int size = to - from;
        long[] array2 = new long[size];

        int k1 = from;  // array
        int k2 = mid;   // array
        int k3 = 0;     // array2

        while (k1 < mid && k2 < to) {
            if (array[k1] <= array[k2]) {   // 加等号是为了保证稳定性
                array2[k3++] = array[k1++];
            } else {
                array2[k3++] = array[k2++];
            }
        }

        // 有一个区间内的元素全部取完了
        if (k1 < mid) {
            // 左边区间还有元素
            while (k1 < mid) {
                array2[k3++] = array[k1++];
            }
        } else {
            // 右边区间还有元素
            while (k2 < to) {
                array2[k3++] = array[k2++];
            }
        }

        // 我们还需要把数据搬回原数组中
        for (int i = 0; i < size; i++) {
            array[from + i] = array2[i];
        }
    }

性能分析
归并排序不区分最好情况和最坏情况
时间复杂度：O(n*log(n))
空间复杂度：O(n)
并且具备稳定性