十大排序算法

 

十大经典排序算法：
# 分为两类：
非线性时间比较类排序：通过比较决定元素间的相对次序，由于时间复杂度不能突破O(nlogn)，称之为非线性时间比较类排序。
线性时间非比较类排序：不通过比较决定元素间的相对顺序，突破基于比较排序的时间下界，以线性时间运行，称之为线性时间非比较类排序。
# 排序算法：
非线性时间比较类排序：
1）交换排序：冒泡排序，快速排序
2）插入排序：简单插入排序，希尔排序
3）选择排序：简单选择排序，堆排序
4）归并排序：二路归并排序，多路归并排序
线性时间非比较类排序：
1）计数排序
2）桶排序
3）基数排序

1. 冒泡排序(Bubble Sort):比较两个元素，如果前一个大于后一个，交换

public static int[] bubbleSort(int[] arr){
    int arrLen = arr.length;
    for (int i = arrLen - 1; i >= 1; i--) {
        for (int j = 0; j < i; j++) {
            if (arr[j] > arr[j+1]) {
                swap(arr, j, j+1);
            }
        }
    }
    return arr;
}
public static void swap(int[] arr, int i, int j) {
    int tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
}

2. 快速排序(Quick Sort):通过一趟排序，将记录分为两个独立的部分，其中一部分的关键字比另一部分小，可以分别
对于这两个部分进行排序，达到有序的效果。
从数列中选出一个元素，称为“基准”(pivot)
重新排序数列，所有比基准值小的元素放在基准值的前面，比基准值大的元素放在基准值的后面，分区结束后，基准
值处于数列的中间，称之为分区(partition)操作
递归地处理子数列

public static void QuickSort(int[] arr, int start, int end) {
    if (start < end) {
        int index = partition(arr, start, end);
        QuickSort(arr, start, index - 1);
        QuickSort(arr, index + 1, end);
    }
}
public static int partition(int[] arr, int start, int end) {
    int pivot = arr[start];
    while (start < end) {
        while (start < end && arr[end] >= pivot){
            end--;
        }
        arr[start] = arr[end];
        while (start < end && arr[start] < arr[pivot]) {
            start++;
        }
        arr[end] = arr[start];
    }
    arr[start] = pivot;
    return start;
}

3. 简单插入排序(Insertion Sort):从第一个元素开始，该元素表示为有序，取出下一个元素，在已经排序的元素序列中
从后向前扫描，如果以及排序好的元素大于新的元素，该元素后移，直到找到其位置。

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

4.希尔排序(Shell sort):简单插入排序的改进版本，与插入排序不同之处在于，优先比较距离比较元的元素，缩小增量排序
将整个待排序的记录序列分割称为若干个子序列分别进行插入排序，具体算法：
选择一个增量序列t1,t2,...,tk,其中ti>tj,tk = 1
按照增量序列的个数K，对于序列进行k趟排序；
每趟排序，根据对应的增量ti，将待排序列分割为长度为m的子序列，分别对各个子表进行直接插入排序，仅增量因子为1
时候，整个序列作为一个表处理，表长度为整个序列的长度。

public static void shellSort(int[] arr){
    int gap = 1;
    while (gap < arr.length / 3) {
        gap = gap*3+1;
    }
    while (gap >= 1) {
        for (int i = gap; i < arr.length; i++) {
            for (int j = i; j >= gap && arr[j] < arr[j-gap]; j-= gap) {
                swap(arr, j, j-gap);
            }
        }
        gap /= 3;
    }
}

5. 简单选择排序(Selection Sort):在未排序的序列中找到最小(最大)元素，存放到排序序列的起始位置，从
剩余的未排序的元素中找到最小(最大)元素，放到已经排序的末尾，直到所有元素排序完成。

public static void selectionSort(int[] arr){
    for (int i = 0; i < arr.length - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        int tmp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = tmp;
    }
}

6.堆排序(heap Sort):利用堆的数据结构设计的一种排序算法，堆是一个近似完全二叉树的结构，同时满足堆的性质：
子节点的键值总是小于或者大于其父节点。
算法描述：
将初始待排序的关键字序列(R1,R2,...,Rn)构建成为大顶堆
将堆顶的元素R[1]与最后一个元素R[n]交换，对于(R1, R2,...,Rn-1)调整为新的堆，再次将R[1]与最后一个元素
交换得到新的无序区，不断重复直到有序区的元素为n-1个，整个排序过程完成。

