【LeetCode】912-排序数组

排序数组

题目

给你一个整数数组 nums，请你将该数组升序排列。

示例 1：
输入：nums = [5,2,3,1]
输出：[1,2,3,5]
示例 2
输入：nums = [5,1,1,2,0,0]
输出：[0,0,1,1,2,5]
提示：
1 <= nums.length <= 50000
-50000 <= nums[i] <= 50000

基本概念

• 稳定性
  如果待排序数组中两个相等的值，在排序后相对位置不对，我们就说这种排序算法是稳定的排序算法。反之，则不是一种稳定的排序算法。比如数组 [2(a), 2(b), 1]（为了方便解释，我给两个 2 加上标志，以便区分），在排序后，两个 2 的相对位置是否改变，即排序后的数组是 [1, 2(a), 2(b)]，还是 [1, 2(b), 2(a)]。
  如果是稳定的排序算法，排序后得到的应是 [1, 2(a), 2(b)]。

• 原地排序
  原地排序算法，即空间复杂度为 O(1) 的算法。

解法 1：冒泡排序

• 解题思路
  冒泡排序是一种稳定的、原地排序算法，时间复杂度为 O(n^2)。它每次对相邻的两个数进行比较，如果不是有序的，则交换位置。如果一次 for 循环后，没有发生数据交换，则说明数组已经完全有序，可以提前退出 for 循环。

代码

class Solution {
     public int[] sortArray(int[] nums) {
          if (nums == null || nums.length == 0 || nums.length == 1) {
                 return nums;
             }
     
             for (int i = 0; i < nums.length; i++) {
                 // 提前退出循环标志位
                 boolean flag = false;
                 // 这里多一个-1是因为冒泡排序每次都是比较相邻的两个数，比如3个数实际只需要两次比较，因此-1
                 // 也可以简单理解为，比较的时候是nums[j]和nums[j+1]比较，如果不-1的话，会数组越界
                 for (int j = 0; j < nums.length - i - 1; j++) {
                     if (nums[j] > nums[j + 1]) {
                         // 交换位置
                         int tmp = nums[j];
                         nums[j] = nums[j + 1];
                         nums[j + 1] = tmp;
                         flag = true;
                     }
                 }
                 // 如果没有数据交换，说明已经完全有序，提前退出循环
                 if (!flag) {
                     break;
                 }
             }
             return nums;
     }
}

解法 2：选择排序

• 解题思路
  选择排序是一种不稳定的、原地排序算法（比如数组 [2, 2, 1] 排序后，两个 2 的顺序发生改变），时间复杂度为 O(n^2)。它将数组中的数据分为已排序区间和未排序区间，每次都在未排序区间中选择一个最小值，放到已排序区间的后面（通过交换位置实现）。

代码

class Solution {
     public int[] sortArray(int[] nums) {
         if (nums == null || nums.length == 0 || nums.length == 1) {
             return nums;
         }
 
         //记录最小值的索引
         int min = 0;
         //遍历 n-1 轮，最后一个数不用遍历比较
         for (int i = 0; i < nums.length - 1; i++) {
             min = i;
             // 左边是排好序，只需要遍历初始最小值后的所有数
             for (int j = i + 1; j < nums.length; j++) {
                 if (nums[min] > nums[j]) {
                     min = j;
                 }
             }
             if (min != i) {
                 int tmp = nums[min];
                 nums[min] = nums[i];
                 nums[i] = tmp;
             }
         }
         return nums;
     }
}

解法 3：插入排序

• 解题思路
  插入排序是一种稳定的原地排序算法，时间复杂度为 O(n^2)。它将数组中的数据分为已排序区间和未排序区间，默认数组中的第一个数为已排序区间。每次从未排序区间中取数，在已排序区间中找到合适的位置插入，直到未排序区间为空。因为数组实现插入的代价较高，在具体实现中，用数据移动的方式实现插入。

代码

