From 0afafc69cd39746b8f1edca34103e44c486089f9 Mon Sep 17 00:00:00 2001 From: CyC2018 <1029579233@qq.com> Date: Thu, 21 Jun 2018 11:09:03 +0800 Subject: [PATCH] auto commit --- notes/Leetcode 题解.md | 558 +++++++++++++++++++++-------------------- 1 file changed, 283 insertions(+), 275 deletions(-) diff --git a/notes/Leetcode 题解.md b/notes/Leetcode 题解.md index 733d5851..44bddaa3 100644 --- a/notes/Leetcode 题解.md +++ b/notes/Leetcode 题解.md @@ -5622,116 +5622,6 @@ private boolean isLeaf(TreeNode node){ } ``` -**修剪二叉查找树** - -[669. Trim a Binary Search Tree (Easy)](https://leetcode.com/problems/trim-a-binary-search-tree/description/) - -```html -Input: - - 3 - / \ - 0 4 - \ - 2 - / - 1 - - L = 1 - R = 3 - -Output: - - 3 - / - 2 - / - 1 -``` - -二叉查找树（BST）：根节点大于等于左子树所有节点，小于等于右子树所有节点。 - -只保留值在 L \~ R 之间的节点 - -```java -public TreeNode trimBST(TreeNode root, int L, int R) { - if (root == null) return null; - if (root.val > R) return trimBST(root.left, L, R); - if (root.val < L) return trimBST(root.right, L, R); - root.left = trimBST(root.left, L, R); - root.right = trimBST(root.right, L, R); - return root; -} -``` - -**从有序数组中构造二叉查找树** - -[108. Convert Sorted Array to Binary Search Tree (Easy)](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/description/) - -```java -public TreeNode sortedArrayToBST(int[] nums) { - return toBST(nums, 0, nums.length - 1); -} - -private TreeNode toBST(int[] nums, int sIdx, int eIdx){ - if (sIdx > eIdx) return null; - int mIdx = (sIdx + eIdx) / 2; - TreeNode root = new TreeNode(nums[mIdx]); - root.left = toBST(nums, sIdx, mIdx - 1); - root.right = toBST(nums, mIdx + 1, eIdx); - return root; -} -``` - -**二叉查找树的最近公共祖先** - -[235. Lowest Common Ancestor of a Binary Search Tree (Easy)](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/description/) - -```html - _______6______ - / \ - ___2__ ___8__ - / \ / \ -0 4 7 9 - / \ - 3 5 - -For example, the lowest common ancestor (LCA) of nodes 2 and 8 is 6. Another example is LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. -``` - -```java -public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { - if (root.val > p.val && root.val > q.val) return lowestCommonAncestor(root.left, p, q); - if (root.val < p.val && root.val < q.val) return lowestCommonAncestor(root.right, p, q); - return root; -} -``` - -**二叉树的最近公共祖先** - -[236. Lowest Common Ancestor of a Binary Tree (Medium) ](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/) - -```html - _______3______ - / \ - ___5__ ___1__ - / \ / \ -6 2 0 8 - / \ - 7 4 - -For example, the lowest common ancestor (LCA) of nodes 5 and 1 is 3. Another example is LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. -``` - -```java -public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { - if (root == null || root == p || root == q) return root; - TreeNode left = lowestCommonAncestor(root.left, p, q); - TreeNode right = lowestCommonAncestor(root.right, p, q); - return left == null ? right : right == null ? left : root; -} -``` - **相同节点值的最大路径长度** [687. Longest Univalue Path (Easy)](https://leetcode.com/problems/longest-univalue-path/) @@ -5998,190 +5888,54 @@ public List inorderTraversal(TreeNode root) { ### BST -主要利用 BST 中序遍历有序的特点。 +二叉查找树（BST）：根节点大于等于左子树所有节点，小于等于右子树所有节点。 -**在 BST 中寻找两个节点，使它们的和为一个给定值** +二叉查找树中序遍历有序。 -[653. Two Sum IV - Input is a BST (Easy)](https://leetcode.com/problems/two-sum-iv-input-is-a-bst/description/) +**修剪二叉查找树** + +[669. Trim a Binary Search Tree (Easy)](https://leetcode.com/problems/trim-a-binary-search-tree/description/) ```html Input: - 5 + + 3 / \ - 3 6 - / \ \ -2 4 7 + 0 4 + \ + 2 + / + 1 -Target = 9 - -Output: True -``` - -使用中序遍历得到有序数组之后，再利用双指针对数组进行查找。 - -应该注意到，这一题不能用分别在左右子树两部分来处理这种思想，因为两个待求的节点可能分别在左右子树中。 - -```java -public boolean findTarget(TreeNode root, int k) { - List nums = new ArrayList<>(); - inOrder(root, nums); - int i = 0, j = nums.size() - 1; - while (i < j){ - int sum = nums.get(i) + nums.get(j); - if (sum == k) return true; - if (sum < k) i++; - else j--; - } - return false; -} - -private void inOrder(TreeNode root, List nums){ - if (root == null) return; - inOrder(root.left, nums); - nums.add(root.val); - inOrder(root.right, nums); -} -``` - -**在 BST 中查找两个节点之差的最小绝对值** - -[530. Minimum Absolute Difference in BST (Easy)](https://leetcode.com/problems/minimum-absolute-difference-in-bst/description/) - -```html -Input: - 1 - \ - 3 - / - 2 + L = 1 + R = 3 Output: -1 + + 3 + / + 2 + / + 1 ``` -利用 BST 的中序遍历为有序的性质，计算中序遍历中临近的两个节点之差的绝对值，取最小值。 +只保留值在 L \~ R 之间的节点 ```java -private int minDiff = Integer.MAX_VALUE; -private int preVal = -1; - -public int getMinimumDifference(TreeNode root) { - inorder(root); - return minDiff; -} - -private void inorder(TreeNode node){ - if (node == null) return; - inorder(node.left); - if (preVal != -1) minDiff = Math.min(minDiff, Math.abs(node.val - preVal)); - preVal = node.val; - inorder(node.right); -} -``` - -**把 BST 每个节点的值都加上比它大的节点的值** - -[Convert BST to Greater Tree (Easy)](https://leetcode.com/problems/convert-bst-to-greater-tree/description/) - -```html -Input: The root of a Binary Search Tree like this: - 5 - / \ - 2 13 - -Output: The root of a Greater Tree like this: - 18 - / \ - 20 13 -``` - -先遍历右子树。 - -```java -private int sum = 0; - -public TreeNode convertBST(TreeNode root) { - traver(root); +public TreeNode trimBST(TreeNode root, int L, int R) { + if (root == null) return null; + if (root.val > R) return trimBST(root.left, L, R); + if (root.val < L) return trimBST(root.right, L, R); + root.left = trimBST(root.left, L, R); + root.right = trimBST(root.right, L, R); return root; } - -private void traver(TreeNode root) { - if (root == null) return; - if (root.right != null) traver(root.right); - sum += root.val; - root.val = sum; - if (root.left != null) traver(root.left); -} ``` -**寻找 BST 中出现次数最多的节点** - -[501. Find Mode in Binary Search Tree (Easy)](https://leetcode.com/problems/find-mode-in-binary-search-tree/description/) - -```html - 1 - \ - 2 - / - 2 -return [2]. -``` - -```java -private int cnt = 1; -private int maxCnt = 1; -private TreeNode preNode = null; -private List list; - -public int[] findMode(TreeNode root) { - list = new ArrayList<>(); - inOrder(root); - int[] ret = new int[list.size()]; - int idx = 0; - for (int num : list) { - ret[idx++] = num; - } - return ret; -} - -private void inOrder(TreeNode node) { - if (node == null) return; - inOrder(node.left); - if (preNode != null) { - if (preNode.val == node.val) cnt++; - else cnt = 1; - } - if (cnt > maxCnt) { - maxCnt = cnt; - list.clear(); - list.add(node.val); - } else if (cnt == maxCnt) { - list.add(node.val); - } - preNode = node; - inOrder(node.right); -} -``` - -**寻找 BST 的第 k 个元素** +**寻找二叉查找树的第 k 个元素** [230. Kth Smallest Element in a BST (Medium)](https://leetcode.com/problems/kth-smallest-element-in-a-bst/description/) -递归解法： - -```java -public int kthSmallest(TreeNode root, int k) { - int leftCnt = count(root.left); - if (leftCnt == k - 1) return root.val; - if (leftCnt > k - 1) return kthSmallest(root.left, k); - return kthSmallest(root.right, k - leftCnt - 1); -} - -private int count(TreeNode node) { - if (node == null) return 0; - return 1 + count(node.left) + count(node.right); -} -``` 中序遍历解法： @@ -6206,7 +5960,129 @@ private void inOrder(TreeNode node, int k) { } ``` -**根据有序链表构造平衡的 BST** +递归解法： + +```java +public int kthSmallest(TreeNode root, int k) { + int leftCnt = count(root.left); + if (leftCnt == k - 1) return root.val; + if (leftCnt > k - 1) return kthSmallest(root.left, k); + return kthSmallest(root.right, k - leftCnt - 1); +} + +private int count(TreeNode node) { + if (node == null) return 0; + return 1 + count(node.left) + count(node.right); +} +``` + +**把二叉查找树每个节点的值都加上比它大的节点的值** + +[Convert BST to Greater Tree (Easy)](https://leetcode.com/problems/convert-bst-to-greater-tree/description/) + +```html +Input: The root of a Binary Search Tree like this: + + 5 + / \ + 2 13 + +Output: The root of a Greater Tree like this: + + 18 + / \ + 20 13 +``` + +先遍历右子树。 + +```java +private int sum = 0; + +public TreeNode convertBST(TreeNode root) { + traver(root); + return root; +} + +private void traver(TreeNode root) { + if (root == null) return; + if (root.right != null) traver(root.right); + sum += root.val; + root.val = sum; + if (root.left != null) traver(root.left); +} +``` + +**二叉查找树的最近公共祖先** + +[235. Lowest Common Ancestor of a Binary Search Tree (Easy)](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/description/) + +```html + _______6______ + / \ + ___2__ ___8__ + / \ / \ +0 4 7 9 + / \ + 3 5 + +For example, the lowest common ancestor (LCA) of nodes 2 and 8 is 6. Another example is LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. +``` + +```java +public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { + if (root.val > p.val && root.val > q.val) return lowestCommonAncestor(root.left, p, q); + if (root.val < p.val && root.val < q.val) return lowestCommonAncestor(root.right, p, q); + return root; +} +``` + +**二叉树的最近公共祖先** + +[236. Lowest Common Ancestor of a Binary Tree (Medium) ](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/) + +```html + _______3______ + / \ + ___5__ ___1__ + / \ / \ +6 2 0 8 + / \ + 7 4 + +For example, the lowest common ancestor (LCA) of nodes 5 and 1 is 3. Another example is LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. +``` + +```java +public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { + if (root == null || root == p || root == q) return root; + TreeNode left = lowestCommonAncestor(root.left, p, q); + TreeNode right = lowestCommonAncestor(root.right, p, q); + return left == null ? right : right == null ? left : root; +} +``` + +**从有序数组中构造二叉查找树** + +[108. Convert Sorted Array to Binary Search Tree (Easy)](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/description/) + +```java +public TreeNode sortedArrayToBST(int[] nums) { + return toBST(nums, 0, nums.length - 1); +} + +private TreeNode toBST(int[] nums, int sIdx, int eIdx){ + if (sIdx > eIdx) return null; + int mIdx = (sIdx + eIdx) / 2; + TreeNode root = new TreeNode(nums[mIdx]); + root.left = toBST(nums, sIdx, mIdx - 1); + root.right = toBST(nums, mIdx + 1, eIdx); + return root; +} +``` + + +**根据有序链表构造平衡的二叉查找树** [109. Convert Sorted List to Binary Search Tree (Medium)](https://leetcode.com/problems/convert-sorted-list-to-binary-search-tree/description/) @@ -6251,6 +6127,138 @@ private int size(ListNode node) { } ``` +**在二叉查找树中寻找两个节点，使它们的和为一个给定值** + +[653. Two Sum IV - Input is a BST (Easy)](https://leetcode.com/problems/two-sum-iv-input-is-a-bst/description/) + +```html +Input: + + 5 + / \ + 3 6 + / \ \ +2 4 7 + +Target = 9 + +Output: True +``` + +使用中序遍历得到有序数组之后，再利用双指针对数组进行查找。 + +应该注意到，这一题不能用分别在左右子树两部分来处理这种思想，因为两个待求的节点可能分别在左右子树中。 + +```java +public boolean findTarget(TreeNode root, int k) { + List nums = new ArrayList<>(); + inOrder(root, nums); + int i = 0, j = nums.size() - 1; + while (i < j) { + int sum = nums.get(i) + nums.get(j); + if (sum == k) return true; + if (sum < k) i++; + else j--; + } + return false; +} + +private void inOrder(TreeNode root, List nums) { + if (root == null) return; + inOrder(root.left, nums); + nums.add(root.val); + inOrder(root.right, nums); +} +``` + +**在二叉查找树中查找两个节点之差的最小绝对值** + +[530. Minimum Absolute Difference in BST (Easy)](https://leetcode.com/problems/minimum-absolute-difference-in-bst/description/) + +```html +Input: + + 1 + \ + 3 + / + 2 + +Output: + +1 +``` + +利用二叉查找树的中序遍历为有序的性质，计算中序遍历中临近的两个节点之差的绝对值，取最小值。 + +```java +private int minDiff = Integer.MAX_VALUE; +private TreeNode preNode = null; + +public int getMinimumDifference(TreeNode root) { + inOrder(root); + return minDiff; +} + +private void inOrder(TreeNode node) { + if (node == null) return; + inOrder(node.left); + if (preNode != null) minDiff = Math.min(minDiff, Math.abs(node.val - preNode.val)); + preNode = node; + inOrder(node.right); +} +``` + +**寻找二叉查找树中出现次数最多的值** + +[501. Find Mode in Binary Search Tree (Easy)](https://leetcode.com/problems/find-mode-in-binary-search-tree/description/) + +```html + 1 + \ + 2 + / + 2 + +return [2]. +``` + +答案可能不止一个，也就是有多个值出现的次数一样多，并且是最大的。 + +```java +private int curCnt = 1; +private int maxCnt = 1; +private TreeNode preNode = null; + +public int[] findMode(TreeNode root) { + List maxCntNums = new ArrayList<>(); + inOrder(root, maxCntNums); + int[] ret = new int[maxCntNums.size()]; + int idx = 0; + for (int num : maxCntNums) { + ret[idx++] = num; + } + return ret; +} + +private void inOrder(TreeNode node, List nums) { + if (node == null) return; + inOrder(node.left, nums); + if (preNode != null) { + if (preNode.val == node.val) curCnt++; + else curCnt = 1; + } + if (curCnt > maxCnt) { + maxCnt = curCnt; + nums.clear(); + nums.add(node.val); + } else if (curCnt == maxCnt) { + nums.add(node.val); + } + preNode = node; + inOrder(node.right, nums); +} +``` ### Trie