常用几种排序算法

常用的几种排序算法
选择排序方法时，除了基本实现的要求外，还应当注重所选择算法的时间、空间复杂度既执行效率，另外在实际工作中往往还要注意算法的稳定性（排序后相同元素的相对位置是否发生改变）等。
一、冒泡、插入、选择
二、快排、归并
1、冒泡排序
冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求，如果不满足则两者互换。

public static void bubbleSort(int[] nums) {
        if (nums.length <= 1) return;
        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;
                }
            }
            System.out.println(i + 1 + "次 冒泡:" + Arrays.toString(nums));
        }
    }
输出：
1次冒泡:[4, 5, 1, 3, 2, 6]
2次冒泡:[4, 1, 3, 2, 5, 6]
3次冒泡:[1, 3, 2, 4, 5, 6]
4次冒泡:[1, 2, 3, 4, 5, 6]
5次冒泡:[1, 2, 3, 4, 5, 6]
6次冒泡:[1, 2, 3, 4, 5, 6]

冒泡排序只涉及相邻元素的对比交换，空间复杂度O(1)，时间复杂度最好情况O(n)，最坏情况O(n2)，相邻元素相等不作交换则为稳定排序。

2、插入排序
将数组分为两个区间、已排区间和未排区间。初始已拍区间只有数组的第一个元素，之后每次取未排区间元素插入到已排区间中合适的位置。

public static void insertionSort(int[] nums) {
        if (nums.length <= 1) return;
        for(int i = 1; i < nums.length; i ++){
            int value= nums[i];
            int j = i - 1;
            //查找插入位置
            for(;j >= 0;j --){
                if(nums[j] > value){
                    nums[j + 1] = nums[j]; //数据移动
                }else{
                    break;
                }
            }
            nums[j + 1] = value; //插入数据
            System.out.println(i + "次插入：" + Arrays.toString(nums));
        }
    }
    输出：
    1次插入：[4, 5, 6, 1, 3, 2]
	2次插入：[4, 5, 6, 1, 3, 2]
	3次插入：[1, 4, 5, 6, 3, 2]
	4次插入：[1, 3, 4, 5, 6, 2]
	5次插入：[1, 2, 3, 4, 5, 6]

插入排空间复杂度O(1)，时间复杂度最好情况O(n)，最坏情况O(n2)，元素相等不作交换则为稳定排序。

3、选择排序
有点类似插入排序，选择排序也分为已排和未排两个区间，区别于插入排序的是，每次从未排区间中取最小数插入到已排区间的末尾。

public static void selectionSort(int[] nums) {
        if (nums.length <= 1) return;
        for(int i = 0; i < nums.length; i ++){
            int k  = i;
            //查找最小元素下表
            for(int j = i; j < nums.length; j ++){
                if(nums[j] < nums[k]){
                    k = j;
                }
            }
            if(i != k) {
                int temp = nums[k];
                nums[k] = nums[i];
                nums[i] = temp;
            }
            System.out.println(i + 1 + "次选择排序：" + Arrays.toString(nums));
        }
    }
    输出：
    1次选择排序：[1, 5, 6, 4, 3, 2]
	2次选择排序：[1, 2, 6, 4, 3, 5]
	3次选择排序：[1, 2, 3, 4, 6, 5]
	4次选择排序：[1, 2, 3, 4, 6, 5]
	5次选择排序：[1, 2, 3, 4, 5, 6]
	6次选择排序：[1, 2, 3, 4, 5, 6]

选择排空间复杂度O(1)，时间复杂度最好情况O(n2)，最坏情况O(n2)，每次选最小值维持不了原有位置所以为不稳定排序。