前言
记录LeetCode刷题时遇到的排序相关题目
面试题 10.01. 合并排序的数组
二路归并,临时创建一个长度为 m + n 的数组,然后将A,B数组中的元素进行二路归并升序排序存放到临时数组中,最后再把临时数组的元素复制到A中
这种做法需要临时数组,空间复杂度为O(m + n),因为如果直接归并到A数组中,当B中数组有元素大于A中某个元素的时候,A中的元素就会被覆盖
注意到 A 数组初始大小就是 m + n,这个设定绝对不是随便设的。为了将两个数组的元素归并后直接存放到A数组中,可以逆序遍历A,B数组,从大到小归并元素,详见代码
public void merge(int[] A, int m, int[] B, int n) {
//从A数组的最后面往前归并元素
int index = m + n - 1;
int pa = m - 1;
int pb = n - 1;
while(pa >= 0 && pb >= 0){
if(A[pa] > B[pb]){
A[index--] = A[pa--];
}else{
A[index--] = B[pb--];
}
}
while(pa >= 0){
A[index--] = A[pa--];
}
while(pb >= 0){
A[index--] = B[pb--];
}
}
快排解决 Top K 问题
之前遇到 Top K 问题,第一反应都是 优先队列。后面做的题越多,发现很多题解都是使用 快排 来解决这些问题,而且时间花费比 优先队列 要少很多
面试题 17.14. 最小K个数
看到最小 k,第一个想到的就是用 优先队列 / 堆 来解题;除此之外也可以先对数组排序然后直接取前 k 个数。但是这两种做法都需要对整个数组进行调整,但是我们只需要其中 k 个最小就够;而且这两种做法取出来的最小 k 个数都是有序的,但题目并不要求有序。总而言之,这两种做法会出现多余的操作
可以借助快排的思想:快排操作就是每次将一个数 (枢轴) 放置到其按顺序所该存放的位置上,保证其左边所有的数都小于等于它,其右边所有的数都大于等于它,且不保证左右两边的数的有序性。那么,假设一次操作完,将枢轴放到它所应该在的位置上,发现恰好是下标 k 的位置,那么整个数组中最小 k 个数不就正好是它左边那 k 个数 (即下标 [0,k - 1] 的数)
所以只需在快排的基础上,每次排完一个枢轴判断它的位置,如果是索引 k 的位置,那就返回其左边 k 个数;如果是索引 k - 1 的位置,就返回其左边 k - 1个数再加上它本身;如果大于 k ,就对左边部分进行快排;如果小于 k - 1,就对右边部分进行快排
class Solution {
int[] quickSort(int[] arr,int l,int r,int k){
if(l >= r) return null;
int ll = l;
int rr = r;
while(rr > ll){
//这里要用">=",因为有相等的数并不影响索引k的位置的左边是最小k个数
while(arr[rr] >= arr[l] && rr > ll) rr--;
while(arr[ll] <= arr[l] && rr > ll) ll++;
if(rr != ll){ //这里如果改成了rr > ll,用时就变 2ms 了
swap(arr,rr,ll);
}
}
swap(arr,rr,l);
if(rr == k) return Arrays.copyOfRange(arr,0,rr);
if(rr == k - 1) return Arrays.copyOfRange(arr,0,rr + 1);
if(rr > k) return quickSort(arr,l,rr - 1,k);
if(rr < k) return quickSort(arr,rr + 1,r,k);
return null;
}
public int[] smallestK(int[] arr, int k) {
if(k == 0) return new int[0];
return quickSort(arr,0,arr.length - 1,k);
}
void swap(int[] arr,int i,int j){
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}
215. 数组中的第K个最大元素
这道题大部分代码我是从上面 最小 K 个数 的代码 copy 过来的
思路很简单,数组中的第 K 个最大元素,其实也就是数组排序后的下标为 nums.length - k 的元素,所以使用快排对数组进行处理,找到排序后下标为 nums.length - k 的元素即可
要注意的是,在这道题中,枢轴有没有进行随机选取对跑出来的时间影响很大——如果选区间最左边的数为枢轴,结果耗时是 12ms 左右;而枢轴随机化后结果耗时达到 1ms。总之,枢轴随机化普遍来说还是很有必要的
class Solution {
int quickSort(int[] arr,int l,int r,int k){
if(l == r) return arr[l]; //注意这里l == r,即剩下一个数时直接返回
//===========枢轴随机选取================//
int randomIndex = new Random().nextInt(r + 1 - l) + l;
swap(arr,l,randomIndex);
//=====================================//
int ll = l;
int rr = r;
while(rr > ll){
while(arr[rr] >= arr[l] && rr > ll) rr--;
while(arr[ll] <= arr[l] && rr > ll) ll++;
if(rr != ll){
swap(arr,rr,ll);
}
}
swap(arr,rr,l);
if(rr == k) return arr[rr];
if(rr > k) return quickSort(arr,l,rr - 1,k);
if(rr < k) return quickSort(arr,rr + 1,r,k);
return -1;
}
void swap(int[] arr,int i,int j){
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
public int findKthLargest(int[] nums, int k) {
return quickSort(nums,0,nums.length - 1,nums.length - k);
}
}
347. 前 K 个高频元素
桶排序的思想。统计数组中每个数的出现次数,再按照出现次数从多到少取对应的数,取够 k 个就是答案
public int[] topKFrequent(int[] nums, int k) {
List<Integer> res = new ArrayList();
//使用一个map记录所有元素的出现次数,键为某个元素,值为其出现次数
HashMap<Integer,Integer> map = new HashMap();
for(int num : nums){
map.put(num,map.getOrDefault(num,0) + 1);
}
//再以出现次数为数组下标,出现次数相同的元素构成的列表作为数组元素
List<Integer>[] list = new List[nums.length + 1];
for(int key : map.keySet()){
int i = map.get(key);
if(list[i] == null){
list[i] = new ArrayList();
}
list[i].add(key);
}
//这样,数组中下标从大到小的元素就是出现频率从高到低的元素,所以按照下标从大到小取够k个数就是出现频率最高的k个数
for(int i = list.length - 1;i >= 0 && res.size() < k;i--){
if(list[i] == null) continue;
res.addAll(list[i]);
}
//由于是使用ArrayList收集元素,要转化为数组
int size = res.size();
int[] ans = new int[size];
for(int i = 0;i < size;i++){
ans[i] = res.get(i);
}
return ans;
}
剑指 Offer 51. 数组中的逆序对
不看题解我也不会想到可以用归并排序做这道题。归并排序分为划分,排序,合并这三步。如果当前要合并 [a1,a2,…,ai] 以及 [bi+1,bi+2,…,bj] 这两个已排序好的区间,我们采取的操作是两个指针 p1 指向 a1,p2 指向 bi+1,然后重复比较两个指针指向的数哪个更小,就放入排序后数组,然后指针后移
那么如何把查找逆序对的操作融入这个过程?如果我们判断出 p1 指向的数大于 p2 指向的数,由于 a 区间中是升序排好的,所以 p1 后续的数也会大于 p2,也就是说 p1 以及 p1 后续的数都与 p2 构成逆序对,计算共多少个数累加到 res 中即可。而且此时 p2 会增一,后续不会再被拿来计算,保证了每个数对逆序对对数的贡献只会被计算一次
class Solution {
public int[] tmp;
public int res = 0;
public int reversePairs(int[] nums) {
tmp = new int[nums.length];
mergeSort(nums,0,nums.length - 1);
return res;
}
public void mergeSort(int[] nums,int l,int r){
if(l >= r) return;
int mid = (l + r) >> 1;
mergeSort(nums,l,mid);
mergeSort(nums,mid + 1,r);
merge(nums,l,mid,r);
}
public void merge(int[] nums,int l,int mid,int r){
System.arraycopy(nums,l,tmp,l,r - l + 1);
int index = l;
int p1 = l,p2 = mid + 1;
while(p1 <= mid && p2 <= r){
if(tmp[p1] > tmp[p2]){
res += mid - p1 + 1; //相比于单纯的归并排序,其实只加了这一行代码
nums[index++] = tmp[p2++];
}else{
nums[index++] = tmp[p1++];
}
}
while(p1 <= mid){
nums[index++] = tmp[p1++];
}
while(p2 <= r){
nums[index++] = tmp[p2++];
}
}
}