[Function add]

1. Add leetcode solutions with tag tree.

Author: Seanforfun

README.md

@@ -642,6 +642,48 @@
 #### Bipartite
 * [785. Is Graph Bipartite?](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/785.%20Is%20Graph%20Bipartite?.md)
 * [886. Possible Bipartition](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/886.%20Possible%20Bipartition.md)
+#### Cycle+Union-find
+* [684. Redundant Connection](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/684.%20Redundant%20Connection.md)
+* [685. Redundant Connection II](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/685.%20Redundant%20Connection%20II.md)
+* [787. Cheapest Flights Within K Stops](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/787.%20Cheapest%20Flights%20Within%20K%20Stops.md)
+#### Shortest Path
+* [743. Network Delay Time](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/743.%20Network%20Delay%20Time.md)
+#### BFS
+* [847. Shortest Path Visiting All Nodes](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/847.%20Shortest%20Path%20Visiting%20All%20Nodes.md)
+* [815. Bus Routes](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/815.%20Bus%20Routes.md)
+* [864. Shortest Path to Get All Keys](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/864.%20Shortest%20Path%20to%20Get%20All%20Keys.md)
+* [924. Minimize Malware Spread](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/924.%20Minimize%20Malware%20Spread.md)
+#### Hamilton Path / DP
+* [943. Find the Shortest Superstring](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/943.%20Find%20the%20Shortest%20Superstring.md)
+* [980. Unique Paths III](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/980.%20Unique%20Paths%20III.md)
+* [996. Number of Squareful Arrays](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/996.%20Number%20of%20Squareful%20Arrays.md)
+#### Union-find + connected component
+* [959. Regions Cut By Slashes](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/959.%20Regions%20Cut%20By%20Slashes.md)
+
+### Tree
+#### Traversal
+* [94. Binary Tree Inorder Traversal](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/94.%20Binary%20Tree%20Inorder%20Traversal.md)
+* [589. N-ary Tree Preorder Traversal](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/589.%20N-ary%20Tree%20Preorder%20Traversal.md)
+* [590. N-ary Tree Postorder Traversal](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/590.%20N-ary%20Tree%20Postorder%20Traversal.md)
+* [100. Same Tree](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/100.%20Same%20Tree.md)
+* [101. Symmetric Tree](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/101.%20Symmetric%20Tree.md)
+* [104. Maximum Depth of Binary Tree](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/104.%20Maximum%20Depth%20of%20Binary%20Tree.md)
+* [110. Balanced Binary Tree](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/110.%20Balanced%20Binary%20Tree.md)
+* [111. Minimum Depth of Binary Tree](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/111.%20Minimum%20Depth%20of%20Binary%20Tree.md)
+* [572. Subtree of Another Tree](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/572.%20Subtree%20of%20Another%20Tree.md)
+* [965. Univalued Binary Tree](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/965.%20Univalued%20Binary%20Tree.md)
+#### Collecting Node
+* [102. Binary Tree Level Order Traversal](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/102.%20Binary%20Tree%20Level%20Order%20Traversal.md)
+* [107. Binary Tree Level Order Traversal II](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/107.%20Binary%20Tree%20Level%20Order%20Traversal%20II.md)
+* [429. N-ary Tree Level Order Traversal](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/429.%20N-ary%20Tree%20Level%20Order%20Traversal.md)
+* [987. Vertical Order Traversal of a Binary Tree](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/987.%20Vertical%20Order%20Traversal%20of%20a%20Binary%20Tree.md)
+* [814. Binary Tree Pruning](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/814.%20Binary%20Tree%20Pruning.md)
+* [669. Trim a Binary Search Tree](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/669.%20Trim%20a%20Binary%20Search%20Tree.md)
+* [112. Path Sum](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/112.%20Path%20Sum.md)
+* [113. Path Sum II](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/113.%20Path%20Sum%20II.md)
+* [437. Path Sum III](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/437.%20Path%20Sum%20III.md)
+
+
 
 ## Algorithm(4th_Edition)
 Reading notes of book Algorithm(4th Algorithm),ISBN: 9787115293800.

leetcode/112. Path Sum.md

@@ -89,4 +89,33 @@ class Solution {
         }
     }
 }
