auto commit

2019-05-14 22:56:30 +08:00
parent 1dd4d45e0a
commit cb20aadfef
14 changed files with 332 additions and 372 deletions
--- a/notes/Leetcode
+++ b/notes/Leetcode
@ -1,40 +1,40 @@
 <!-- GFM-TOC -->
 * [递归](#递归)
-    * [树的高度](#树的高度)
-    * [平衡树](#平衡树)
-    * [两节点的最长路径](#两节点的最长路径)
-    * [翻转树](#翻转树)
-    * [归并两棵树](#归并两棵树)
-    * [判断路径和是否等于一个数](#判断路径和是否等于一个数)
-    * [统计路径和等于一个数的路径数量](#统计路径和等于一个数的路径数量)
-    * [子树](#子树)
-    * [树的对称](#树的对称)
-    * [最小路径](#最小路径)
-    * [统计左叶子节点的和](#统计左叶子节点的和)
-    * [相同节点值的最大路径长度](#相同节点值的最大路径长度)
-    * [间隔遍历](#间隔遍历)
-    * [找出二叉树中第二小的节点](#找出二叉树中第二小的节点)
+    * [1. 树的高度](#1-树的高度)
+    * [2. 平衡树](#2-平衡树)
+    * [3. 两节点的最长路径](#3-两节点的最长路径)
+    * [4. 翻转树](#4-翻转树)
+    * [5. 归并两棵树](#5-归并两棵树)
+    * [6. 判断路径和是否等于一个数](#6-判断路径和是否等于一个数)
+    * [7. 统计路径和等于一个数的路径数量](#7-统计路径和等于一个数的路径数量)
+    * [8. 子树](#8-子树)
+    * [9. 树的对称](#9-树的对称)
+    * [10. 最小路径](#10-最小路径)
+    * [11. 统计左叶子节点的和](#11-统计左叶子节点的和)
+    * [12. 相同节点值的最大路径长度](#12-相同节点值的最大路径长度)
+    * [13. 间隔遍历](#13-间隔遍历)
+    * [14. 找出二叉树中第二小的节点](#14-找出二叉树中第二小的节点)
 * [层次遍历](#层次遍历)
-    * [一棵树每层节点的平均数](#一棵树每层节点的平均数)
-    * [得到左下角的节点](#得到左下角的节点)
+    * [1. 一棵树每层节点的平均数](#1-一棵树每层节点的平均数)
+    * [2. 得到左下角的节点](#2-得到左下角的节点)
 * [前中后序遍历](#前中后序遍历)
-    * [非递归实现二叉树的前序遍历](#非递归实现二叉树的前序遍历)
-    * [非递归实现二叉树的后序遍历](#非递归实现二叉树的后序遍历)
-    * [非递归实现二叉树的中序遍历](#非递归实现二叉树的中序遍历)
+    * [1. 非递归实现二叉树的前序遍历](#1-非递归实现二叉树的前序遍历)
+    * [2. 非递归实现二叉树的后序遍历](#2-非递归实现二叉树的后序遍历)
+    * [3. 非递归实现二叉树的中序遍历](#3-非递归实现二叉树的中序遍历)
 * [BST](#bst)
-    * [修剪二叉查找树](#修剪二叉查找树)
-    * [寻找二叉查找树的第 k 个元素](#寻找二叉查找树的第-k-个元素)
-    * [把二叉查找树每个节点的值都加上比它大的节点的值](#把二叉查找树每个节点的值都加上比它大的节点的值)
-    * [二叉查找树的最近公共祖先](#二叉查找树的最近公共祖先)
-    * [二叉树的最近公共祖先](#二叉树的最近公共祖先)
-    * [从有序数组中构造二叉查找树](#从有序数组中构造二叉查找树)
-    * [根据有序链表构造平衡的二叉查找树](#根据有序链表构造平衡的二叉查找树)
-    * [在二叉查找树中寻找两个节点，使它们的和为一个给定值](#在二叉查找树中寻找两个节点，使它们的和为一个给定值)
-    * [在二叉查找树中查找两个节点之差的最小绝对值](#在二叉查找树中查找两个节点之差的最小绝对值)
-    * [寻找二叉查找树中出现次数最多的值](#寻找二叉查找树中出现次数最多的值)
+    * [1. 修剪二叉查找树](#1-修剪二叉查找树)
+    * [2. 寻找二叉查找树的第 k 个元素](#2-寻找二叉查找树的第-k-个元素)
+    * [3. 把二叉查找树每个节点的值都加上比它大的节点的值](#3-把二叉查找树每个节点的值都加上比它大的节点的值)
+    * [4. 二叉查找树的最近公共祖先](#4-二叉查找树的最近公共祖先)
+    * [5. 二叉树的最近公共祖先](#5-二叉树的最近公共祖先)
+    * [6. 从有序数组中构造二叉查找树](#6-从有序数组中构造二叉查找树)
+    * [7. 根据有序链表构造平衡的二叉查找树](#7-根据有序链表构造平衡的二叉查找树)
+    * [8. 在二叉查找树中寻找两个节点，使它们的和为一个给定值](#8-在二叉查找树中寻找两个节点，使它们的和为一个给定值)
+    * [9. 在二叉查找树中查找两个节点之差的最小绝对值](#9-在二叉查找树中查找两个节点之差的最小绝对值)
+    * [10. 寻找二叉查找树中出现次数最多的值](#10-寻找二叉查找树中出现次数最多的值)
 * [Trie](#trie)
-    * [实现一个 Trie](#实现一个-trie)
-    * [实现一个 Trie，用来求前缀和](#实现一个-trie，用来求前缀和)
+    * [1. 实现一个 Trie](#1-实现一个-trie)
+    * [2. 实现一个 Trie，用来求前缀和](#2-实现一个-trie，用来求前缀和)
 <!-- GFM-TOC -->


@ -42,7 +42,7 @@

 一棵树要么是空树，要么有两个指针，每个指针指向一棵树。树是一种递归结构，很多树的问题可以使用递归来处理。

-## 树的高度
+## 1. 树的高度

 [104. Maximum Depth of Binary Tree (Easy)](https://leetcode.com/problems/maximum-depth-of-binary-tree/description/)

@ -53,7 +53,7 @@ public int maxDepth(TreeNode root) {
 }
 ```

-## 平衡树
+## 2. 平衡树

 [110. Balanced Binary Tree (Easy)](https://leetcode.com/problems/balanced-binary-tree/description/)

@ -84,7 +84,7 @@ public int maxDepth(TreeNode root) {
 }
 ```

-## 两节点的最长路径
+## 3. 两节点的最长路径

 [543. Diameter of Binary Tree (Easy)](https://leetcode.com/problems/diameter-of-binary-tree/description/)

@ -117,7 +117,7 @@ private int depth(TreeNode root) {
 }
 ```

-## 翻转树
+## 4. 翻转树

 [226. Invert Binary Tree (Easy)](https://leetcode.com/problems/invert-binary-tree/description/)

@ -131,7 +131,7 @@ public TreeNode invertTree(TreeNode root) {
 }
 ```

-## 归并两棵树
+## 5. 归并两棵树

 [617. Merge Two Binary Trees (Easy)](https://leetcode.com/problems/merge-two-binary-trees/description/)

@ -164,7 +164,7 @@ public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
 }
 ```

-## 判断路径和是否等于一个数
+## 6. 判断路径和是否等于一个数

 [Leetcdoe : 112. Path Sum (Easy)](https://leetcode.com/problems/path-sum/description/)

@ -192,7 +192,7 @@ public boolean hasPathSum(TreeNode root, int sum) {
 }
 ```

-## 统计路径和等于一个数的路径数量
+## 7. 统计路径和等于一个数的路径数量

 [437. Path Sum III (Easy)](https://leetcode.com/problems/path-sum-iii/description/)

@ -232,7 +232,7 @@ private int pathSumStartWithRoot(TreeNode root, int sum) {
 }
 ```

-## 子树
+## 8. 子树

 [572. Subtree of Another Tree (Easy)](https://leetcode.com/problems/subtree-of-another-tree/description/)

@ -283,7 +283,7 @@ private boolean isSubtreeWithRoot(TreeNode s, TreeNode t) {
 }
 ```

-## 树的对称
+## 9. 树的对称

 [101. Symmetric Tree (Easy)](https://leetcode.com/problems/symmetric-tree/description/)

@ -309,7 +309,7 @@ private boolean isSymmetric(TreeNode t1, TreeNode t2) {
 }
 ```

-## 最小路径
+## 10. 最小路径

 [111. Minimum Depth of Binary Tree (Easy)](https://leetcode.com/problems/minimum-depth-of-binary-tree/description/)

@ -325,7 +325,7 @@ public int minDepth(TreeNode root) {
 }
 ```

-## 统计左叶子节点的和
+## 11. 统计左叶子节点的和

 [404. Sum of Left Leaves (Easy)](https://leetcode.com/problems/sum-of-left-leaves/description/)

@ -352,7 +352,7 @@ private boolean isLeaf(TreeNode node){
 }
 ```

-## 相同节点值的最大路径长度
+## 12. 相同节点值的最大路径长度

 [687. Longest Univalue Path (Easy)](https://leetcode.com/problems/longest-univalue-path/)

@ -385,7 +385,7 @@ private int dfs(TreeNode root){
 }
 ```

-## 间隔遍历
+## 13. 间隔遍历

 [337. House Robber III (Medium)](https://leetcode.com/problems/house-robber-iii/description/)

@ -409,7 +409,7 @@ public int rob(TreeNode root) {
 }
 ```

-## 找出二叉树中第二小的节点
+## 14. 找出二叉树中第二小的节点

 [671. Second Minimum Node In a Binary Tree (Easy)](https://leetcode.com/problems/second-minimum-node-in-a-binary-tree/description/)

@ -444,7 +444,7 @@ public int findSecondMinimumValue(TreeNode root) {

 使用 BFS 进行层次遍历。不需要使用两个队列来分别存储当前层的节点和下一层的节点，因为在开始遍历一层的节点时，当前队列中的节点数就是当前层的节点数，只要控制遍历这么多节点数，就能保证这次遍历的都是当前层的节点。

-## 一棵树每层节点的平均数
+## 1. 一棵树每层节点的平均数

 [637. Average of Levels in Binary Tree (Easy)](https://leetcode.com/problems/average-of-levels-in-binary-tree/description/)

@ -469,7 +469,7 @@ public List<Double> averageOfLevels(TreeNode root) {
 }
 ```

-## 得到左下角的节点
+## 2. 得到左下角的节点

 [513. Find Bottom Left Tree Value (Easy)](https://leetcode.com/problems/find-bottom-left-tree-value/description/)

@ -550,7 +550,7 @@ void dfs(TreeNode root) {
 }
 ```

-## 非递归实现二叉树的前序遍历
+## 1. 非递归实现二叉树的前序遍历

 [144. Binary Tree Preorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-preorder-traversal/description/)

@ -570,7 +570,7 @@ public List<Integer> preorderTraversal(TreeNode root) {
 }
 ```

-## 非递归实现二叉树的后序遍历
+## 2. 非递归实现二叉树的后序遍历

 [145. Binary Tree Postorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-postorder-traversal/description/)

@ -593,7 +593,7 @@ public List<Integer> postorderTraversal(TreeNode root) {
 }
 ```

-## 非递归实现二叉树的中序遍历
+## 3. 非递归实现二叉树的中序遍历

 [94. Binary Tree Inorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-inorder-traversal/description/)

@ -622,7 +622,7 @@ public List<Integer> inorderTraversal(TreeNode root) {

 二叉查找树中序遍历有序。

-## 修剪二叉查找树
+## 1. 修剪二叉查找树

 [669. Trim a Binary Search Tree (Easy)](https://leetcode.com/problems/trim-a-binary-search-tree/description/)

@ -662,7 +662,7 @@ public TreeNode trimBST(TreeNode root, int L, int R) {
 }
 ```

-## 寻找二叉查找树的第 k 个元素
+## 2. 寻找二叉查找树的第 k 个元素

 [230. Kth Smallest Element in a BST (Medium)](https://leetcode.com/problems/kth-smallest-element-in-a-bst/description/)

@ -706,7 +706,7 @@ private int count(TreeNode node) {
 }
 ```

-## 把二叉查找树每个节点的值都加上比它大的节点的值
+## 3. 把二叉查找树每个节点的值都加上比它大的节点的值

 [Convert BST to Greater Tree (Easy)](https://leetcode.com/problems/convert-bst-to-greater-tree/description/)

@ -743,7 +743,7 @@ private void traver(TreeNode node) {
 }
 ```

-## 二叉查找树的最近公共祖先
+## 4. 二叉查找树的最近公共祖先

 [235. Lowest Common Ancestor of a Binary Search Tree (Easy)](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/description/)

@ -767,7 +767,7 @@ public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
 }
 ```

-## 二叉树的最近公共祖先
+## 5. 二叉树的最近公共祖先

 [236. Lowest Common Ancestor of a Binary Tree (Medium) ](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/)

@ -792,7 +792,7 @@ public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
 }
 ```

-## 从有序数组中构造二叉查找树
+## 6. 从有序数组中构造二叉查找树

 [108. Convert Sorted Array to Binary Search Tree (Easy)](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/description/)

@ -811,7 +811,7 @@ private TreeNode toBST(int[] nums, int sIdx, int eIdx){
 }
 ```

-## 根据有序链表构造平衡的二叉查找树
+## 7. 根据有序链表构造平衡的二叉查找树

 [109. Convert Sorted List to Binary Search Tree (Medium)](https://leetcode.com/problems/convert-sorted-list-to-binary-search-tree/description/)

@ -852,7 +852,7 @@ private ListNode preMid(ListNode head) {
 }
 ```

-## 在二叉查找树中寻找两个节点，使它们的和为一个给定值
+## 8. 在二叉查找树中寻找两个节点，使它们的和为一个给定值

 [653. Two Sum IV - Input is a BST (Easy)](https://leetcode.com/problems/two-sum-iv-input-is-a-bst/description/)

@ -896,7 +896,7 @@ private void inOrder(TreeNode root, List<Integer> nums) {
 }
 ```

-## 在二叉查找树中查找两个节点之差的最小绝对值
+## 9. 在二叉查找树中查找两个节点之差的最小绝对值

 [530. Minimum Absolute Difference in BST (Easy)](https://leetcode.com/problems/minimum-absolute-difference-in-bst/description/)

@ -934,7 +934,7 @@ private void inOrder(TreeNode node) {
 }
 ```

-## 寻找二叉查找树中出现次数最多的值
+## 10. 寻找二叉查找树中出现次数最多的值

 [501. Find Mode in Binary Search Tree (Easy)](https://leetcode.com/problems/find-mode-in-binary-search-tree/description/)

@ -991,7 +991,7 @@ private void inOrder(TreeNode node, List<Integer> nums) {

 Trie，又称前缀树或字典树，用于判断字符串是否存在或者是否具有某种字符串前缀。

-## 实现一个 Trie
+## 1. 实现一个 Trie

 [208. Implement Trie (Prefix Tree) (Medium)](https://leetcode.com/problems/implement-trie-prefix-tree/description/)

@ -1053,7 +1053,7 @@ class Trie {
 }
 ```

-## 实现一个 Trie，用来求前缀和
+## 2. 实现一个 Trie，用来求前缀和

 [677. Map Sum Pairs (Medium)](https://leetcode.com/problems/map-sum-pairs/description/)