排序算法

*时间复杂度

排序算法	平均时间复杂度	最坏时间复杂度	空间复杂度	稳定性
冒泡排序	O( n ^ 2)	O( n ^ 2)	O(1)	是
选择排序	O( n ^ 2)	O( n ^ 2)	O(1)	不是
插入排序	O( n ^ 2)	O( n ^ 2)	O(1)	是
归并排序	O( n log n)	O( n log n)	O(n)	是
快速排序	O( n log n)	O( n ^ 2)	O(log n)	不是
堆排序	O( n log n)	O( n log n)	O(1)	不是

1. 冒泡排序

两两对比，较大的数往后面沉。

    public static void bubbleSort(int[] arr) {
        for(int i = arr.length - 1; i > 0; i--) {
            for(int j = 0; j < i; j++) {
                if(arr[j] > arr[j + 1]) {
                    //两两对比，大的数往后面沉
                    swap(arr, j, j + 1);
                }
            }
        }
    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

2. 选择排序

最前面的数分别与后面所有数对比，找出最小的，交换。

    public static void selectSort(int[] arr) {
        for(int i = 0; i < arr.length; i++) {
            int min = i;
            for(int j = i + 1; j < arr.length; j++) {
                //从当前位置往后面找，选择一个最小的数
                if(arr[j] < arr[min]) {
                    min = j;
                }
            }
            swap(arr, i, min);
        }
    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

3. 插入排序

类似于打扑克牌，已经在手上的牌有序，新抽的牌插入到有序的位置。

第二个数与第一个数比较，排序。第三个数与前两个数比较，排序。

　　public static void insertSort(int[] arr) {
        for(int i = 1; i < arr.length; i++) {
            for(int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
                swap(arr, j, j+ 1);
            }
        }
    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

4. 希尔排序

是简单插入排序的优化版，与插入排序的不同之处在于，会优先比较距离较远的元素，希尔排序又叫缩小增量排序。

public static void shellSort(int[] arr) {
        int temp = 1;
        while(temp < arr.length / 3)
            temp = temp * 3 + 1;
        while(temp >= 1) {
            for(int i = temp; i < arr.length; i++) {
                if(arr[i] < arr[i - temp]) {
                    swap(arr, i, i - temp);
                }
            }
            temp = temp / 3;
        }
        SelectSort s = new SelectSort();
        s.selectSort(arr);
    }
    
    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

 

5. 归并排序

分治的思想，不断将数组二分，直到不可再分时（即只剩一个元素时）便有序了，然后在将两部分合并的时候，利用外排将两部分合成有序序列

　　public static void mergeSort(int[] arr) {
        if(arr == null || arr.length < 2) return;
        mergeSort(arr, 0, arr.length - 1);
    }

    public static void mergeSort(int[] arr, int left, int right) {
        if(left == right) return;
        int mid = left + ((right - left) >> 1);
        //右移一位时除于2，右移 n 位相当于除于 2 的 n 次方
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);
        merge(arr, left, mid, right);
        //合并分开的两部分
    }

    public static void merge(int[] arr, int left, int mid, int right) {
        int[] help = new int[right - left + 1];
        //辅助数组，空间复杂度O（n）
        int index = 0;
        int p1 = left, p2 = mid + 1;
        //通过外排的方式，按照顺序放入辅助数组中
        while(p1 <= mid && p2 <= right) {
            help[index++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
        }
        while(p1 <= mid) {
            help[index++] = arr[p1++];
        }
        while(p2 <= right) {
            help[index++] = arr[p2++];
        }
        //将辅助数组中的元素复制回原素组
        for(int i = 0; i < help.length; i++) {
            arr[left + i] = help[i];
        }
    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

6. 快速排序

经典快排：选择一个元素作为切分元素，左右两个指针分别向中间遍历，当左遇到大于切分元素，而右小于切分元素时，两者交换，继续遍历，直到左边都小于切分元素，右边都大于切分元素，一趟结束。

性能分析：

• 快排是原地排序，不需要辅助数组，但是递归调用需要辅助栈，快排最好的情况是每次切分元素都正好将数组对半分，这样递归调用的次数是最少的。
• 实现方法：1. 随机快排，每趟快排之前随机选取一个元素与原定切分元素交换。 2. 三数取中，最好的情况是每次都能取到数组的中位数作为切分元素，但是计算中位数显然不可取，折中的方法是：每趟快排选取3个元素，取中间的值作为切分元素
• 三向切分优化：大于有大量重复元素的数组，可以将数组划分为三部分，分别对应小于、等于、大于切分元素。对于大量重复元素的随机数组可以在线性时间内完成排序。

    public static void quickSort(int[] arr) {
        if(arr == null || arr.length < 2) return;
        quickSort(arr, 0, arr.length - 1);
    }

    public static void quickSort(int[] arr, int left, int right) {
        if(left < right) {
            swap(arr, right, left + (int)(Math.random()*(right - left + 1)));
            //随机快排实现：随机生成left-right中的下标，然后与right位置的值交换
            int[] result = partition(arr, left, right);
            //三向切分优化快排，返回等于划分right位置的值的前后下标
            quickSort(arr, left, result[0] - 1);
            quickSort(arr, result[1] + 1, right);
        }
    }

    public static int[] partition(int[] arr, int left, int right) {
        int less = left - 1;
        int more = right;
        int index = left;
        while(index < more) {
            if(arr[index] < arr[right]) {
                //小于基准值，与小于区域的后一个值交换
                swap(arr, index++, ++less);
            } else if(arr[index] > arr[right]) {
                //大于基准值，与大于区域的前一个值交换
                swap(arr, index, --more);
            } else {
                //等于基准值时，继续遍历下一个数
                index++;
            }
        }
        swap(arr, more, right);
        return new int[]{less + 1, more};
    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

7.堆排序

堆的底层结构使用数组实现，每个结点的父亲结点为 ( i - 1) / 2 ，孩子结点为 2 * i + 1 和 2 * i + 2。

排序过程：先将数组构建成大顶堆，然后将堆顶元素与最后一个元素交换（最后一个元素不一定最小，但一定会比堆顶元素小），交换之后除掉最后一个元素（即原堆顶元素）重新调整为大顶堆。

    public static void heapSort(int[] arr) {
        if(arr == null || arr.length < 2) return;
        for(int i = 0; i < arr.length; i++) {
            heapInsert(arr, i);
        }
        int size = arr.length - 1 ;
        swap(arr, 0, size);
        while(size > 0) {
            heapify(arr, 0, size--);
            swap(arr, 0, size);
        }
    }
    //构建大顶堆
    public static void heapInsert(int[] arr, int index) {
        //不断与父亲节点比较，交换
        while(arr[index] > arr[(index - 1) / 2]) {
            swap(arr, index, (index - 1) / 2);
            index = (index - 1) / 2;
        }
    }

    //当将堆顶与最后一个数交换后，重建构建大顶堆
    public static void heapify(int[] arr, int index, int size) {

        int left = index * 2 + 1;

        while(left < size) {
            int largeSet = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left;
            //选择孩子结点中较大的一个
            if(arr[index] > arr[largeSet]) {
                break;
            }
            swap(arr, index, largeSet);
            index = largeSet;
            left = index * 2 + 1;
        }
    }


    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }