LeetCode精选题之排序、分治

LeetCode精选题之排序、分治

参考资料：CyC2018的LeetCode题解

排序

1 数组中的第K个最大元素–LeetCode215（Medium）

在未排序的数组中找到第 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

说明：你可以假设 k总是有效的，且 1 ≤ k ≤ 数组的长度。

思路：优先队列。时间复杂度 O(NlogK)，空间复杂度 O(K)。

class Solution {
    public int findKthLargest(int[] nums, int k) {
        PriorityQueue<Integer> heap = new PriorityQueue<>();
        for (int num : nums) {
            heap.offer(num);
            if (heap.size() > k) { // 维护堆的大小为k
                heap.poll();
            }
        }
        return heap.peek();
    }
}

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

class Solution {
    private static Random random = new Random(System.currentTimeMillis());
    public int findKthLargest(int[] nums, int k) {
        int left = 0;
        int right = nums.length - 1;
        int target = nums.length - k; //第k个最大元素在已排序的数组中对应的索引
        while (true) {
            int p = partiton(nums, left, right);
            if (p == target) {
                return nums[p];
            } else if (p > target) {
                right = p - 1;
            } else {
                left = p + 1;
            }
        }
    }

    private int partiton(int[] nums, int left, int right) {
        // 随机化应对特殊测试用例，防止退化成链表
        if (right > left) {
            int randomIndex = left + random.nextInt(right - left + 1);
            swap(nums, left, randomIndex);
        }
        int pivot = nums[left];
        int j = left;
        for (int i = left + 1; i <= right; i++) {
            if (nums[i] < pivot) {
                j++;
                swap(nums, i, j);
            }
        }
        swap(nums, left, j);
        return j;
    }
    
    private void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

参考题解：liweiwei1419的题解

2 前 K 个高频元素–LeetCode347（Medium）

给定一个非空的整数数组，返回其中出现频率前 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 是数组的大小。
• 题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的。
• 你可以按任意顺序返回答案。

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        Map<Integer, Integer> timeMap = new HashMap<>();
        for (int num : nums) {
            if (timeMap.containsKey(num)) {
                timeMap.put(num, 1 + timeMap.get(num));
            } else {
                timeMap.put(num, 1);
            }
        }
        PriorityQueue<Integer> minHeap = new PriorityQueue<>((a, b) -> (timeMap.get(a) - timeMap.get(b)));
        for (int key : timeMap.keySet()) {
            minHeap.offer(key);
            if (minHeap.size() > k) {
                minHeap.poll();
            }
        }
        int[] res = new int[k];
        int index = 0;
        while (!minHeap.isEmpty()) {
            res[index] = minHeap.poll();
            index++;
        }
        return res;
    }
}

3 根据字符出现频率排序–LeetCode451（Medium）

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

示例 1:

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

示例 2:

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

示例 3:

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

class Solution {
    public String frequencySort(String s) {
        Map<Character, Integer> timeMap = new HashMap<>();
        for (char sChar : s.toCharArray()) {
            if (timeMap.containsKey(sChar)) {
                timeMap.put(sChar, 1 + timeMap.get(sChar));
            } else {
                timeMap.put(sChar, 1);
            }
        }
        PriorityQueue<Character> maxHeap = new PriorityQueue<>((a, b) -> timeMap.get(b) - timeMap.get(a));
        for (Character sChar : timeMap.keySet()) {
            maxHeap.offer(sChar);
        }
        StringBuilder sb = new StringBuilder();
        while (!maxHeap.isEmpty()) {
            Character peek = maxHeap.peek();
            for (int i = 0; i < timeMap.get(peek); i++) {
                sb.append(peek);
            }
            maxHeap.poll();
        }
        return sb.toString();
    }
}

桶排序：设置若干个桶，每个桶存储出现频率相同的数。桶的下标表示数出现的频率，即第 i个桶中存储的数出现的频率为 i。把数都放到桶之后，从后向前遍历桶，得到答案。

public String frequencySort(String s) {
    Map<Character, Integer> frequencyForNum = new HashMap<>();
    for (char c : s.toCharArray())
        frequencyForNum.put(c, frequencyForNum.getOrDefault(c, 0) + 1);

    List<Character>[] frequencyBucket = new ArrayList[s.length() + 1];
    for (char c : frequencyForNum.keySet()) {
        int f = frequencyForNum.get(c);
        if (frequencyBucket[f] == null) {
            frequencyBucket[f] = new ArrayList<>();
        }
        frequencyBucket[f].add(c);
    }
    StringBuilder str = new StringBuilder();
    for (int i = frequencyBucket.length - 1; i >= 0; i--) {
        if (frequencyBucket[i] == null) {
            continue;
        }
        for (char c : frequencyBucket[i]) {
            for (int j = 0; j < i; j++) {
                str.append(c);
            }
        }
    }
    return str.toString();
}

