[LeetCode]-排序

Pacifica_

已于 2022-12-17 21:07:32 修改

阅读量84

点赞数

分类专栏： LeetCode 文章标签： leetcode 算法

于 2022-05-30 13:17:05 首次发布

本文链接：https://blog.csdn.net/Pacifica_/article/details/124364487

版权

LeetCode 专栏收录该内容

36 篇文章 0 订阅

订阅专栏

前言

记录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. 数组中的逆序对

不看题解我也不会想到可以用归并排序做这道题。归并排序分为划分，排序，合并这三步。如果当前要合并 [a₁,a₂,…,a_i] 以及 [b_i+1,b_i+2,…,b_j] 这两个已排序好的区间，我们采取的操作是两个指针 p1 指向 a₁，p2 指向 b_i+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++];
        }
    }
}