-```
+```
+
+### Third Time
+* Method 1: DFS
+	```Java
+	/**
+	 * Definition for a binary tree node.
+	 * public class TreeNode {
+	 *     int val;
+	 *     TreeNode left;
+	 *     TreeNode right;
+	 *     TreeNode(int x) { val = x; }
+	 * }
+	 */
+	class Solution {
+		public boolean hasPathSum(TreeNode root, int sum) {
+			if(root == null) return false;
+			return dfs(root, 0, sum);
+		}
+		private boolean dfs(TreeNode node, int cur, int sum){
+			if(node.left == null && node.right == null){
+				return cur + node.val == sum;
+			}else{
+				if(node.left != null && dfs(node.left, cur + node.val, sum))   return true;
+				if(node.right != null && dfs(node.right, cur + node.val, sum))  return true;
+				return false;
+			}
+		}
+	}
+	```

leetcode/113. Path Sum II.md

@@ -105,4 +105,40 @@ class Solution {
         temp.remove(temp.size() - 1);
     }
 }
-```
+```
+
+### Third Time
+* Method 1: dfs
+	```Java
+	/**
+	 * Definition for a binary tree node.
+	 * public class TreeNode {
+	 *     int val;
+	 *     TreeNode left;
+	 *     TreeNode right;
+	 *     TreeNode(int x) { val = x; }
+	 * }
+	 */
+	class Solution {
+		private List<List<Integer>> result;
+		public List<List<Integer>> pathSum(TreeNode root, int sum) {
+			result = new ArrayList<>();
+			if(root == null) return result;
+			dfs(root, new ArrayList<>(), 0, sum);
+			return result;
+		}
+		private void dfs(TreeNode node, List<Integer> temp, int cur, int sum){
+			if(node == null){
+				if(cur == sum)  result.add(new ArrayList<Integer>(temp));
+			}else{
+				temp.add(node.val);
+				if(node.left == null && node.right == null) dfs(node.left, temp, cur + node.val, sum);
+				else{
+					if(node.left != null)   dfs(node.left, temp, cur + node.val, sum);
+					if(node.right != null)  dfs(node.right, temp, cur + node.val, sum);
+				}
+				temp.remove(temp.size() - 1);
+			}
+		}
+	}
+	```

leetcode/429. N-ary Tree Level Order Traversal.md

@@ -0,0 +1,58 @@
+## 429. N-ary Tree Level Order Traversal
+
+### Question:
+Given an n-ary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).
+
+```
+We should return its level order traversal:
+[
+     [1],
+     [3,2,4],
+     [5,6]
+]
+```
+
+Note:
+1. The depth of the tree is at most 1000.
+2. The total number of nodes is at most 5000.
+
+### Solution:
+* Method 1: bfs
+    ```Java
+    /*
+    // Definition for a Node.
+    class Node {
+        public int val;
+        public List<Node> children;
+    
+        public Node() {}
+    
+        public Node(int _val,List<Node> _children) {
+            val = _val;
+            children = _children;
+        }
+    };
+    */
+    class Solution {
+        public List<List<Integer>> levelOrder(Node root) {
+            List<List<Integer>> result = new ArrayList<>();
+            if(root == null) return result;
+            Queue<Node> q = new LinkedList<>();
+            q.offer(root);
+            while(!q.isEmpty()){
+                List<Integer> temp = new ArrayList<>();
+                int size = q.size();
+                for(int i  = 0; i < size; i++){
+                    Node node = q.poll();
+                    temp.add(node.val);
+                    for(Node n : node.children){
+                        q.offer(n);
+                    }
+                }
+                result.add(temp);
+            }
+            return result;
+        }
+    }
+    ```
+   

leetcode/437. Path Sum III.md

