提交94,145,144,104

Author: MistRay

leetcode/src/main/java/com/mistray/tree/BalancedBinaryTree110.java

@@ -0,0 +1,11 @@
+package com.mistray.tree;
+
+/**
+ * @author ZJY(MistRay)
+ * @Project algorithm-study
+ * @Package com.mistray.tree
+ * @create 2020年03月06日 16:26
+ * @Desc
+ */
+public class BalancedBinaryTree110 {
+}

leetcode/src/main/java/com/mistray/tree/BinaryTreeInorderTraversal94.java

@@ -0,0 +1,57 @@
+package com.mistray.tree;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
+/**
+ * @author ZJY(MistRay)
+ * @Project algorithm-study
+ * @Package com.mistray.tree
+ * @create 2020年03月06日 13:54
+ * @Desc
+ */
+public class BinaryTreeInorderTraversal94 {
+
+
+    public static void main(String[] args) {
+        TreeNode root = new TreeNode(1);
+        root.right = new TreeNode(2);
+        root.right.left = new TreeNode(3);
+        BinaryTreeInorderTraversal94 bin = new BinaryTreeInorderTraversal94();
+        List<Integer> integers = bin.inorderTraversal(root);
+
+    }
+
+    public List<Integer> inorderTraversal(TreeNode root) {
+        List<Integer> list = new ArrayList<>();
+        Stack<TreeNode> stack = new Stack<>();
+        while (stack.size() > 0 || root != null) {
+            if (root != null) {
+                stack.add(root);
+                root = root.left;
+            } else {
+                TreeNode pop = stack.pop();
+                list.add(pop.val);
+                root = pop.right;
+            }
+        }
+        return list;
+    }
+
+    public List<Integer> inorderTraversal2(TreeNode root) {
+        List<Integer> list = new ArrayList<>();
+        helper(root, list);
+        return list;
+    }
+
+
+    public void helper(TreeNode root, List<Integer> list) {
+        if (root == null) {
+            return;
+        }
+        helper(root.left, list);
+        list.add(root.val);
+        helper(root.right, list);
+    }
+}

leetcode/src/main/java/com/mistray/tree/BinaryTreePostorderTraversal145.java

@@ -0,0 +1,36 @@
+package com.mistray.tree;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
+/**
+ * @author ZJY(MistRay)
+ * @Project algorithm-study
+ * @Package com.mistray.tree
+ * @create 2020年03月06日 14:47
+ * @Desc
+ */
+public class BinaryTreePostorderTraversal145 {
+    public List<Integer> postorderTraversal(TreeNode root) {
+        List<Integer> list = new ArrayList<>();
+        Stack<TreeNode> stack1 = new Stack<>();
+        Stack<TreeNode> stack2 = new Stack<>();
+        stack1.add(root);
+        while (stack1.size() > 0) {
+            TreeNode pop = stack1.pop();
+            stack2.add(pop);
+            if (pop.left != null) {
+                stack1.add(pop.left);
+            }
+            if (pop.right != null) {
+                stack1.add(pop.right);
+            }
+        }
+
+        while (stack2.size() > 0) {
+            list.add(stack2.pop().val);
+        }
+        return list;
+    }
+}

leetcode/src/main/java/com/mistray/tree/BinaryTreePreorderTraversal144.java

@@ -0,0 +1,30 @@
+package com.mistray.tree;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author ZJY(MistRay)
+ * @Project algorithm-study
+ * @Package com.mistray.tree
+ * @create 2020年03月06日 14:42
+ * @Desc
+ */
+public class BinaryTreePreorderTraversal144 {
+
+
+    public List<Integer> preorderTraversal(TreeNode root) {
+        List<Integer> list = new ArrayList<>();
+        helper(root,list);
+        return list;
+    }
+
+    public void helper(TreeNode node, List<Integer> list) {
+        if (node == null){
+            return;
+        }
+        list.add(node.val);
+        helper(node.left,list);
+        helper(node.right,list);
+    }
+}

leetcode/src/main/java/com/mistray/tree/MaximumDepthOfBinaryTree104.java

@@ -0,0 +1,39 @@
+package com.mistray.tree;
+
+/**
+ * @author ZJY(MistRay)
+ * @Project algorithm-study
+ * @Package com.mistray.tree
+ * @create 2020年03月06日 11:39
+ * @Desc
+ */
+public class MaximumDepthOfBinaryTree104 {
+
+    public int maxDepth(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        return max(root, 0, 0);
+    }
+
+    // 获取当前树的最大深度
+    public int max(TreeNode node, int level, int maxLevel) {
+        // 当前深度+1
+        int curLevel = level + 1;
+        // 当前深度如果比最大深度要大的话,更新最大深度
+        if (curLevel > maxLevel) {
+            maxLevel = curLevel;
+        }
+        // 如果当前节点的左节点不为空的话递归,直到左节点的尽头
+        if (node.left != null) {
+            maxLevel = max(node.left, curLevel, maxLevel);
+        }
+        // 第一次执行时到这里时,为左节点的尽头,已经没有更左的节点
+        if (node.right != null) {
+            maxLevel = max(node.right, curLevel, maxLevel);
+        }
+        return maxLevel;
+    }
+
+
+}