交换排序
冒泡排序
从小到达排序,每次循环把最大的数移到后面
时间复杂度:
- 平均:O(n2)
- 最好(数组有序):O(n)
稳定
void bubble(int[] nums) {
int n = nums.length;
for (int i = n - 1; i > 0; i--) {
boolean flag = true;
for (int j = 0; j < i; j++)
if (nums[j] > nums[j + 1]) {
int tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
flag = false;
}
if (flag) break;
}
}
快速排序
时间复杂度:
- 平均:O(log2n)
- 最差(数组基本有序):O(n2)
不稳定
每一趟排序至少确定一个元素的最终位置
public static void quickSort(int[] nums, int begin, int end) {
if (begin >= end) return;
int first = nums[begin], i = begin, j = end;
while (i < j) {
// 这一步可能会导致不稳定, 例如 (0, 2) (1, 1) (2, 1) -> (2, 1) (1, 1) (0, 2)
while (i < j && nums[j] >= first) --j;
swap(nums, i, j);
// 这一步可能会导致不稳定
while (i < j && nums[i] < first) ++i;
swap(nums, i, j);
}
nums[i] = first;
quickSort(nums, begin, i - 1);
quickSort(nums, i + 1, end);
}
public void swap(int[] nums, int i, int j) {
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
插入排序
直接插入排序
数组的前 i 个元素有序。
时间复杂度:
- 平均:O(n2)
- 最好(数组有序):O(n)
稳定
每一趟排序不一定能确定元素的最终位置
public void directInsert(int[] nums) {
int n = nums.length;
for (int i = 1; i < n; i++) {
int insertVal = nums[i], j = i - 1;
for (; j >= 0 && nums[j] > insertVal; j--) nums[j + 1] = nums[j];
nums[j + 1] = insertVal;
}
}
希尔排序
时间复杂度:O(n1.5)
不稳定,例如 (0, 2), (1, 1), (2, 1),当 k = 2 时,排序的结果为 (2, 1), (1, 1), (0, 2),两个 1 的相对位置变了。
public void shellSort(int[] nums) {
int n = nums.length;
for (int k = n / 2; k > 0; k /= 2) {
for (int i = k; i < n; i++) {
int insertVal = nums[i], j = i - k;
for (; j >= 0 && nums[j] > insertVal; j -= k) nums[j + k] = nums[j];
nums[j + k] = insertVal;
}
}
}
选择排序
简单选择排序
每次选择数组中最小的元素与已排序好的后面一个元素交换
时间复杂度:与数组的初始状态无关,恒为 O(n2)
不稳定,例如 (0, 2), (1, 2), (2, 1),第一次排序后,(2, 1), (1, 2), (0, 2)
public void simpleChoose(int[] nums) {
int n = nums.length;
for (int i = 0; i < n - 1; i++) {
int min = i;
for (int j = i + 1; j < n; j++) if (nums[min] > nums[j]) min = j;
if (min != i) {
int tmp = nums[i];
nums[i] = nums[min];
nums[min] = tmp;
}
}
}
堆排序
将数组从小到大排序时,构建大顶堆,每趟把堆顶元素跟已排序的前一个元素交换。
堆是一棵完全二叉树,用数组存储,数组下标从 0 开始,则下标为 i 的结点,左孩子的下标为 2 * i + 1,右孩子的下标为 2 * i + 2,第一个非叶子结点的下标为 n / 2 - 1,其中 n 为数组大小。
时间复杂度:恒为 O(nlogn)
不稳定
public void heap(int[] nums) {
int n = nums.length;
for (int i = n / 2 - 1; i >= 0; i--) adjustHeap(i, n, nums);
for (int i = n - 1; i > 0; i--) {
// 这一步的交换可能会导致不稳定, 例如 (0, 2), (1, 1), (2, 1), 第一个元素跟最后一个元素交换后, (2, 1), (1, 1), (0, 2)
int tmp = nums[0];
nums[0] = nums[i];
nums[i] = tmp;
adjustHeap(0, i, nums);
}
}
private void adjustHeap(int k, int n, int[] nums) {
int tmp = nums[k];
for (int i = 2 * k + 1; i < n; i = i * 2 + 1) {
if (i + 1 < n && nums[i + 1] > nums[i]) ++i;
if (nums[i] > tmp) {
nums[k] = nums[i];
k = i;
} else break;
}
nums[k] = tmp;
}
归并排序
时间复杂度:恒为 O(log2n)
递归写法:
int[] tmpArr;
public void divideMerge(int[] nums) {
int n = nums.length;
tmpArr = new int[n];
divide(nums, 0, n - 1);
}
private void divide(int[] nums, int begin, int end) {
if (begin >= end) return;
int mid = begin + (end - begin) / 2;
divide(nums, begin, mid);
divide(nums, mid + 1, end);
merge(nums, mid, begin, end);
}
private void merge(int[] nums, int mid, int begin, int end) {
int i = begin, j = mid + 1, k = 0;
// 哪个小就先放入到 tmpArr 中, [left, mid] 和 [mid + 1, right] 之间的元素是有序的
while (i <= mid && j <= end) {
if (nums[i] <= nums[j]) tmpArr[k++] = nums[i++];
else tmpArr[k++] = nums[j++];
}
// 以下两个只会执行其中一个
while (i <= mid) tmpArr[k++] = nums[i++];
while (j <= end) tmpArr[k++] = nums[j++];
k = 0;
int size = end - begin + 1;
while (k < size) nums[begin++] = tmpArr[k++];
}
迭代写法:
public void mergeSort(int[] nums) {
int n = nums.length;
tmpArr = new int[n];
for (int k = 1; k < n; k *= 2) {
int i = 0;
while (i + 2 * k - 1 < n) {
merge(nums, i, i + k - 1, i + 2 * k - 1);
i += 2 * k;
}
if (i + k - 1 < n - 1) merge(nums, i, i + k - 1, n - 1);
}
}
桶排序
构造有序的桶,然后把元素放入桶中,在桶中排序,最后输出就是有序的
时间复杂度:O(n)
public static void tong(int[] nums) {
int min = Integer.MAX_VALUE;
int max = Integer.MIN_VALUE;
for (int num : nums) {
min = Math.min(min, num);
max = Math.max(max, num);
}
int bucketSize = (int)Math.ceil((double)(max - min) / nums.length);
List<List<Integer>> bucket = new ArrayList<>(bucketSize);
for (int i = 0; i < bucketSize; i++) bucket.add(new ArrayList<>());
for (int num : nums) {
int index = (num - min) / nums.length;
bucket.get(index).add(num);
}
int index = 0;
for (List<Integer> list : bucket) {
if (list.isEmpty()) continue;
Collections.sort(list);
for (int num : list) nums[index++] = num;
}
}