class Solution {
     public int[] sortArray(int[] nums) {
         if (nums == null || nums.length == 0 || nums.length == 1) {
                 return nums;
             }
     
             for (int i = 1; i < nums.length; i++) {
                 int tmp = nums[i];
                 int j = i - 1;
                 for (; j >= 0; j--) {
                     if (nums[j] > tmp) {
                         // 数据移动
                         nums[j + 1] = nums[j];
                     } else {
                         // 因为左边是已排序区间，因此如果nums[j]<=tmp，没必要继续比较，提前退出
                         break;
                     }
                 }
                 // 插入值
                 // for循环时，j多经历了一次j--，所以要+1
                 // 比如第一次循环时，j到这里，值为-1
                 nums[j + 1] = tmp;
             }
             return nums;
     }
}

解法 4：归并排序

• 解题思路
  归并排序是不是一种稳定的排序算法，具体要看 merge() 函数的实现，示例代码中的归并排序是一种稳定的、非原地排序算法，时间复杂度为 O(nlogn)。
  归并排序利用的是分治思想，将一个大数组分成 2 个小数组，小数组排好序后再合并成一个大数组，以此递归，直至数组不能再划分成小数组。

代码

class Solution {
     public int[] sortArray(int[] nums) {
          if (nums == null || nums.length == 0 || nums.length == 1) {
                 return nums;
             }
     
             mergerSort(nums, 0, nums.length - 1);
     
             return nums;
     }
     
     private void mergerSort(int[] nums, int start, int end) {
          if (start >= end) {
              return;
          }
          // 利用分治思想，将要排序的数组分解成两个小数组，分别排序
          int mid = (start + end) / 2;
          mergerSort(nums, start, mid);
          mergerSort(nums, mid + 1, end);
          // 合并排好序的小数组
          merger(nums, start, end);
     }
 
     private void merger(int[] nums, int start, int end) {
          int[] tmp = new int[end - start + 1];
          int mid = (start + end) / 2;
          int i = start;
          int j = mid + 1;
          int index = 0;
          while (i <= mid && j <= end) {
              if (nums[i] < nums[j]) {
                  tmp[index++] = nums[i++];
              } else {
                  tmp[index++] = nums[j++];
              }
          }
 
          // 判断哪个数组还有剩余数据，将之放到临时数组中
          int tmpStart = i;
          int tmpEnd = mid;
          if (j <= end) {
              tmpStart = j;
              tmpEnd = end;
          }
          while (tmpStart <= tmpEnd) {
              tmp[index++] = nums[tmpStart++];
          }
 
          // 将临时数组中的内容放回nums数组中
          if (end - start + 1 >= 0) {
              System.arraycopy(tmp, 0, nums, start, end - start + 1);
          }
     }
}

解法 5：快速排序

• 解题思路
  快速排序是一种不稳定的、原地排序算法，时间复杂度为 O(nlogn)。它与归并排序都是利用分治思想进行排序，但快速排序的实现思路和归并排序完全不同。
  快速排序是在待排序数组中任意选择一个分区点（一般选择数组的第一个元素或最后一个元素），小于分区点的元素放到分区点左边，大于分区点的放到分区点右边，以此递归待排序数组不能再细分（start>=end）。

代码

class Solution {
     public int[] sortArray(int[] nums) {
         if (nums == null || nums.length == 0 || nums.length == 1) {
             return nums;
         }
 
         quickSort(nums, 0, nums.length - 1);
 
         return nums;
     }
 
 
     private void quickSort(int[] nums, int start, int end) {
         if (start >= end) {
             return;
         }
         // 获取分区点
         int q = partition(nums, 0, end);
         quickSort(nums, start, q - 1);
         quickSort(nums, q + 1, end);
     }
 
     private int partition(int[] nums, int start, int end) {
         // 默认拿数组最后一个值作为分区点
         int pivot = nums[end];
         int i = start;
         for (int j = start; j < end; j++) {
             if (nums[j] < pivot) {
                 if (i == j) {
                     i++;
                 } else {
                     // 交换i和j
                     int tmp = nums[i];
                     nums[i] = nums[j];
                     nums[j] = tmp;
                     i++;
                 }
             }
         }
 
         if (i < end) {
             int tmp = nums[i];
             nums[i] = nums[end];
             nums[end] = tmp;
         }
 
         return i;
     }
}