20181230

Author: mJackie

code/lc144.java

@@ -0,0 +1,37 @@
+package code;
+/*
+ * 144. Binary Tree Preorder Traversal
+ * 题意：二叉树先序遍历
+ * 难度：Medium
+ * 分类：Stack, Tree
+ * 思路：左节点依次入栈
+ * Tips：和lc94中序,lc145后序一起看
+ */
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
+public class lc144 {
+    public class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+        TreeNode(int x) { val = x; }
+    }
+    public List<Integer> inorderTraversal(TreeNode root) {
+        List<Integer> res = new ArrayList<>();
+        if(root==null)
+            return res;
+        Stack<TreeNode> st = new Stack();
+        while( !st.isEmpty() || root!=null ) {      //注意停止条件
+            while (root != null) {
+                st.push(root);
+                res.add(root.val);
+                root = root.left;
+            }
+            root = st.pop();
+            root = root.right;
+        }
+        return res;
+    }
+}

code/lc145.java

@@ -0,0 +1,38 @@
+package code;
+/*
+ * 145. Binary Tree Postorder Traversal
+ * 题意：二叉树后序遍历
+ * 难度：Hard
+ * 分类：Stack, Tree
+ * 思路：调整的先序遍历，再反转结果
+ */
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Stack;
+
+public class lc145 {
+    public class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+        TreeNode(int x) { val = x; }
+    }
+    public List<Integer> postorderTraversal(TreeNode root) {
+        ArrayList<Integer> res = new ArrayList();
+        if(root==null)
+            return res;
+        Stack<TreeNode> st = new Stack();
+        while(!st.isEmpty()||root!=null){
+            while(root!=null) {
+                st.add(root);
+                res.add(root.val);
+                root = root.right;  //先遍历右节点
+            }
+            root = st.pop();
+            root =root.left;        //再左节点
+        }
+        Collections.reverse(res);   //反转链表
+        return res;
+    }
+}

code/lc94.java

@@ -0,0 +1,37 @@
+package code;
+/*
+ * 94. Binary Tree Inorder Traversal
+ * 题意：二叉树中序遍历
+ * 难度：Medium
+ * 分类：HashTable, Stack, Tree
+ * 思路：左节点依次入栈
+ * Tips：和lc144前序,lc145后序一起看
+ */
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
+public class lc94 {
+    public class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+        TreeNode(int x) { val = x; }
+    }
+    public List<Integer> inorderTraversal(TreeNode root) {
+        List<Integer> res = new ArrayList<>();
+        if(root==null)
+            return res;
+        Stack<TreeNode> st = new Stack();
+        while( !st.isEmpty() || root!=null ) {      //注意停止条件
+            while (root != null) {
+                st.push(root);
+                root = root.left;
+            }
+            root = st.pop();
+            res.add(root.val);
+            root = root.right;
+        }
+        return res;
+    }
+}

code/lc96.java

@@ -0,0 +1,27 @@
+package code;
+/*
+ * 96. Unique Binary Search Trees
+ * 题意：给定n，多少棵二叉搜索树，1~n
+ * 难度：Medium
+ * 分类：Dynamic Programming, Tree
+ * 思路：1~n都可以做根节点，分成左右两个子问题 dp[i] * dp[n-1-i]
+ * Tips：
+ */
+public class lc96 {
+    public static void main(String[] args) {
+        System.out.println(numTrees(3));
+    }
+    public static int numTrees(int n) {
+        if(n<2)
+            return 1;
+        int[] dp = new int[n+1];
+        dp[0] = 1;
+        dp[1] = 1;
+        for (int i = 2; i < n+1; i++) {
+            for (int j = 0; j <i ; j++) {
+                dp[i] += dp[j] * dp[i-1-j];
+            }
+        }
+        return dp[n];
+    }
+}

code/lc98.java

@@ -0,0 +1,55 @@
+package code;
+/*
+ * 98. Validate Binary Search Tree
+ * 题意：判断是否为二叉搜索树
+ * 难度：Medium
+ * 分类：Tree, Depth-first Search
+ * 思路：两种方法，一种递归；另一种中序遍历的思路；
+ * Tips：递归时注意设置最大最小两个参数，因为节点间val限制会传递的
+ */
+import java.util.Stack;
+
+public class lc98 {
+    public static void main(String[] args) {
+        TreeNode tn1 = new TreeNode(0);
+        tn1.left = new TreeNode(-1);
+        //System.out.println(isValidBST(tn1));
+        System.out.println(isValidBST2(tn1));
+    }
+    public static class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+        TreeNode(int x) { val = x; }
+    }
+    public static boolean isValidBST(TreeNode root) {
+        if(root==null)
+            return true;
+        return dfs(root, -Double.MAX_VALUE, Double.MAX_VALUE);  // 注意Double.MIN_VALUE是接近0的正数
+    }
+    public static boolean dfs(TreeNode root, double min_bound, double max_bound){   //设置两个参数，一个最大值，一个最小值
+        if (root == null) return true;
+        if (root.val >= max_bound || root.val <= min_bound) return false;
+        return dfs(root.left, min_bound, root.val) && dfs(root.right, root.val, max_bound);
+    }
+
+    public static boolean isValidBST2(TreeNode root) {
+        if(root == null)
+            return true;
+        Stack<TreeNode> st = new Stack();
+        TreeNode pre = null;
+        while( !st.isEmpty() || root!=null ){
+            while(root!=null){
+                st.add(root);
+                root = root.left;
+            }
+            root = st.pop();
+            if( pre!=null && root.val<=pre.val )    //先序遍历，自下而上，孩子节点小于父节点
+                return false;
+            pre = root;
+            root = root.right;
+        }
+        return true;
+    }
+
+}