4 颜色分类–LeetCode75（Medium）

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

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

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

示例:

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

进阶：

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

public void sortColors(int[] nums) {
    int zero = -1, one = 0, two = nums.length;
    while (one < two) {
        if (nums[one] == 0) {
            swap(nums, ++zero, one++);
        } else if (nums[one] == 2) {
            swap(nums, --two, one);
        } else {
            ++one;
        }
    }
}

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

另外一种写法：快速排序的基本实现。【注】上面的写法更加贴合题意。

class Solution {
    public void sortColors(int[] nums) {
        if (nums == null || nums.length == 0) {
            return ;
        }
        partition(nums, 0, nums.length - 1);
    }

    private void partition(int[] nums, int left, int right) {
        if (left >= right) {
            return ;
        }
        int v = nums[left];
        int i = left + 1;
        int j = left;
        while (i <= right) {
            if (nums[i] < v) {
                j++;
                swap(nums, i, j);
                i++;
            } else {
                i++;
            }
        }
        swap(nums, left, j);
        j--;
        partition(nums, left, j);
        partition(nums, j + 2, right);
        return;
    }

    private void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }

}

分治

1 为运算表达式设计优先级–LeetCode241（Medium）

给定一个含有数字和运算符的字符串，为表达式添加括号，改变其运算优先级以求出不同的结果。你需要给出所有可能的组合的结果。有效的运算符号包含 +, -以及 *。

示例 1:

输入: "2-1-1"
输出: [0, 2]
解释: 
((2-1)-1) = 0 
(2-(1-1)) = 2

示例 2:

输入: "2*3-4*5"
输出: [-34, -14, -10, -10, 10]
解释: 
(2*(3-(4*5))) = -34 
((2*3)-(4*5)) = -14 
((2*(3-4))*5) = -10 
(2*((3-4)*5)) = -10 
(((2*3)-4)*5) = 10

class Solution {
    public List<Integer> diffWaysToCompute(String input) {
        return partition(input);
    }

    private List<Integer> partition(String input) {
        List<Integer> result = new ArrayList<>();
        if (!input.contains("+") && !input.contains("-") && !input.contains("*")) {
            result.add(Integer.valueOf(input));
            return result;
        }
        for (int i = 0; i < input.length(); i++) {
            char ch = input.charAt(i);
            if (ch == '+' || ch == '-' || ch == '*') {
                for (Integer left : partition(input.substring(0, i))) {
                    for (Integer right : partition(input.substring(i + 1))) {
                        if (ch == '+') {
                            result.add(left + right);
                        } else if (ch == '-') {
                            result.add(left - right);
                        } else {
                            result.add(left * right);
                        }
                    }
                }
            }
        }
        return result;
    }
}

其它解法：递归，动态规划。

2 不同的二叉搜索树II–LeetCode95（Medium）

给定一个整数 n，生成所有由 1 ... n为节点所组成的 二叉搜索树 。

示例：

输入：3
输出：
[
  [1,null,3,2],
  [3,2,null,1],
  [3,1,null,null,2],
  [2,1,3],
  [1,null,2,null,3]
]
解释：
以上的输出对应以下 5 种不同结构的二叉搜索树：

   1         3     3      2      1
    \       /     /      / \      \
     3     2     1      1   3      2
    /     /       \                 \
   2     1         2                 3

提示：0 <= n <= 8

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<TreeNode> generateTrees(int n) {
        return generateBST(1, n);
    }

    private List<TreeNode> generateBST(int start, int end) {
        List<TreeNode> result = new ArrayList<>();
        if (start > end) {
            return result;
        }
        if (start == end) {
            TreeNode node = new TreeNode(start);
            result.add(node);
            return result;
        }
        for (int i = start; i <= end; i++) {
            if (i == start) {
                for (TreeNode node : generateBST(i + 1, end)) {
                    TreeNode root = new TreeNode(i);
                    root.right = node;
                    result.add(root);
                }
            } else if (i == end) {
                for (TreeNode node : generateBST(start, i - 1)) {
                    TreeNode root = new TreeNode(i);
                    root.left = node;
                    result.add(root);
                }
            } else {
                for (TreeNode leftNode : generateBST(start, i - 1)) {
                    for (TreeNode rightNode : generateBST(i + 1, end)) {
                        TreeNode root = new TreeNode(i);
                        root.left = leftNode;
                        root.right = rightNode;
                        result.add(root);
                    }
                }
            }
        }
        return result;
    }
}