常见的排序算法

常见的排序算法可以分为两大类：

   **非线性时间比较类排序**：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此称为非线性时间比较类排序。

线性时间非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此称为线性时间非比较类排序。

算法的复杂度

1 冒泡排序

在无序的区间里通过相邻数的比较，将最大的数的冒泡到无序空间的最后，持续这个过程，让数组整体有序

 /*
    * 冒泡排序
    * 时间复杂度 为 O(n^2) 最坏的时间复杂度也是O（n^2） 最好的时间复杂度为o(n)
    * 稳定排序 空间复杂度为O（1）
    * */
    public void bubbleSort(int[] array) {
        for (int i = 0; i < array.length; i++) {
            boolean isSorted = true;
            for (int j = 0; j <array.length-1-i ; j++) {
                if (array[j] > array[j+1]){
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    isSorted = false;
                }
            }
            if (isSorted){
                break;
            }
        }
    }

2 选择排序

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

* 选择排序
* 时间复杂度为 O（n^2） 空间复杂的 为 O（1） 不稳定
* */
    public void selectSort(int[] array){
        for (int i = 0; i < array.length-1; i++) {
            // 无序区间: [0, array.length - i)
            // 有序区间: [array.length - i, array.length)
            int max = 0;
            for (int j = 1; j < array.length - i; j++) {
                if (array[j] > max){
                    max = j;
                }
            }
            int tmp = array[i];
            array[i] = array[max];
            array[max] = tmp;
        }
    }

3 插入排序整个区间被分为

把区间分为

1. 有序区间
2. 无序区间
   每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入

 /*
    * 插入排序
    *第二位数字开始，每一个数字都试图跟它的前一个比较并交换，并重复；直到前一个数字不存在或者比它小或相等时停下来
    * 最好的时间复杂度为O（n） 平均为O(n^2) 最坏为O(n^2)  稳定
    * 初始数据越接近有序，时间效率越高
    * */
    public void insertSort(int[] array){
        for (int i = 1; i < array.length ; i++) {
            // 有序区间: [0, i)
            // 无序区间: [i, array.length)
            int j = i-1;
            int key = array[i];
            while (j >= 0  && array[j] > key ){
                array[j+1] = array[j];
                j--;
            }
            array[j+1] = key;
        }
    }

4 希尔排序

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

  /*
    * 希尔排序 最好是O（n） 平均是O（n^1.3） 最坏 O(n^2)
    * */
    public static void shellSort(int[] array){
        int gap = array.length;
        while (gap > 1){
            insertSortGap(array,gap);
            gap = (gap/3)+1;
        }
    }

    private static void insertSortGap(int[] array, int gap) {
        for (int i = 1; i < array.length; i++) {
            int v = array[i];
            int j = i - gap;
            for (;  j >= 0 && array[j] > v; j--) {
                array[j+gap] = array[j];
            }
            array[j+gap] = v;
        }
    }

5 归并排序

  /*
    * 归并排序
    * 归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and
Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使
子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
    * */
    public void mergeSort(int[] array){
        mergeSortInternal(array,0,array.length);
    }

    private void mergeSortInternal(int[] array, int low, int height) {
        if (low >= height -1){
            return;
        }
        int mid = (low + height) / 2;
        mergeSortInternal(array,low,mid);
        mergeSortInternal(array,mid,height);

        merge(array,low,mid,height);
    }

    private void merge(int[] array, int low, int mid, int height) {
        int i = low;
        int j = mid;
        int length = height - low;
        int[] extra = new int[length];
        int k = 0;

        while (i < mid && j <height) {
            if (array[i] <= array[j]){
                extra[k++] = array[i++];
            } else {
                extra[k++] = array[j++];
            }
        }
        
        while (i < mid){
            extra[k++] = array[i++];
        }
        while (j < height){
            extra[k++] = array[j++];
        }
        for (int l = 0; l < length ; l++) {
            array[low + l] = extra[l]; 
        }
    }

海量数据的排序问题

外部排序：排序过程需要在磁盘等外部存储进行的排序
前提：内存只有 1G，需要排序的数据有 100G
因为内存中因为无法把所有数据全部放下，所以需要外部排序，而归并排序是最常用的外部排序

1. 先把文件切分成 200 份，每个 512 M
2. 分别对 512 M 排序，因为内存已经可以放的下，所以任意排序方式都可以
3. 进行 200 路归并，同时对 200 份有序文件做归并过程，最终结果就有序

6 堆排序

public static void heapSort(int[] array) {
createHeap(array);
for (int i = 0; i < array.length - 1; i++) {
// 交换前
// 无序区间: [0, array.length - i)
// 有序区间: [array.length - i, array.length)
swap(array, 0, array.length - 1);
// 交换后
// 无序区间: [0, array.length - i - 1)
// 有序区间: [array.length - i - 1, array.length)
// 无序区间长度: array.length - i - 1
shiftDown(array, array.length - i - 1, 0);
}
}
private void swap(int[] array, int i, int j) {
int t = array[i];
array[i] = array[j];
array[j] = t;
} p
rivate void createHeap(int[] array) {
for (int i = (array.length - 1) / 2; i >= 0; i--) {
shiftDown(array, array.length, i);
}
} p
ublic static void shiftDown(int[] array, int size, int index) {
int left = 2 * index + 1;
while (left < size) {
int max = left;
int right = 2 * index + 2;
if (right < size) {
if (array[right] > array[left]) {
max = right;
}
} i
f (array[index] >= array[max]) {
break;
} i
nt t = array[index];
array[index] = array[max];
array[max] = t;
index = max;
left = 2 * index + 1;
}
}

7 快速排序

  public static void main(String[] args) {
        Random rd = new Random();
        int[] num = new int[10];
        for (int i = 0; i < num.length; i++) {
            num[i] = rd.nextInt(100)+1;
        }
        System.out.println(Arrays.toString(num));
        quickSort(num,0,num.length-1);
        System.out.println(Arrays.toString(num));
    }
    /**
     * 实现快速排序
     * @param num
     * @param i
     * @param j
     */
    public static void quickSort(int[] num,int i,int j){
        if(i >= j){//只剩一个元素不用处理直接结束。
            return;
        }
        //选取基准数
        int val =num[i];
        int l = i;
        int r = j;
        while(l < r){//当l == r时，就是调整完成时
            //从后往前找第一个小于val的数字
            while (l < r && num[r] > val){
                r --;
            }
            if(l < r){//找到了数字
                num[l++] = num[r];
            }
            //从前往后找第一个大于val的数字
            while (l < r && num[l] < val){
                l ++;
            }
            if(l < r){//找到了数字
                num[r--] = num[l];
            }
        }
        //l==r,基准数放进去
        num[l] = val;
        quickSort(num,i,l-1);
        quickSort(num,l+1,j);
    }