Java实现常用排序算法

学习排序算法的常用实现，需要先了解常用算法种类及其实现原理，最好是通过动图的形式。

visualgo.net/zh/

这个很帅的网站做了一个可视化的算法实现网站，最好是先通过动画的方式了解每一种排序的概念，然后再来看代码。

冒泡排序

public void bubbleSort(int[] nums) {
    for (int i = nums.length; i > 0; i--) {
        for (int j = 0; j < i - 1; j++) {
            if (nums[j] > nums[j + 1]) { // swap
                int tmp = nums[j];
                nums[j] = nums[j + 1];
                nums[j + 1] = tmp;
            }
        }
    }
}

选择排序

public void selectSort(int[] nums) {
    for (int i = 0; i < nums.length - 2; i++) {
        int op = i;
        for (int j = i + 1; j < nums.length; j++) {
            if (nums[j] < nums[op]) op = j;
        }
        //swap
        int tmp = nums[i];
        nums[i] = nums[op];
        nums[op] = tmp;
    }
}

插入排序

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

快速排序

public void quickSort(int[] nums, int left, int right) {
    if (left >= right) return ;
    int x = nums[left + right >> 1];

    int i = left - 1;
    int j = right + 1;
    while(i < j){
        do i++; while(nums[i] < x);
        do j--; while(nums[j] > x);
        if ( i < j){
            int tmp = nums[i];
            nums[i] = nums[j];
            nums[j] = tmp;
        }
    }
    quickSort(nums,left,j);
    quickSort(nums,j + 1,right);
}

归并排序

public void mergeSort(int[] nums, int left, int right) {
    //end
    if (left >= right) return;

    //logic
    int mid = left + ((right - left) >> 1);
    mergeSort(nums, left, mid);
    mergeSort(nums, mid + 1, right);

    // 临时数组，用于临时存储[l,r] 区间内排好序的数据
    int[] tmp = new int[right - left + 1];
    int i = left, j = mid + 1, k = 0; // two points
    // merge
    while (i <= mid && j <= right) {
        if (nums[i] <= nums[j])
            tmp[k++] = nums[i++];
        else tmp[k++] = nums[j++];
    }

    while (i <= mid) tmp[k++] = nums[i++];
    while (j <= right) tmp[k++] = nums[j++];

    // return
    for (i = left, j = 0; i <= right; i++, j++)
        nums[i] = tmp[j];
}

各排序算法信息对照表

排序方式	时间复杂度	空间复杂度	稳定性	复杂性
冒泡排序	O(n2)	O(1)	稳定	简单
选择排序	O(n2)	O(1)	不稳定	简单
插入排序	O(n2)	O(1)	稳定	简单
快速排序	O(nlog2n)	O(1)	不稳定	复杂
归并排序	O(nlog2n)	O(n)	稳定	复杂
堆排序	O(nlog2n)	O(1)	不稳定	复杂