note

Author: guangxush

guangxu/202101/20210128.md

@@ -76,7 +76,7 @@ class Solution {
                 dp[i+1] += dp[i];
             }
             // 当前数字前一个数字可以组合对应一个字母
-            if(i-1 >= 0 && s.charAt(i)!='0' && Integer.parseInt(s.substring(i-1, i+1)) <= 26){
+            if(i-1 >= 0 && s.charAt(i-1)!='0' && Integer.parseInt(s.substring(i-1, i+1)) <= 26){
                 dp[i+1] += dp[i-1];
             }
         }

guangxu/202101/20210129.md

@@ -1,11 +1,121 @@
 ## Algorithm
 
+[94. Binary Tree Inorder Traversal](https://leetcode.com/problems/binary-tree-inorder-traversal/)
+
 ### Description
 
+Given the root of a binary tree, return the inorder traversal of its nodes' values.
+
+Example 1:
+
+![](assets/20210129-97802a7b.png)
+
+```
+Input: root = [1,null,2,3]
+Output: [1,3,2]
+```
+
+Example 2:
+
+```
+Input: root = []
+Output: []
+```
+
+Example 3:
+
+```
+Input: root = [1]
+Output: [1]
+```
+
+Example 4:
+
+![](assets/20210129-360b580d.png)
+
+```
+Input: root = [1,2]
+Output: [2,1]
+```
+
+Example 5:
+
+![](assets/20210129-1a3128aa.png)
+
+```
+Input: root = [1,null,2]
+Output: [1,2]
+```
+
+Constraints:
+
+- The number of nodes in the tree is in the range [0, 100].
+- -100 <= Node.val <= 100
+
+
+Follow up:
+
+Recursive solution is trivial, could you do it iteratively?
+
 ### Solution
 
-```java 
+非递归方法
+
+```java
+/**
+ * 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<Integer> inorderTraversal(TreeNode root) {
+        List<Integer> list = new ArrayList<Integer>();
+        Stack<TreeNode> stack = new Stack<TreeNode>();
+        while(root!=null || !stack.isEmpty()){
+            while(root!=null){
+                stack.push(root);
+                root = root.left;
+            }
+            root = stack.pop();
+            list.add(root.val);
+            root = root.right;
+        }
+        return list;
+    }
+}
+```
+
+递归方法
 
+```JAVA
+private List<Integer> list = new ArrayList<>();
+public List<Integer> inorderTraversal(TreeNode root) {
+    if(root==null){
+        return list;
+    }
+    inOrder(root);
+    return list;
+}
+private void inOrder(TreeNode root){
+   if(root.left!=null){
+      inOrder(root.left);
+   }
+   list.add(root.val);
+   if(root.right!=null){
+      inOrder(root.right);
+   }
+   return;
+}
 ```
 
 ### Discuss

guangxu/202101/assets/20210129-1a3128aa.png

@@ -1,5 +1,6 @@
 | 标题 | Algorithm | Review | Tip | Share|
 | :-----| :---- | :---- |  :---- |  :---- |
+| [20210129](./202101/20210129.md) |[94. Binary Tree Inorder Traversal(二叉树中序遍历)](https://leetcode.com/problems/binary-tree-inorder-traversal/)||||
 | [20210128](./202101/20210128.md) |[91. Decode Ways(动态规划解码方法)](https://leetcode.com/problems/decode-ways/)||||
 | [20210127](./202101/20210127.md) |[48. Rotate Image(图像旋转)](https://leetcode.com/problems/rotate-image)||||
 | [20210126](./202101/20210126.md) |[215. Kth Largest Element in an Array(数组中第K个最大元素)](https://leetcode.com/problems/kth-largest-element-in-an-array/)||||