手撕排序JAVA（经验贴）

以力扣题912为例，介绍冒泡排序，选择排序，插入排序和归并排序。

冒泡排序：

//冒泡排序
class Solution {
    public int[] sortArray(int[] nums) {
        //通过swap方法将最小的数选出来放在最前，然后选第二小的，以此类推；
        int len=nums.length;
        for(int index=0;index<len-1;index++){
            for(int i=len-2;i>=index;i--){
                if(nums[i]>nums[i+1]){
                    swap(nums,i,i+1);//如果排序在前的数比后面的数大，交换两者使小数在前，一个一个比较
                }
            }
        }
        return nums;
    }
    public  void swap(int[] nums,int i1,int i2){
        int temp=nums[i1];
        nums[i1]=nums[i2];
        nums[i2]=temp;
    }
}

选择排序：

    //选择排序
    public int[] sortArray(int[] nums) {
        int len= nums.length;
        for (int i=0;i<len-1;i++){
            int minIndex=i;//目前寻找的最小值索引，即第多少个最小数；
            for (int j=i+1;j<len;j++){
                if(nums[j]<nums[minIndex]){
                    minIndex=j;//找到未排序部分最小值的索引
                }
                swap(nums,j,minIndex);
            }
        }
        return nums;
    }
    public void swap(int[] nums,int i,int j){
        int temp=nums[i];
        nums[i]=nums[j];
        nums[j]=temp;
    }

选择排序最令人诟病的就是时间复杂度，但是从另一个角度来说，选择排序需要进行的swap（）次数是最少的（n次），对于每次交换成本高的情况下，可以考虑选择排序，时间复杂度无论数组是什么样的都是O（N²）

插入排序：

插入排序可以理解为从第二个元素开始，拿出每一个元素然后插入到它应该去的位置，比如进行到第n个元素时，它的前面的所有元素都是已排序好了的，将它拿出来，与前面的已排序数相比较，比它大的往后移一位，然后到达不小于它的数的位置时，就是它此时应该放的位置，替换即可；

//插入排序
class Solution {
    public int[] sortArray(int[] nums) {
        int len=nums.length;
        for(int index=1;index<len;index++){
            int temp=nums[index];
            int j=index;//不能改变index的值，所以要新定义一个遍历索引
            while (j>0&&nums[j-1]>temp){//这两个限制条件大大减少了时间复杂度，对于基本有序数组来说时间复杂度近乎为o（N）
                nums[j]=nums[j-1];
                j--;
            }
            nums[j]=temp;//将拿出来的数插入进去
        }
        return nums;
    }
}

插入排序相对于选择排序来说新增了限定条件从而减少了运行处理量，时间复杂度O（N²），最佳情况下为O（N）

归并排序：

归并排序可以理解为升级版的插入排序，对于大体量的数据来说，每次插入数值需要进行的比较次数较大，因此归并排序将大体量的数据等分再等分至多个小体量的数据（比如size为7及7以下），这时再分别使用插入排序，最后再将多个已排序的有序数组整合成大数组即可；

//归并排序
public class Solution {
    public int[] sortArray(int[] nums) {
        int len = nums.length;
        int[] temp = new int[len];
        mergesort(nums, 0, len - 1, temp);
        return nums;
    }

    public void mergesort(int[] nums, int left, int right, int[] temp) {
        if (right - left <= 7) {
            insertsort(nums, left, right);
            return;
        }//递归的终点：n次等分后，需要排序的数组size较小了，就可以直接用插排来排序
        int mid = (right - left) / 2 + left;
        //对于大整数，先计算right-left得到差值会避免整数溢出
        mergesort(nums, left, mid, temp);
        mergesort(nums, mid + 1, right, temp);
        if (nums[mid] <= nums[mid + 1]) {
            return;
        }//如果两个子数组满足前一个的最大值小于后一个的最小值，就可以不用再重新组合
        mergesortedcombine(nums, left, right, mid, temp);
    }

    public void insertsort(int[] nums, int left, int right) {//插入排序
        for (int i = left + 1; i < right + 1; i++) {
            int temp = nums[i];
            int j = i;
            while (j > left && nums[j - 1] > temp) {//此处插排要注意左右边界不再是0和len-1；
                nums[j] = nums[j - 1];
                j--;
            }
            nums[j] = temp;
        }
    }

    public void mergesortedcombine(int[] nums, int left, int right, int mid, int[] temp) {
        System.arraycopy(nums, left, temp, left, right);//复制选中的数组段，然后用复制的填入nums；
        int i = left;
        int j = mid + 1;
        for (int k = left; k <= right; k++) {
            if (i == mid + 1) {
                nums[k] = temp[j];//如果i到达了mid+1的位置意味着中点前的所有数已经全部排序进了temp，所以只用依次添加中点后剩余的数即可
                j++;
            } else if (j == right + 1) {
                nums[k] = temp[i];//同上，即中点后的全部排序了，依次加入中点前剩余的数
                i++;
            } else if (temp[i] >= temp[j]) {//这里加上等于号可以提高稳定性，即当两数相等时，还能保证原来在前的数还在前
                nums[k] = temp[j];
                j++;
            } else {
                nums[k] = temp[i];
                i++;
            }
        }
    }
}

对于大体量数据的运算，归并是能有效降低时间复杂度的方法，本方法时间复杂度为O（LogN）；