七大基于比较的排序

 排序

就是使一串记录，按照其中的某个关键字的大小，递增或递减排列起来的操作。通常意义上的排序，指的是原地排序（升序）。

稳定性：两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化，则称该算法是具备稳定性的排序。

例如：9    5（a）    4    6    5（b）    0，排序后为：4    5（a）    5（b）    6    9

1.直接插入排序：将整个区间分为无序区间（后面）和有序区间（前面的部分），每次选择无序区间的第一个元素，插入在有序区间合适的位置。

//  直接插入排序。时间复杂度最坏O(n^2),最好O(n）。空间复杂度O(1)
// 思路：前面为有序（从后往前判断），后面为无序，（从前往后遍历）
 public static void insertSort(int[] array){
        // 有序区间: [0, i)
        // 无序区间: [i, array.length)
        for(int i = 1;i < array.length;i++){
            int key = array[i];// 保存当前待排序数据
            int j;// 遍历有序部分从后往前比较
            for(j = i - 1;j >= 0 && array[j] > key;j--){
                //条件：如果 j 到达第一个位置表示这个数就是最小的，如果 key >= array[j] 就不用进行处理
                array[j + 1] = array[j];
            }
            array[j + 1] = key;// 将 key 值放到他该在的位置
        }
    }

 折半插入排序：在有序区间选择合适的位置插入时，由于元素已经有序，所以可以利用折半查找的思想。

public static void binaryInsertSort(int[] array){
        for(int i = 1;i < array.length;i++){
            int key = array[i];
            int left = 0;
            int right = i;
            while(left < right){
                int mid = (left + right) / 2;
                if(key >= array[mid]){
                    left = mid + 1;
                }else{
                    right = mid;
                }
            }
            for(int j = i;j > left;j--){
                array[j] = array[j - 1];
            }
            array[left] = key;
        }
    }

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

希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。
1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。

// 希尔排序:分组对数据进行预处理
    public static void shellSort(int[] array){
        int gap = array.length;
        while(true){
            gap /= 2;
            // 排序
            for(int i = gap;i < array.length;i++){
                int key = array[i];
                int j = i - gap;
                for(;j >= 0 && array[j] > key;j -= gap){
                    array[j + gap] = array[j];
                }
                array[j + gap] = key;
            }
            if(gap == 1){
                break;
            }
        }
    }

3.直接选择排序：每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元
素排完 。

 //每次选择最大的元素放到无序区间的最后面,无序在前，有序在后
    public static void selectSort1(int[] array){
        // 无序区间: [0, array.length - i)
        // 有序区间: [array.length - i, array.length)
        for(int i = 0;i < array.length - 1;i++){// 有序
            int max = 0;
            for(int j = 1;j < array.length - i;j++){
                if(array[j] > array[max]){
                    max = j;
                }
            }
            swap(array,array.length - 1 - i,max);
        }
    }
    //每次选择最小的元素放到无序区间的最前面,有序在前，无序在后
    public static void selectSort2(int[] array){
        // 有序区间[0,i)
        //无序区间[i,array.length)
        for(int i = 0;i < array.length - 1;i++){
            int min = i;
            for(int j = i + 1;j < array.length;j++){
                if(array[j] < array[min]){
                    min = j;
                }
            }
            swap(array,min,i);
        }
    }
    public static void swap(int[] array,int a,int b){
        int t = array[a];
        array[a] = array[b];
        array[b] = t;
    }

双向选择排序：每一次从无序区间选出最小 + 最大的元素，存放在无序区间的最前和最后，直到全部待排序的数据元素排完 。

public static void selectSortOP(int[] array){
        // 无序区间[begin,end]
        int begin = 0;
        int end = array.length - 1;
        while(begin < end) {
            int min = begin;
            int max = begin;
            for (int i = begin ; i <= end; i++){// 遍历有序
                if(array[i] > array[max]){
                    max = i;
                }
                if(array[i] < array[min]){
                    min = i;
                }
            }
            swap(array, min, begin);
            if(max == begin){
                max = min;
            }
            swap(array,max,end);
            begin++;
            end--;
        }
    }

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

// 堆排序
    public static void heapSort(int[] array){// 4 3 2 1
        createHeapBig(array);
        for(int i = 0;i < array.length - 1;i++){
            swap(array,0,array.length - 1 - i);
            shiftDownBig(array,0,array.length - 1 - i);
        }
    }
    // 建立大根堆
    private static void createHeapBig(int[] array) {
        for(int i = (array.length - 2)/2;i >= 0 ;i--){
            shiftDownBig(array,i,array.length);
        }
    }
    // 向下调整
    private static void shiftDownBig(int[] array, int index, int size) {
        int left = index * 2 + 1;
        while(left < size){
            int right = left + 1;
            int max = left;
            if(right < size && array[right] > array[max]){
                max = right;
            }
            if(array[index] >= array[max]){
                break;
            }
            swap(array,index,max);
            index = max;
            left = index * 2 + 1;
        }
    }

5.冒泡排序：在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序。

// 冒泡排序:相邻数比较，将大的放在后面
    public static void bubbleSort(int[] array){
        for (int i = 0; i < array.length - 1; i++) {
            boolean isSorted = true;
            for (int j = 0; j < array.length - i - 1; j++) {
                // 相等不交换，保证稳定性
                if (array[j] > array[j + 1]) {
                    swap(array, j, j + 1);
                    isSorted = false;
                }
            }
            if (isSorted) {
                break;
            }
        }
    }

6.快速排序：

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

public static void quickSort(int[] array){
        quickSortInter(array,0,array.length - 1);
    }
    private static void quickSortInter(int[] array, int left, int right) {// 左右都是闭区间
        if(left >= right){
            return;
        }
        //int pivotIndex = partition1(array,left,right);
        //int pivotIndex = partition2(array,left,right);
        int pivotIndex = partition3(array,left,right);
        quickSortInter(array,left,pivotIndex - 1);
        quickSortInter(array,pivotIndex + 1,right);
    }
    // Hoare法
    private static int partition1(int[] array, int left, int right) {
        int pivot = array[left];
        int i = left;
        int j = right;
        while(i < j){
            while(i < j && array[j] >= pivot){
                j--;
            }
            while(i < j && array[i] <= pivot){
                i++;
            }
            swap(array,i,j);
        }
        swap(array,i,left);
        return i;
    }
    private static void swap(int[] array, int i, int j) {
        int t = array[i];
        array[i] = array[j];
        array[j] = t;
    }

    // 挖坑法
    private static int partition2(int[] array,int left,int right){
        int pivot = array[left];
        int i = left;
        int j = right;
        while(i < j){
            while(i < j && array[j] >= pivot){
                j--;
            }
            array[i] = array[j];
            while(i < j && array[i] <= pivot){
                i++;
            }
            array[j] = array[i];
        }
        array[i] = pivot;
        return i;
    }

    // 前后遍历法
    private static int partition3(int[] array,int left,int right){
        int pivot = array[left];
        int d = left + 1;
        int i = left + 1;
        for(;i <= right;i++){
            if(array[i] < pivot){
                swap(array,i,d++);
            }
        }
        swap(array,d - 1,left);
        return d - 1;
    }

7.归并排序：