public static void heapSort(int[] arr) { //整体程序
    maxHeap(arr);//得到大顶堆
    int len = arr.length;
    while(len > 1) {
        exchange(arr, 0, len - 1); //交换
        len--; //长度减一
        heapify(arr, 0, len); //调整堆
    }
}
public static void exchange(int[] arr, int i, int j) {
    int tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
}
public static void heapify(int[] arr, int i, int len) {
    int tmp = arr[i];
    for (int k = 2*i+1; k < len; k = 2*k+1) {
        if (k+1 < len && arr[k] < arr[k+1]) {
            k++;
        }
        if (tmp < arr[k]) {//tmp和arr[k]进行比较
            arr[i] = arr[k];
            i = k;
        }
        else{
            break;
        }
    }
    arr[i] = tmp;
}
public static void maxHeap(int[] arr) {
    int len = arr.length;
    for (int i = len/2 - 1; i >= 0; i--) {
        heapify(arr, i, len);
    }
}

7.二路归并排序(Merge Sort):归并排序是建立在归并操作上的一种有效的排序算法，采用分治法的一个典型应用，
将已经有序的子序列合并，得到完全有序的序列，使得每个子序列有序，再使得子序列段间有序。
算法描述：
将长度为n的输入序列分为两个长度为n/2的子序列
对于两个子序列分别使用归并排序
将两个排序好的序列合并为最终的一个排序序列

public static void mergeSort(int[] arr, int low, int high) {
    if (arr.length == 1)
        return;
    if (low < high) {
        int middle = (low + high) / 2;
        mergeSort(arr, low, middle);
        mergeSort(arr, middle+1, high);
        merge(arr, low, middle, high);
    }
}
public static void merge(int[] arr, int low, int middle, int high){
    int[] result = new int[high - low + 1];
    int k =0;
    int i = low;
    int j = middle + 1;
    while(i <= middle && j <= high) {
        if (arr[i] < arr[j]) {
            result[k++] = arr[i++];
        }
        else{
            result[k++] = arr[j++];
        }
    }
    while (i <= middle) {
        result[k++] = arr[i++];
    }
    while (j <= high) {
        result[k++] = arr[j++];
    }
    System.arraycopy(result,0,arr,low,result.length);
}

基数排序，计数排序，桶排序都使用了桶的概念，但是对于桶的使用方法有明显的差异：
基数排序：根据键值的每位数字来分配桶
计数排序：每个桶只存储单一键值
桶排序：每个桶存储一定范围的数值
8.计数排序(Count Sort):计数排序不是基于比较的排序算法，核心在于将数据值转化为键存储再额外开辟的数组
空间中，作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是具有确定的范围的整数。
算法描述：
找出待排序的数组的最大和最小的元素
统计数组中每个值为i的元素出现的次数，存入数组C的第i项

public static void countSort(int[] arr, int maxValue) {
    int[] bucket = new int[maxValue + 1];
    for (int i = 0; i < arr.length; i++) {
        bucket[arr[i]]++;
    }
    int k = 0; //arr的索引
    for (int i = 0; i <= maxValue;) {
        while (bucket[i] != 0) {
            arr[k++] = i;
            bucket[i]--;
        }
        i++;
    }
}

9.桶排序
桶排序是计数排序的升级版本，利用函数的映射关系，高效与否在于这个映射函数的确定，为了使得桶排序更加
高效，需要：
在额外空间充足的情况下，尽量增大桶的数量
使用映射函数能够将输入的N个数据均匀的分配到K个桶中，对于桶中的元素，使用何种排序算法对于性能的影响
至关重要。
10.基数排序(Radix Sort):按照低位先排序，然后收集，再按照高位排序，然后再收集，以此类推，直到最高位，
有时候，有些属性是有优先级的，先按照低优先级排序，再按照高优先级排序，最后的次序就是高优先级高的在前，
高优先级相同的低优先级高的在前。
算法描述：
取得数组中的最大数，取得位数
arr为原始的数组，从最低位置开始取每个位组成radix数组
对于radix进行计数排序(利用计数排序适用于小范围数的特点)

public static void radixSort(int[]arr){
    //最大值
    int maxNum = arr[0];
    for(int i = 1; i < arr.length; i++){
        if(maxNum < arr[i]){
            maxNum = arr[i];
        }
    }
    //位数
    int level = 0;
    while (maxNum > 0) {
        maxNum /= 10;
        level++;
    }
    //排序
    int[][] bucket = new int[10][arr.length];
    int[] bCount = new int[10];
    int index = 0;//索引当前到了第几位
    int radix = 1;
    while(index < level) {
        //按照某位输入数组中
        for (int i = 0; i < arr.length; i++){
            int k = (arr[i]/radix)%10;
            bucket[k][bCount[k]++] = arr[i];
        }
        //从数组中输出
        int k = 0;
        for(int i = 0; i < arr.length;){
            int cur = 0;
            while(cur < bCount[k]){
                arr[i++] = bucket[k][cur++];//不能使用--bCount[k]，应该首先取底下
            }
            k++;
        }
        //bCount置0
        Arrays.fill(bCount, 0);
        //自增
        index++;
        radix *= 10;
    }
}