排序

1、排序只能应用在线性结构上，虽然链表也可以排序，但无特殊说明时，默认都是数组排序。

2、排序的稳定性：保证一定不会交换相等元素的相对位置。

3、内部排序依赖的存储只有内存，外部排序依赖的不仅仅是内存，还包括硬盘等持久化存储。前者数据量小，后者数据量大。

4、7种基于“比较”的排序（元素之间需要具备比较的能力）：插入排序，希尔排序，选择排序，冒泡排序，堆排序，快速排序，归并排序。

插入排序：

public static void insertSort(long[] array) {
        for (int i = 1; i < array.length; i++) {
            long toInsert = array[i];
            int j;
            for (j = i - 1; j >= 0 && toInsert < array[j]; j--) {  // 不加等号，具备稳定性
                array[j + 1] = array[j];
            }
            array[j + 1] = toInsert;
        }
    }

希尔排序

 public static void shellSort(long[] array) {
        int group = array.length / 2;
        while (true) {
            groupInsertSort(array, group);
            if (group == 1) {
                // 只有 1 组，并且已经完成排序时，停止循环
                return;
            }
            group = group / 2;
        }
    }

   private static void groupInsertSort(long[] array, int group) {
        for (int i = group; i < array.length; i++) {
            long toInsert = array[i];
            int j;
            for (j = i - group; j >= 0 && toInsert < array[j]; j -= group) {
                array[j + group] = array[j];
            }
            array[j + group] = toInsert;
        }
    }

选择排序：

public static void selectSort(long[] array) {
        
        for (int i = 0; i < array.length - 1; i++) {
            // 无序区间：[0, array.length - i) 元素个数 array.length - i

            // 内部的循环整体，遍历无序区间，找到最大的元素的过程 => 最大元素所在的下标
            int maxElementIdx = -1;
            for (int j = 0; j < array.length - i; j++) {
                if (maxElementIdx == -1 || array[j] > array[maxElementIdx]) {
                    maxElementIdx = j;
                }
            }

            // 交换，最大的元素 和 无序区间最后一个元素的位置
            // 要交换，需要最大元素的下标，和最后一个元素的下标
            Swap.swap(array, maxElementIdx, array.length - i - 1);
        }
    }

冒泡排序

public static void bubbleSort(long[] array) {
        // 要排好整个数组，一共需要多少次冒泡过程
        for (int i = 0; i < array.length - 1; i++) {
            // 无序区间：[0, array.length - i) 元素个数 array.length - i

            boolean sorted = true;

            // 内部的循环整体，表示一次冒泡过程
            // 冒泡过程：
            // 无序区间的相邻的两个元素，需要两两比较一次
            for (int j = 0; j < array.length - i - 1; j++) {
                // 永远保证，相邻两个元素，最大的在后边
                if (array[j] > array[j + 1]) {  // 不加等号，具备稳定性
                    Swap.swap(array, j, j + 1);
                    sorted = false;
                }
            }

            if (sorted) {
                return;
            }
        }
    }

public class Swap {
    public static void swap(long[] array, int i, int j) {
        long t = array[i];
        array[i] = array[j];
        array[j] = t;
    }
}

堆排序

 public static void heapSort(long[] array) {
        createBigHeap(array);

        for (int i = 0; i < array.length - 1; i++) {
            // 无序区间：[0, array.length - i)
            Swap.swap(array, 0, array.length - i - 1);
            // 无序区间：[0, array.length - i - 1) 元素个数 array.length - i - 1

            shiftDown(array, array.length - i - 1, 0);
        }
    }
}

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

            int max = left;
            if (right < size && array[right] > array[left]) {
                max = right;
            }

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

            Swap.swap(array, index, max);

            index = max;
        }
    }

快速排序

import java.util.Arrays;

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

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

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

    private static int partition(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;
    }

   
    public static void main(String[] args) {
        //long[] array = { 5, 9, 2, 7, 3, 6, 8, 4, 0 };
        int from = 0;
        int to = 8;

        System.out.println(Arrays.toString(array));
        partition3(array, from, to);
        System.out.println(Arrays.toString(array));
    }
}

归并排序

import java.util.Arrays;

public class MergeSort {
   
    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 - from) / 2;
        // [from, mid) 和 [mid, to)

        mergeSortRange(array, from, mid);
        mergeSortRange(array, mid, to);

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

    // 时间复杂度: O(n)
    // 空间复杂度: O(n)
    private static void merge(long[] array, int from, int mid, int to) {
        // 合并 [from, mid) 和 [mid, to) 的两个有序区间
        int size = to - from;
        long[] extra = new long[size];
        int k1 = from;
        int k2 = mid;
        int k3 = 0;

        // 两个区间中还各自有元素，选择出小的放到 extra 中
        while (k1 < mid && k2 < to) {
            if (array[k1] <= array[k2]) {   // 加等号，保证稳定性
                extra[k3++] = array[k1++];
            } else {
                extra[k3++] = array[k2++];
            }
        }

        // 再把剩余的元素复制到 extra 中
        if (k1 < mid) {
            while (k1 < mid) {
                extra[k3++] = array[k1++];
            }
        } else {
            while (k2 < to) {
                extra[k3++] = array[k2++];
            }
        }

        // 把所有的元素从 extra 复制回 array 中
        for (int i = 0; i < size; i++) {
            array[from + i] = extra[i];
        }
    }

    public static void main(String[] args) {
        long[] array = { 9, 7, 1, 3, 5, 8, 2, 4, 0, 6 };
        mergeSort(array);

        System.out.println(Arrays.toString(array));
    }
}