@@ -0,0 +1,67 @@
+## 437. Path Sum III
+
+### Question:
+You are given a binary tree in which each node contains an integer value.
+
+Find the number of paths that sum to a given value.
+
+The path does not need to start or end at the root or a leaf, but it must go downwards (traveling only from parent nodes to child nodes).
+
+The tree has no more than 1,000 nodes and the values are in the range -1,000,000 to 1,000,000.
+
+```
+Example:
+
+root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8
+
+      10
+     /  \
+    5   -3
+   / \    \
+  3   2   11
+ / \   \
+3  -2   1
+
+Return 3. The paths that sum to 8 are:
+
+1.  5 -> 3
+2.  5 -> 2 -> 1
+3. -3 -> 11
+```
+
+
+### Solution:
+* Method 1: dfs + bfs
+    ```Java
+    /**
+     * Definition for a binary tree node.
+     * public class TreeNode {
+     *     int val;
+     *     TreeNode left;
+     *     TreeNode right;
+     *     TreeNode(int x) { val = x; }
+     * }
+     */
+    class Solution {
+        private int result;
+        public int pathSum(TreeNode root, int sum) {
+            if(root == null) return 0;
+            Queue<TreeNode> q = new LinkedList<>();
+            q.offer(root);
+            while(!q.isEmpty()){
+                TreeNode node = q.poll();
+                dfs(node, 0, sum);
+                if(node.left != null) q.offer(node.left);
+                if(node.right != null) q.offer(node.right);
+            }
+            return result;
+        }
+        private void dfs(TreeNode node, int cur, int sum){
+            if(node == null) return;
+            if(cur + node.val == sum) result++;
+            dfs(node.left, cur + node.val, sum);
+            dfs(node.right, cur + node.val, sum);
+        }
+    }
+    ```
+   

leetcode/872. Leaf-Similar Trees.md

@@ -0,0 +1,53 @@
+## 872. Leaf-Similar Trees
+
+### Question:
+Consider all the leaves of a binary tree.  From left to right order, the values of those leaves form a leaf value sequence.
+
+```
+For example, in the given tree above, the leaf value sequence is (6, 7, 4, 9, 8).
+
+Two binary trees are considered leaf-similar if their leaf value sequence is the same.
+
+Return true if and only if the two given trees with head nodes root1 and root2 are leaf-similar.
+```
+
+Note:
+* Both of the given trees will have between 1 and 100 nodes.
+
+### Solution:
+* Method 1: dfs
+    ```Java
+    /**
+     * Definition for a binary tree node.
+     * public class TreeNode {
+     *     int val;
+     *     TreeNode left;
+     *     TreeNode right;
+     *     TreeNode(int x) { val = x; }
+     * }
+     */
+    class Solution {
+        private List<Integer> leaves1;
+        private List<Integer> leaves2;
+        public boolean leafSimilar(TreeNode root1, TreeNode root2) {
+            this.leaves1 = new ArrayList<>();
+            this.leaves2 = new ArrayList<>();
+            dfs(root1, leaves1);
+            dfs(root2, leaves2);
+            if(leaves1.size() != leaves2.size()) return false;
+            for(int i = 0; i < leaves1.size(); i++){
+                if(leaves1.get(i) != leaves2.get(i)) return false;
+            }
+            return true;
+        }
+        private void dfs(TreeNode node, List<Integer> list){
+            if(node.left == null && node.right == null){
+                list.add(node.val);
+                return;
+            }
+            if(node.left != null) dfs(node.left, list);
+            if(node.right != null) dfs(node.right, list);
+        }
+    }
+    ```
+   

leetcode/965. Univalued Binary Tree.md

@@ -0,0 +1,52 @@
+## 965. Univalued Binary Tree
+
+### Question:
+A binary tree is univalued if every node in the tree has the same value.
+
+Return true if and only if the given tree is univalued.
+
+```
+Example 1:
+
+Input: [1,1,1,1,1,null,1]
+Output: true
+
+Example 2:
+
+Input: [2,2,2,5,2]
+Output: false
+```
+ 
+
+Note:
+1. The number of nodes in the given tree will be in the range [1, 100].
+2. Each node's value will be an integer in the range [0, 99].
+
+### Solution:
+* Method 1: dfs
+    ```Java
+    /**
+     * Definition for a binary tree node.
+     * public class TreeNode {
+     *     int val;
+     *     TreeNode left;
+     *     TreeNode right;
+     *     TreeNode(int x) { val = x; }
+     * }
+     */
+    class Solution {
+        private int pre;
+        public boolean isUnivalTree(TreeNode root) {
+            pre = root.val;
+            return check(root.left) && check(root.right);
+        }
+        private boolean check(TreeNode node){
+            if(node == null) return true;
+            else if(pre != node.val) return false;
+            else{
+                return check(node.left) && check(node.right);
+            }
+        }
+    }
+    ```
+