Java 几种常见的排序算法（Java实现+算法思想）

这篇博客中 默认升序

一、插入排序

算法思想：

1. 默认第一个元素是有序的
2. 取出第二个元素 i，从后往前进行比较：
   若出现大于 i 的元素，则把该元素后移，然后插入 i；
   若出现小于 i 的元素，则位置不变
   此时 i 位置之前的元素是有序的
3. 取出下一个元素，重复步骤2，直至找到已排序的元素中小于或等于 i 元素的位置，插入 i
4. 重复上述步骤，直到所有元素都有序

代码：

public static void insertSort(int[] array){
        for (int i = 1; i < array.length; i++) {
            int tmp = array[i];
            int j = i-1;
            for (; j >= 0; j--) {
                if(array[j] > tmp){
                    array[j+1] = array[j];
                }else{
                    break;
                }
            }
            array[j+1] = tmp;
        }
    }

二、希尔排序

希尔排序法又称缩小增量法，是插入排序的优化。

算法思想：

1. 选择一个增量序列
2. 按增量序列x，对序列进行 x 次排序
3. 根据增量序列，把所有元素进行分组
4. 组内进行插入排序

注意：增量序列的值为素数，且最后一个增量必须为1。

代码：

public static void shellSort(int[] array) {
        int[] drr = {5,3,1};//增量序列
        for (int i = 0; i < drr.length; i++) {
            shell(array,drr[i]);
        }
}
public static void shell(int[] array,int gap) {
        for (int i = gap; i < array.length; i++) {
            int tmp = array[i];
            int j = i-gap;
            for (; j >= 0; j = j-gap) {
                if(array[j] > tmp) {
                    array[j+gap] = array[j];
                }else {
                    break;
                }
            }
            array[j+gap] = tmp;
        }
}

三、堆排序

算法思想：通过堆来选择无序区间的最大的数

注意： 排升序要建大堆；排降序要建小堆

1. 将初始序列建成大堆
2. 将堆顶元素与最后一个元素进行交换，然后对当前堆进行调整；然后再次将堆顶元素与倒数第二个元素进行交换，得到新堆
3. 不断重复上述步骤，直至全部有序

代码

public static void heapSort(int[] array) {
    //1.大堆  -> 时间复杂度O(n)
    createHeap(array);
    //2、排序 -> 时间复杂度n*logn
    int end = array.length-1;
    while (end > 0) {//最大的和end换
        int tmp = array[0];
        array[0] = array[end];
        array[end] = tmp;
        adjust(array,0,end);
        end--;
    }
}

public static void createHeap(int[] array) {//建堆
    for (int p = (array.length-1-1)/2; p >= 0; p--) {
        adjust(array,p,array.length);
    }
}

public static void adjust(int[] array,int parent,int len) {
    int child = 2*parent+1;
    while (child < len) {
        if(child+1 < len && array[child] < array[child+1]) {
            child++;
        }//此时child是左右孩子中最大的
        if(array[child] > array[parent]) {
            int tmp = array[child];
            array[child] = array[parent];
            array[parent] = tmp;
            parent = child;
            child = 2*parent+1;
        }else {
            break;
        }
    }
}

四、选择排序

算法思想：

1. 在未排序序列中找到最小的元素，放到排序序列的起始位置
2. 从剩余元素中继续寻找最小的元素，放到已排序序列的后面
3. 重复步骤2，直到所有元素都有序

代码：

public static 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] > array[max]) {
                max = j;
           }
        }
        int t = array[max];
        array[max] = array[array.length - i - 1];
        array[array.length - i - 1] = t;
   }
}

五、冒泡排序

算法思想：

1. 比较相邻的元素，若第一个比第二个大，则交换
2. 对每一对相邻元素重复步骤1，此时最大的元素在最后一个
3. 针对所有元素重复以上的步骤，除了最后一个元素
4. 直至所有元素有序

代码：

public static void bubbleSort(int[] array) {
        for (int i = 0; i < array.length-1; i++) {
            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;
                }
            }
        }
    }

六、快速排序

算法思想：

1. 先从数列中取出一个数作为基准
2. 遍历整个待排序区间，将比基准值小的数放到基准值的左边，将比基准值大的或等于基准值的数，放到基准值的右边
3. 对基准左右两边重复步骤2，直至两个区间都只有1个数或者没有数，此时序列有序

代码：

public static void quickSort(int[] array) {
    quick(array,0,array.length-1);
}

public static void quick(int[] array,int low,int high) {
    if(low >= high) {
        return;
    }
    int par = partion(array,low,high);
    quick(array,low,par-1);//第一个基准的左边
    quick(array,par+1,high);//第一个基准的右边
}

public static int partion(int[] array,int start,int end) {
    int tmp = array[start];
    while (start < end) {
        while (start < end && array[end] >= tmp) {//在后面找一个比基准小的
             end--;
        }
        if(start >= end) {//后面的都比基准大或等
             array[start] = tmp;
             break;
        }else {
             array[start] = array[end];
        }
        while (start < end && array[start] <= tmp) {//在前面找一个比基准大的
            start++;
        }
        if(start >= end) {//相遇
            array[start] = tmp;
            break;
        }else {
            array[end] = array[start];
        }
    }
    return start;
}

优化： 选择基准值很重要，通常使用几数取中法

七、归并排序

算法思想：采用分治法

1. 把序列尽可能地分成两个长度相等的子序列
2. 对这两个子序列分别采用归并排序
3. 重复上述步骤 -->归
4. 使每两个子序列段间有序
5. 直至整个序列有序 -->并
   

代码：

public static void mergeSort(int[] array) {
    mergeSortRec(array,0,array.length-1);
}

public static void mergeSortRec(int[] array,int low,int high) {
    if(low >= high) {
        return;
    }
    int mid = (high+low) / 2;
    mergeSortRec(array,low,mid);
    mergeSortRec(array,mid+1,high);
    merge(array,low,mid,high);
}

public static void merge(int[] array,int low,int mid,int high) {
    int[] tmpArr = new int[high-low+1];
    int k = 0;// 数组下标
    int s1 = low;
    int e1 = mid;
    int s2 = mid+1;
    int e2 = high;
    while (s1 <= e1 && s2 <= e2) {
        if(array[s1] <= array[s2]) {
            tmpArr[k++] = array[s1++];
        }else {
            tmpArr[k++] = array[s2++];
        }
    }
    while (s1 <= e1) {
        tmpArr[k++] = array[s1++];
    }
    while (s2 <= e2) {
        tmpArr[k++] = array[s2++];
    }
    for (int i = 0; i < tmpArr.length; i++) {
        array[i+low] = tmpArr[i];
    }
}

八、总结

	时间复杂度（最好）	时间复杂度（最坏）	平均时间复杂度	空间复杂度	稳定性
插入排序	O(n)	O(n^2)	O(n^2)	O(1)	稳定
希尔排序	O(n)	O(n^2)	O(n^1.3) ~O(n^1.5) O(n^2)	O(1)	不稳定
选择排序	O(n^2)	O(n^2)	O(n^2)	O(1)	不稳定
堆排序	O(n*logn)	O(n*logn)	O(n*logn)	O(1)	不稳定
冒泡排序	O(n)	O(n^2)	O(n^2)	O(1)	稳定
快速排序	O(n * log(n))	O(n^2)	O(n * log(n))	O(log(n))	不稳定
归并排序	O(n * log(n))	O(n * log(n))	O(n * log(n))	O(n)	稳定

另外，基数排序、计数排序以及桶排序是不同于上述排序方法的，这三种排序是不需要通过比较的排序方法。