random, intervals

Author: rchen102

JZOffer/JZ 44.java renamed to JZandNC/JZ 44.java

@@ -0,0 +1,22 @@
+// 判断是否是完全二叉树
+public boolean isCBST(TreeNode root) {
+    if (root == null) return true;
+    Queue<TreeNode> queue = new LinkedList<>();
+    queue.offer(root);
+    while (!queue.isEmpty()) {
+        int size = queue.size();
+        boolean findNULL = false;
+        for (int i = 0; i < size; i++) {
+            TreeNode cur = queue.poll();
+            if (cur == null) {
+                findNULL = true;
+            }
+            else {
+                if (findNULL) return false;
+                queue.offer(cur.left);
+                queue.offer(cur.right);
+            }
+        }
+    }
+    return true;
+}

JZOffer/JZ 60.java renamed to JZandNC/JZ 60.java

@@ -0,0 +1,18 @@
+public class Solution {
+    public int nodeNum(TreeNode head) {
+        if (head == null) return 0;
+        int leftH = getHeight(head.left);
+        int rightH = getHeight(head.right);
+        if (leftH > rightH) {
+            return (int)Math.pow(2, rightH) - 1 + 1 + nodeNum(head.left);
+        }
+        else {
+            return (int)Math.pow(2, leftH) - 1 + 1 + nodeNum(head.right);
+        }
+    }
+
+    public int getHeight(TreeNode cur) {
+        if (cur == null) return 0;
+        return 1 + getHeight(cur.left);
+    }
+}

JZandNC/NC 60.java

@@ -8,23 +8,23 @@
  * }
  */
 
-//Solution1: BFS iterative  T： O(n) S: O(n) (node: (n+1) / 2)
+// Solution1: BFS iterative  T： O(n) S: O(n) (node: (n+1) / 2)
 class Solution {
     public List<List<Integer>> levelOrder(TreeNode root) {
         List<List<Integer>> res = new LinkedList<>();
+        if (root == null) return res;
         Queue<TreeNode> queue = new LinkedList<>();
-        if(root == null) return res;
         queue.offer(root);
-        while(!queue.isEmpty()) {
-            int len = queue.size();
-            List<Integer> tmp = new LinkedList<>();
-            for(int i = 0; i < len; i++) {
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            List<Integer> level = new LinkedList<>();
+            for (int i = 0; i < size; i++) {
                 TreeNode cur = queue.poll();
-                tmp.add(cur.val);
-                if(cur.left != null) queue.offer(cur.left);
-                if(cur.right != null) queue.offer(cur.right);
+                level.add(cur.val);
+                if (cur.left != null) queue.offer(cur.left);
+                if (cur.right != null) queue.offer(cur.right);
             }
-            res.add(tmp);
+            res.add(level);
         }
         return res;
     }

JZandNC/NC 84.java

@@ -0,0 +1,57 @@
+// Solution: post-order recursive
+class Solution {
+
+    int res;
+
+    public int maxPathSum(TreeNode root) {
+        if (root == null) return 0;
+        res = root.val;
+        maxPathEndWith(root);
+        return res;
+    }
+
+    int maxPathEndWith(TreeNode cur) {
+        if (cur == null) return 0;
+        int left = Math.max(0, maxPathEndWith(cur.left));
+        int right = Math.max(0, maxPathEndWith(cur.right));
+        int maxPath = left + right + cur.val;
+        res = Math.max(res, maxPath);
+        return Math.max(left, right) + cur.val;
+    }
+}
+
+
+// Solution: post-order iterative
+class Solution {
+    public int maxPathSum(TreeNode root) {
+        if (root == null) return 0;
+        Stack<TreeNode> stack = new Stack<>();
+        HashMap<TreeNode, Integer> map = new HashMap<>();
+        HashMap<TreeNode, Integer> pathEnd = new HashMap<>();
+        stack.push(root);
+        map.put(root, 1);
+        int res = root.val;
+        while (!stack.isEmpty()) {
+            TreeNode cur = stack.pop();
+            if (map.get(cur) == 0) {
+                int left = cur.left == null ? 0 : Math.max(0, pathEnd.get(cur.left));
+                int right = cur.right == null ? 0 : Math.max(0, pathEnd.get(cur.right));
+                res = Math.max(res, left + right + cur.val);
+                pathEnd.put(cur, Math.max(left, right) + cur.val);
+            }
+            else {
+                stack.push(cur);
+                map.put(cur, 0);
+                if (cur.right != null) {
+                    stack.push(cur.right);
+                    map.put(cur.right, 1);
+                }
+                if (cur.left != null) {
+                    stack.push(cur.left);
+                    map.put(cur.left, 1);
+                }
+            }
+        }
+        return res;
+    }
+}