初级排序算法

选择排序

定义

一种最简单的排序算法是这样的：假定我们对一个数组进行排序那么，我们可以找到数组中最小的元素，然后与数组的第一个经行交换，如果第一个已经是最小的，那就和自己交换。然后在剩下的元素中找到最小的和第二个进行交换。以此类推，最终得到一个升序的数组。这种方式就叫做选择排序。

代码实现

@Test
    void select() {
        int nums[] = new int[]{9,8,7,6,5,4,3,2,1,0};

        //经行选择排序
        selectSort(nums);
        for (int num : nums) {
            System.out.println(num);
        }
    }

    private void selectSort(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            //这种排序需要一个变量来记录当前最小值的位置
            int min = i;
            for (int j = i+1; j < nums.length; j++) {
                if(nums[j] < nums[min]){
                    //当前元素比这个小，min指向这个小的
                    min = j;
                }
                //把最小的放在剩余元素的最前面
                int tmp = nums[i];
                nums[i] = nums[min];
                nums [min] = tmp;
            }
        }
    }

时间复杂度

这里只考虑最坏的情况。

对于一个长度为N的数组，第一次就需要遍历整个数组，这个时候就是N次，接下来就是N-1，N-2……直到比较完成。所以最多比较次数就是把这些加起来等于N（N-1）/ 2，与就是O（N^2）。

插入排序

定义

斗地主都玩过，摸起来的牌都会一张一张的插入到一个合适的位置，然后正副牌看起来就是井然有序。这种插入的方式就是插入排序。

就比如这个，3比9小，于是插入到9的左边，然后发现，3比7小，又插入到7的左边，直到左边没有比这数小的，总的来说就是一趟过后，左边的都是有序的。

代码实现

@Test
void select() {
    int nums[] = new int[]{9,8,7,6,5,4,3,2,1,0};

    //经行选择排序
    insertSort(nums);
    for (int num : nums) {
        System.out.println(num);
    }
}

private void insertSort(int[] nums){
    //外层循环
    for (int i = 1; i < nums.length; i++) {
        for (int j = i;j > 0;j--) {
            //当前比前面的小，插入
            if (nums[j] < nums[j-1]){
                //交换
                int tmp = nums[j];
                nums[j] = nums[j-1];
                nums [j-1] = tmp;
            } else {
                break;  //没有就后移再次进入循环比较
            }
        }
    }
}

时间复杂度为：N^{2/4，就是O(N}2)，比选择排序好那么一点。

希尔排序

上面的排序每次都是相邻的元素进行比较，导致每次都需要大量的移动，而希尔排序的特点就是，每次使数组变得大致上有序，然后变得有序。每次使一个组有序，总体上就是大致有序，然后缩小这个组直到最后有序。

比如这个，1，7一组，6，5一组，然后这每一个组排个序，整个数组就整体上变得有序很多，然后缩小这个分组，直到最后有序。

代码实现

@Test
void select() {
    int nums[] = new int[]{9,8,7,6,5,4,3,2,1,0};

    //经行选择排序
    insertSort(nums);
    for (int num : nums) {
        System.out.println(num);
    }
}

private void shellSort(int[] nums){
    //选择一个增量
    int n = nums.length/2;
    //增量不等于1排序，数组只能大致有序，所以会逐步缩小到1
    while (n > 0) {
        for (int i = n; i < nums.length; i++) {
            for (int j = i; j >= n; j -= n) {
                //比较这两个大小
                if (nums[j] < nums[j-n]){
                    //交换
                    int tmp = nums[j];
                    nums[j] = nums[j-n];
                    nums [j-n] = tmp;
                }
            }
        }
        //缩小增量
        n = n / 2;
    }
}

对于这种排序，怎么选择增量就是一个最复杂的问题。这就不在本次讨论当中。