binary tree & divide conqueer & dfs / bfs

Author: anduo

readme.md

@@ -184,6 +184,22 @@ doc中有好几份文档，比较经典，可以参考。
 
 # 刷题总结
 
+## chapter01 基础编程面试总结
+**面试考察的编程基本功**
+
+- 程序风格(缩进,括号,变量名)
+- Coding习惯(异常检查,边界处理)
+- 沟通(让面试官时刻明白你的意图)
+- 测试(主动写出合理的Testcase)
+
+**算法其实很简单**
+
+- 在刷题时,总结、归类相似题目
+- 找出适合同一类题目的模板程序
+
+**排列组合模板**
+
+
 ## chapter02 binary search & sorted array
 这一部分都可以使用bs模板来解决问题 [二分搜索模板](./src/template/bs_template.md)
 
@@ -221,4 +237,25 @@ doc中有好几份文档，比较经典，可以参考。
 3. Find Median in Two Sorted Array **find kth**
 4. Reverse in 3 steps
 
+## chapter03 Binary Tree & Divide Conquer & DFS/BFS
+
+*任何二叉树的问题都可以尝试使用分治法解决*
+
+二叉树的遍历问题，递归转为非递归的写法都是使用人工栈模拟系统栈的方式
+
+宽度优先遍历的方法
+- 2 Queues
+- 1 Queues + Dummy Node
+- 1 Queues(best)
+
+**参考模板** [dfs_template](./src/template/dfs_template.md)
+
+- [question01 binary tree preorder traversal](./src/ninechapter/ch03_binary_tree_and_divide_conquer_and_dfs_bfs/Question01BinaryTreePreorderTraversal.java)
+- [question02 maximum depth of binary tree](./src/ninechapter/ch03_binary_tree_and_divide_conquer_and_dfs_bfs/Question02MaximumDepthOfBinaryTree.java)
+- [question03 balanced binary tree](./src/ninechapter/ch03_binary_tree_and_divide_conquer_and_dfs_bfs/Question03BalancedBinaryTree.java)
+- [question04 binary tree maximum path sum](./src/ninechapter/ch03_binary_tree_and_divide_conquer_and_dfs_bfs/Question04BinaryTreeMaximumPathSum.java)
+
+
+
+
 

src/ninechapter/ch01/Question01StrStr.java

@@ -0,0 +1,32 @@
+package ninechapter.ch01;
+
+/**
+ * Created by anduo on 17-3-13.
+ */
+public class Question01StrStr {
+
+    // 模式匹配算法总结 http://dsqiu.iteye.com/blog/1700312
+    // 需要知道概念和原理
+    public int strStr(String source, String target) {
+        if (source == null || target == null) {
+            return -1;
+        }
+        int i, j;
+
+        // source最多比较的字符个数应该是 len(source) - len(target)
+        int range = source.length() - target.length();
+        for (i = 0; i < range; i++) {
+            for (j = 0; j < target.length(); j++) {
+                // 如果存在滑动窗口内的对应位置元素不相同，就将source的字符往下移动
+                if (source.charAt(i + j) != target.charAt(j)) {
+                    break;
+                }
+            }
+            if (j == target.length()) {// 全部匹配完成
+                return i;
+            }
+        }
+
+        return -1;
+    }
+}

src/ninechapter/ch01/Question02SubSets.java

