快速选择

用于求解 Kth Element 问题，也就是第 K 个元素的问题。

可以使用快速排序的 partition() 进行实现。需要先打乱数组，否则最坏情况下时间复杂度为 O(N2)。

堆

用于求解 TopK Elements 问题，也就是 K 个最小元素的问题。可以维护一个大小为 K 的最小堆，最小堆中的元素就是最小元素。最小堆需要使用大顶堆来实现，大顶堆表示堆顶元素是堆中最大元素。这是因为我们要得到 k 个最小的元素，因此当遍历到一个新的元素时，需要知道这个新元素是否比堆中最大的元素更小，更小的话就把堆中最大元素去除，并将新元素添加到堆中。所以我们需要很容易得到最大元素并移除最大元素，大顶堆就能很好满足这个要求。

堆也可以用于求解 Kth Element 问题，得到了大小为 k 的最小堆之后，因为使用了大顶堆来实现，因此堆顶元素就是第 k 大的元素。

快速选择也可以求解 TopK Elements 问题，因为找到 Kth Element 之后，再遍历一次数组，所有小于等于 Kth Element 的元素都是 TopK Elements。

可以看到，快速选择和堆排序都可以求解 Kth Element 和 TopK Elements 问题。

1. Kth Element

在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

示例 1:

输入: [3,2,1,5,6,4] 和 k = 2
输出: 5

示例 2:

输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4

解法

• Java

排序：时间复杂度 O(NlogN)，空间复杂度 O(1)

public int findKthLargest(int[] nums, int k) {
   
    Arrays.sort(nums);
    return nums[nums.length - k];
}

堆 ：时间复杂度 O(NlogK)，空间复杂度 O(K)。

public int findKthLargest(int[] nums, int k) {
   
    PriorityQueue<Integer> pq = new PriorityQueue<>(); // 小顶堆
    for (int val : nums) {
   
        pq.add(val);
        if (pq.size() > k)  // 维护堆的大小为 K
            pq.poll();
    }
    return pq.peek();
}

快速选择 ：时间复杂度 O(N)，空间复杂度 O(1)

public int findKthLargest(int[] nums, int k) {
   
    k = nums.length - k;
    int l = 0, h = nums.length - 1;
    while (l < h) {
   
        int j = partition(nums, l, h);
        if (j == k) {
   
            break;
        } else if (j < k) {
   
            l = j + 1;
        } else {
   
            h = j - 1;
        }
    }
    return nums[k];
}

private int partition(int[] a, int l, int h) {
   
    int i = l, j = h + 1;
    while (true) {
   
        while (a[++i] < a[l] && i < h) ;
        while (a[--j] > a[l] && j > l) ;
        if (i >= j) {
   
            break;
        }
        swap(a, i, j);
    }
    swap(a, l, j);
    return j;
}

private void swap(int[] a, int i, int j) {
   
    int t = a[i];
    a[i] = a[j];
    a[j] = t;
}

桶排序

1. 出现频率最多的 k 个元素

Leetcode-347. 前 K 个高频元素

给定一个非空的整数数组，返回其中出现频率前 k 高的元素。

示例 1:

输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]

示例 2:

输入: nums = [1], k = 1
输出: [1]

说明：

• 你可以假设给定的 k 总是合理的，且 1 ≤ k ≤ 数组中不相同的元素的个数。
• 你的算法的时间复杂度必须优于 O(n log n) , n 是数组的大小。

解法：

• Java

设置若干个桶，每个桶存储出现频率相同的数。桶的下标表示数出现的频率，即第 i 个桶中存储的数出现的频率为 i。

把数都放到桶之后，从后向前遍历桶，最先得到的 k 个数就是出现频率最多的的 k 个数。

class Solution {
   
