【算法】基础算法——排序（基础篇）

1、冒泡排序

• 复杂度O(n^2)
• 稳定，因为当相邻两个数字相同的时候，不会交换它们
• 思路就是每次将无序部分的最大的数沉到最后面

public void bubble(int[] nums){
        for (int i = 0;i < nums.length;i++){    //一共要沉多少次
            for (int j = 0;j < nums.length-i-1;j++){        //每次沉的时候，后面的值已经排好了不需要再比
                if (nums[j] > nums[j+1]){
                    int temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                }
            }
            
        }
    }

2、选择排序

• 复杂度O(n^2)
• 不稳定：如8，8，2 排序后变为2，8，8，同样的8顺序反过来了
• 思路：从头到尾，每个位置i，把第i小的数直接换到对应的位置来

    public void select(int[] nums){
        for (int i = 0;i < nums.length-1;i++){    //对于每一个要确定的位置
            int minIndex = i;                       //从这个位置开始的所有数中选择最小的一个
            for (int j = i+1;j < nums.length;j++){
                if (nums[j] < nums[minIndex]){
                    minIndex = j;
                }
            }           
            int tmp = nums[minIndex];
            nums[minIndex] = nums[i];
            nums[i] = tmp;
        }
    }

3、插入排序

• 复杂度O(n^2)
• 稳定
• 思路：像玩扑克牌一样，分为前段有序部分和后段无序部分，每次把无序部分的第一个数插到前段对应的位置上

    public void insert(int[] nums){
        for (int i = 1;i < nums.length;i++){    //对于每一个要插入的数来说
            int val = nums[i];        //记录一下这个数,将要往后挪覆盖他
            int j = i;                //被覆盖的下标
            while (j > 0 && nums[j-1] > val){    //开始往后挪让位置
                nums[j] = nums[j-1];
                j--;
            }
            nums[j] = val;            //出来的时候，nums[j-1] < val,所以要给j    
        }
    }