LeetCode入门指南 之 排序
912. 排序数组
给你一个整数数组
nums，请你将该数组升序排列。
归并排序
public class Sort {
//归并排序
public static int[] MergeSort(int[] arr) {
int[] temp = new int[arr.length];
mergeSort(arr, 0, arr.length - 1, temp);
return arr;
}
private static void mergeSort(int[] arr, int left, int right, int[] temp) {
if (left >= right) {
return;
}
int mid = (left + right) / 2;
mergeSort(arr, left, mid, temp);
mergeSort(arr, mid + 1, right, temp);
merge(arr, left, mid, right, temp);
}
private static void merge(int[] arr, int left, int mid, int right, int[] temp) {
int i = left, j = mid + 1;
int k = 0;
while(i <= mid && j <= right) {
if (arr[i] < arr[j]) { //改成 <= 就是稳定的
temp[k++] = arr[i++];
} else {
temp[k++] = arr[j++];
}
}
//如果左边还有剩余
while(i <= mid) {
temp[k++] = arr[i++];
}
//如果右边还有剩余
while(j <= right) {
temp[k++] = arr[j++];
}
//将temp中的数据放回arr
k = 0;
for (int m = left; m <= right; m++) {
arr[m] = temp[k++];
}
}
}
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的。稳定性的好处：排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。推荐阅读：堆排序为什么不稳定_为什么要区分稳定和不稳定排序
时间复杂度：平均 O(nlogn) 最优 O(nlogn) 最差 O(nlogn)
空间复杂度：O(n) = max(O(logn)——递归栈深度, O(n)——临时数组)
是否稳定性算法: 是/否，取决于
merge函数的实现。看merge是否会导致两个值相同的元素发生前后顺序的改变，现在的实现是不稳定的。（如：[ 1, 2, 3, 2] 。第一次合并：1和2、3和2合并有[1, 2, 2, 3]；第二次合并：1, 2 和 2, 3合并得[1, 2, 2, 3]，但已经交换了两个2的先后）
快速排序
public class Sort {
//快速排序
public static int[] QuickSort(int[] arr) {
quickSort(arr, 0, arr.length - 1);
return arr;
}
private static void quickSort(int[] arr, int left, int right) {
if (left >= right) {
return;
}
int mid = partition(arr, left, right);
quickSort(arr, left, mid - 1);
quickSort(arr, mid + 1, right);
}
private static Random random = new Random(47);
private static int partition(int[] arr, int left, int right) {
int rand = left + random.nextInt(right - left + 1);
swap(arr, left, rand);
int pivot = arr[left];
while (left < right) {
// 右边找一个 小于等于 pivot 的元素
while (left < right && arr[right] > pivot) {
right--;
}
// 找到了就将右边的元素放到左边
if (left < right) {
swap(arr, left, right);
left++;
}
// 左边找一个 大于 pivot 的元素
while (left < right && arr[left] <= pivot) {
left++;
}
if (left < right) {
swap(arr, left, right);
right--;
}
}
//跳出循环时 left = right
arr[left] = pivot;
return left;
}
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
- 归并排序是标准的分治法模板
- 快速排序只有分没有治，因为在分之前就已经做好了要做的事
时间复杂度：平均 O(nlogn) 最优 O(nlogn) 最差O(n2)
空间复杂度：O(logn) —— 递归栈深度
是否稳定排序算法：否 （如：[ 4, 2, 3, 2] -> [2, 2, 3, 4]）这里的 4 - 2 交换，导致原有的 2、2排序被打乱。
堆排序
堆：一种满足堆积性质的完全二叉树，需要满足如下性质：
堆中的某个节点的值总是大于等于或小于等于其父节点的值；
堆总是一颗完全二叉树；
public class Sort {
//堆排序
public static void HeapSort(int[] arr) {
buildMaxHeap(arr);
for (int i = arr.length - 1; i > 0; i--) {
swap(arr, 0, i); //将堆顶元素和最后一个叶子结点交换，最大值放到数组尾部
heapify(arr, 0, i); //对前i个元素构建新的大顶堆
}
}
//构建大顶堆(从第一个非叶子结点从右至左，从下至上)
private static void buildMaxHeap(int[] arr) {
for (int i = arr.length / 2 - 1; i >= 0; i--) {
heapify(arr, i, arr.length);
}
}
//以i为根的堆调整(大顶堆)
private static void heapify(int[]arr, int i, int length) {
int left = 2*i + 1;
int right = 2*i + 2;
int largest = i; //假设根节点i为最大值
// 左子结点存在且大于根节点
if (left < length && arr[left] > arr[largest]) {
largest = left;
}
// 右子结点存在且大于根节点
if (right < length && arr[right] > arr[largest]) {
largest = right;
}
if (largest != i) { //说明最大值为其子结点
swap(arr, largest, i);
heapify(arr, largest, length); //交换过后再调整其子结点为根的堆
}
}
private static void swap(int[]arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
时间复杂度：平均 O(nlogn) 最优 O(nlogn) 最差 O(nlogn)
空间复杂度：O(logn) - 递归堆栈
是否稳定排序算法：否。比如：3 27 36 27（小顶堆），如果堆顶3先输出，则，第三层的27（最后一个27）跑到堆顶，然后堆稳定，继续输出堆顶，是刚才那个27，这样说明后面的27先于第二个位置的27输出，不稳定。
排序结果测试类
public class Test {
private static final int num = 8000000;
private static int[] arr = new int[num];
private static SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH::mm:ss");
private static void generateArr() {
//给相同的种子使得每次生成的伪随机数序列相同
Random random = new Random(47);
for (int i = 0; i < num; i++) {
arr[i] = random.nextInt(num);
}
}
private static boolean isOrdered(int[] arr) {
boolean order = true;
for (int i = 0; i < arr.length - 1; i++) {
if (arr[i] > arr[i + 1]) {
order = false;
break;
}
}
return order;
}
public static void test(SortI sort) {
generateArr();
Date startDate = new Date();
System.out.println("start : " + formatter.format(startDate));
sort.sort(arr);
Date endDate = new Date();
System.out.println("end : " + formatter.format(endDate));
System.out.println("排序正确性：" + isOrdered(arr));
}
public static void main(String[] args) {
Test.test(Sort::MergeSort);
Test.test(Sort::QuickSort);
Test.test(Sort::HeapSort);
}
}
interface SortI {
void sort(int[] arr);
}