    public List<Integer> topKFrequent(int[] nums, int k) {
   
        Map<Integer, Integer> map = new HashMap<>();
        for (int num: nums) {
   
            map.put(num, map.getOrDefault(num, 0)+1);            
        }
        List<Integer>[] lstAry = new ArrayList[nums.length+1];
        for (int key: map.keySet()) {
   
            int frequency = map.get(key);
            if (lstAry[frequency]==null) lstAry[frequency] = new ArrayList<>();
            lstAry[frequency].add(key);
        }
        List<Integer> res = new ArrayList<>();
        for (int i=nums.length;i>=0;i--) {
   
            if (res.size() == k) break;
            if (lstAry[i]==null) continue;
            if (lstAry[i].size() <= (k-res.size())) res.addAll(lstAry[i]);
            else res.addAll(lstAry[i].subList(0, k-res.size()));
        }
        return res;
    }
}

2. 按照字符出现次数对字符串排序

Leetcode-451. 根据字符出现频率排序

给定一个字符串，请将字符串里的字符按照出现的频率降序排列。

示例 1:

输入:
"tree"

输出:
"eert"

解释:
'e'出现两次，'r'和't'都只出现一次。
因此'e'必须出现在'r'和't'之前。此外，"eetr"也是一个有效的答案。

示例 2:

输入:
"cccaaa"

输出:
"cccaaa"

解释:
'c'和'a'都出现三次。此外，"aaaccc"也是有效的答案。
注意"cacaca"是不正确的，因为相同的字母必须放在一起。

示例 3:

输入:
"Aabb"

输出:
"bbAa"

解释:
此外，"bbaA"也是一个有效的答案，但"Aabb"是不正确的。
注意'A'和'a'被认为是两种不同的字符。

解法：

• Java

class Solution {
   
    public String frequencySort(String s) {
   
        Map<Character, Integer> map = new HashMap<>();
        for (char c: s.toCharArray()) {
   
            map.put(c, map.getOrDefault(c, 0)+1);
        }
        List<Character>[] lstAry = new ArrayList[s.length()+1];
        for (char c: map.keySet()) {
   
            int frequency = map.get(c);
            if (lstAry[frequency] == null) lstAry[frequency] = new ArrayList<>();
            lstAry[frequency].add(c);
        }
        StringBuilder sb = new StringBuilder();
        for (int i=s.length();i>=0;i--) {
   
            if (lstAry[i] == null) continue;
            for (char c: lstAry[i]) {
   
                for (int j=0;j<i;j++) {
   
                    sb.append(c);
                }
            }
        }
        return sb.toString();
    }
}

荷兰国旗问题

荷兰国旗包含三种颜色：红、白、蓝。

有三种颜色的球，算法的目标是将这三种球按颜色顺序正确地排列。它其实是三向切分快速排序的一种变种，在三向切分快速排序中，每次切分都将数组分成三个区间：小于切分元素、等于切分元素、大于切分元素，而该算法是将数组分成三个区间：等于红色、等于白色、等于蓝色。

1. 按颜色进行排序

Leetcode-75. 颜色分类

给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。

此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。

注意:
不能使用代码库中的排序函数来解决这道题。

示例:

输入: [2,0,2,1,1,0]
输出: [0,0,1,1,2,2]

进阶：

• 一个直观的解决方案是使用计数排序的两趟扫描算法。
  首先，迭代计算出0、1 和 2 元素的个数，然后按照0、1、2的排序，重写当前数组。
• 你能想出一个仅使用常数空间的一趟扫描算法吗？

解法：

• Java

class Solution {
   
    public void sortColors(int[] nums) {
   
        int redBound = -1, cur = 0, blueBound = nums.length;
        while (cur < blueBound) {
   
            // 当前为红色，交换到红色边界的下一个位置，两个指针都要右移，因为从左边交换过来的只能是白色
            if (nums[cur]==0) swap(nums, cur++, ++redBound);
            // 当前为蓝色，交换到蓝色边界的前一个位置，但是cur不要+1因为不知道从右边交换过来的是什么颜色
            else if (nums[cur]==2) swap(nums, cur, --blueBound);
            // 当前为白色，继续向下
            else cur++;
        }
    }
    public void swap(int[] nums, int i, int j) {
   
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
}