[Function add]: 1.Add leetcode solutions.

Author: Botao Xiao

README.md

@@ -427,6 +427,10 @@
 
 [242. Valid Anagram](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/242.%20Valid%20Anagram.md)
 
+[257. Binary Tree Paths](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/257.%20Binary%20Tree%20Paths.md)
+
+[258. Add Digits](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/258.%20Add%20Digits.md)
+
 ## Algorithm(4th_Edition)
 Reading notes of book Algorithm(4th Algorithm),ISBN: 9787115293800.
 All java realization codes are placed in different packages.

leetcode/257. Binary Tree Paths.md

@@ -53,4 +53,52 @@ class Solution {
         }
     }
 }
-```
+```
+
+### Second time
+1. I still used bfs to solve this question. However, using list instead of StringBuilder is faster.
+```Java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    private String arrow = "->";
+    public List<String> binaryTreePaths(TreeNode root) {
+        List<String> result = new LinkedList<>();
+        if(root == null) return result;
+        addPath(result, new LinkedList<Integer>(), root);
+        return result;
+    }
+    private void addPath(List<String> result, List<Integer> temp, TreeNode node){
+        temp.add(node.val);
+        if(node.left == null && node.right == null){
+            if(temp.size() == 0) return;
+            else if(temp.size() == 1){
+                result.add("" + temp.get(0));
+            }else{
+                StringBuilder sb = new StringBuilder();
+                sb.append(temp.get(0));
+                for(int i = 1; i < temp.size(); i++){
+                    sb.append(this.arrow);
+                    sb.append(temp.get(i));
+                }
+                result.add(sb.toString());
+            }
+        }else{
+            if(node.left != null){
+                addPath(result, temp, node.left);
+            }
+            if(node.right != null){
+                addPath(result, temp, node.right);
+            }
+        }
+        temp.remove(temp.size() - 1);
+    }
+}
+```

leetcode/258. Add Digits.md

@@ -7,8 +7,8 @@ Given a non-negative integer num, repeatedly add all its digits until the result
 Example:
 
 Input: 38
-Output: 2 
-Explanation: The process is like: 3 + 8 = 11, 1 + 1 = 2. 
+Output: 2
+Explanation: The process is like: 3 + 8 = 11, 1 + 1 = 2.
              Since 2 has only one digit, return it.
 ```
 
@@ -38,4 +38,20 @@ class Solution {
         return (num - 1)%9 + 1;
     }
 }
-```
+```
+
+### Second time
+1. Recursion
+```Java
+class Solution {
+    public int addDigits(int num) {
+        if(num <= 9) return num;
+        int sum = 0;
+        while(num > 0){
+            sum += num % 10;
+            num /= 10;
+        }
+        return addDigits(sum);
+    }
+}
+```