@@ -0,0 +1,75 @@
+package ninechapter.ch01;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+/**
+ * Created by anduo on 17-3-13.
+ */
+public class Question02SubSets {
+
+    public ArrayList<ArrayList<Integer>> subsets(int[] nums) {
+        ArrayList<ArrayList<Integer>> result = new ArrayList<>();
+        if (nums == null || nums.length == 0) {
+            return result;
+        }
+        ArrayList<Integer> list = new ArrayList<>();
+
+        // 先把集合排序 nlog(n)
+        Arrays.sort(nums);
+
+        dfs(result, list, nums, 0);
+        return result;
+    }
+
+    /**
+     * 构造子集合
+     *
+     * @param result
+     * @param list
+     * @param num
+     * @param pos
+     */
+    private void dfs(ArrayList<ArrayList<Integer>> result,
+                     ArrayList<Integer> list,
+                     int[] num,
+                     int pos) {
+        result.add(new ArrayList<>(list));
+        // 从nums的pos位置开始，先把自己加进去，然后把自己的子集合加进去
+        for (int i = pos; i < num.length; i++) {
+            list.add(num[i]);
+            dfs(result, list, num, i + 1);
+            list.remove(list.size() - 1);// 需要移除最后一个元素
+        }
+    }
+
+
+    // 非递归解法
+    public ArrayList<ArrayList<Integer>> subsetsNoRecursion(int[] nums) {
+        ArrayList<ArrayList<Integer>> result = new ArrayList<>();
+        int n = nums.length;
+        Arrays.sort(nums);
+
+        // 1 << n is 2^n
+        // each subset equals to an binary integer between 0 .. 2^n - 1
+        // 0 -> 000 -> []
+        // 1 -> 001 -> [1]
+        // 2 -> 010 -> [2]
+        // ..
+        // 7 -> 111 -> [1,2,3]
+
+        int total = 1 << n;// 一共有2^n个子集合
+        for (int i = 0; i < total; i++) {
+            ArrayList<Integer> subset = new ArrayList<>();
+            for (int j = 0; j < n; j++) {
+                // check whether the jth digit in i's binary representation is 1
+                if ((i & (1 << j)) != 0) {
+                    subset.add(nums[j]);
+                }
+            }
+            result.add(subset);
+        }
+
+        return result;
+    }
+}

src/ninechapter/ch03_binary_tree_and_divide_conquer_and_dfs_bfs/Question01BinaryTreePreorderTraversal.java

@@ -0,0 +1,84 @@
+package ninechapter.ch03_binary_tree_and_divide_conquer_and_dfs_bfs;
+
+import entity.TreeNode;
+
+import java.util.ArrayList;
+import java.util.Stack;
+
+//    1
+//     \
+//      2
+//     /
+//    3
+// result: 1->2->3
+
+/**
+ * http://www.lintcode.com/problem/binary-tree-preorder-traversal
+ * 二叉树的前序遍历
+ * Created by anduo on 17-3-13.
+ */
+public class Question01BinaryTreePreorderTraversal {
+    // 非递归算法 Non-Recursion (Recommend)
+    public ArrayList<Integer> preorderTraversal1(TreeNode root) {
+        ArrayList<Integer> result = new ArrayList<>();
+        if (root == null) {
+            return result;
+        }
+        Stack<TreeNode> stack = new Stack<>();
+        stack.push(root);
+        while (!stack.empty()) {
+            TreeNode node = stack.pop();
+            result.add(node.val);
+            if (node.left != null) {
+                stack.push(node.left);
+            }
+            if (node.right != null) {
+                stack.push(node.right);
+            }
+        }
+        return result;
+    }
+
+    // version2 递归解法
+    public ArrayList<Integer> preorderTraversal2(TreeNode root) {
+        ArrayList<Integer> result = new ArrayList<>();
+        if (root == null) {
+            return result;
+        }
+        traverse(root, result);
+        return result;
+    }
+
+    private void traverse(TreeNode root, ArrayList<Integer> result) {
+        if (root == null) return;
+        result.add(root.val);
+        traverse(root.left, result);
+        traverse(root.right, result);
+    }
+
+    /***************************************************************/
+    // version3 : divide & conquer
+    // 分治法
+    // Merge Sort:局部有序，然后整体有序
+    // Quick Sort:整体有序，然后局部有序
+    // Most of the Binary Tree Problem！
+    public ArrayList<Integer> preorderTraversal3(TreeNode root) {
+        ArrayList<Integer> result = new ArrayList<>();
+        if (root == null) {
+            return result;
+        }
+
+        // Divide
+        ArrayList<Integer> left = preorderTraversal3(root.left);
+        ArrayList<Integer> right = preorderTraversal3(root.right);
+
+        // Conquer
+        result.add(root.val);
+        result.addAll(left);
+        result.addAll(right);
+        return result;
+
+
+    }
+
+}

src/ninechapter/ch03_binary_tree_and_divide_conquer_and_dfs_bfs/Question02MaximumDepthOfBinaryTree.java

