題目
給你一個整數數組 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;
}
}