@@ -0,0 +1,31 @@
+package ninechapter.ch03_binary_tree_and_divide_conquer_and_dfs_bfs;
+
+import entity.TreeNode;
+
+//二叉树的最大深度
+//   1
+//  / \
+// 2   3
+//    / \
+//   4   5
+
+/**
+ * http://www.lintcode.com/problem/maximum-depth-of-binary-tree
+ * <p>
+ * Created by anduo on 17-3-13.
+ */
+public class Question02MaximumDepthOfBinaryTree {
+
+    public int maxDepth(TreeNode root) {
+        if (root == null) return 0;
+        if (root.left == null && root.right == null) {
+            return 1;
+        }
+        // 分治法
+        int leftDepth = maxDepth(root.left);
+        int rightDepth = maxDepth(root.right);
+        return Math.max(leftDepth, rightDepth) + 1;
+    }
+
+
+}

src/ninechapter/ch03_binary_tree_and_divide_conquer_and_dfs_bfs/Question03BalancedBinaryTree.java

@@ -0,0 +1,38 @@
+package ninechapter.ch03_binary_tree_and_divide_conquer_and_dfs_bfs;
+
+// <h1>平衡二叉树</h1>
+// 给定一个二叉树,确定它是高度平衡的。
+// 对于这个问题,一棵高度平衡的二叉树的定义是：
+// 一棵二叉树中每个节点的两个子树的深度相差不会超过1。
+//     A)  3             B)   3
+//        / \                  \
+//       9  20                 20
+//         /  \                / \
+//        15   7              15  7
+// 二叉树A是高度平衡的二叉树，但是B不是
+
+import entity.TreeNode;
+
+/**
+ * http://www.lintcode.com/zh-cn/problem/balanced-binary-tree/
+ * Created by anduo on 17-3-13.
+ */
+public class Question03BalancedBinaryTree {
+    /**
+     * @param root: The root of binary tree.
+     * @return: True if this Binary tree is Balanced, or false.
+     */
+    public boolean isBalanced(TreeNode root) {
+        return height(root) != -1;
+    }
+
+    private int height(TreeNode root) {
+        if (root == null) return 0;
+        int leftHeight = height(root.left);
+        int rightHeight = height(root.right);
+        if (leftHeight == -1 || rightHeight == -1 || Math.abs(leftHeight - rightHeight) > 1) {
+            return -1;
+        }
+        return Math.max(leftHeight, rightHeight) + 1;
+    }
+}

src/ninechapter/ch03_binary_tree_and_divide_conquer_and_dfs_bfs/Question04BinaryTreeMaximumPathSum.java

@@ -0,0 +1,64 @@
+package ninechapter.ch03_binary_tree_and_divide_conquer_and_dfs_bfs;
+
+// 二叉树中的最大路径和
+// 给出一棵二叉树，寻找一条路径使其路径和最大，
+// 路径可以在任一节点中开始和结束（路径和为两个节点之间所在路径上的节点权值之和）
+//      1
+//     / \
+//    2   3
+// 返回 6
+
+import entity.TreeNode;
+
+import static java.lang.Math.max;
+
+/**
+ * http://www.lintcode.com/zh-cn/problem/binary-tree-maximum-path-sum/
+ * Created by anduo on 17-3-13.
+ */
+// TODO(分治法的最高境界)
+public class Question04BinaryTreeMaximumPathSum {
+
+    private class ResultType {
+        // singlePath: 从root往下走到任意点的最大路径，这条路径可以不包含任何点
+        // maxPath: 从树中任意到任意点的最大路径，这条路径至少包含一个点
+        int singlePath, maxPath;
+
+        ResultType(int singlePath, int maxPath) {
+            this.singlePath = singlePath;
+            this.maxPath = maxPath;
+        }
+    }
+
+    private ResultType help(TreeNode root) {
+        if (root == null) {// 极端情况
+            return new ResultType(0, Integer.MIN_VALUE);
+        }
+        // Divide
+        ResultType left = help(root.left);
+        ResultType right = help(root.right);
+
+        // Conquer
+        // 合并从root开始往下走的路径和
+        int singlePath = max(left.singlePath, right.singlePath) + root.val;
+        singlePath = max(singlePath, 0);
+
+        // 当前节点到左右子树的最大路径
+        int maxPath = max(left.maxPath, right.maxPath);
+        // 当前节点跨根节点的最大路径
+        maxPath = max(maxPath, left.singlePath + right.singlePath + root.val);
+
+        return new ResultType(singlePath, maxPath);
+    }
+
+    public int maxPathSum(TreeNode root) {
+        // 分治法
+        // 三种情况：
+        // 1、左子树
+        // 2、右子树
+        // 3、跨根节点
+
+        ResultType result = help(root);
+        return result.maxPath;
+    }
+}