construct tree

Author: idf

src/BinaryTreeZigzagLevelOrderTraversal/Solution.java

@@ -0,0 +1,62 @@
+package BinaryTreeZigzagLevelOrderTraversal;
+
+import commons.datastructures.TreeNode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * User: Danyang
+ * Date: 1/27/2015
+ * Time: 16:37
+ *
+ * Given a binary tree, return the zigzag level order traversal of its nodes' values. (ie, from left to right, then
+ * right to left for the next level and alternate between).
+
+ For example:
+ Given binary tree {3,9,20,#,#,15,7},
+ 3
+ / \
+ 9  20
+ /  \
+ 15   7
+ return its zigzag level order traversal as:
+ [
+ [3],
+ [20,9],
+ [15,7]
+ ]
+ */
+public class Solution {
+    /**
+     * bfs
+     * @param root
+     * @return
+     */
+    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
+        List<List<Integer>> ret = new ArrayList<>();
+        List<TreeNode> q = new ArrayList<>();
+        if(root==null)
+            return ret;
+        TreeNode cur = root;
+        q.add(cur);
+        boolean obverse = true;
+        while(!q.isEmpty()) {
+            int l = q.size();
+            List<Integer> level = new ArrayList<>();
+            for(int i=0; i<l; i++) {
+                cur = q.get(i);
+                if(obverse)
+                    level.add(cur.val);
+                else
+                    level.add(0, cur.val);
+                if(cur.left!=null) q.add(cur.left);
+                if(cur.right!=null) q.add(cur.right);
+            }
+            ret.add(level);
+            obverse = !obverse;
+            q = q.subList(l, q.size());
+        }
+        return ret;
+    }
+}

src/ConstructBinaryTreefromInorderandPostorderTraversal/Solution.java

@@ -0,0 +1,41 @@
+package ConstructBinaryTreefromInorderandPostorderTraversal;
+
+import commons.datastructures.TreeNode;
+
+/**
+ * User: Danyang
+ * Date: 1/27/2015
+ * Time: 17:10
+ *
+ * Given inorder and postorder traversal of a tree, construct the binary tree.
+
+ Note:
+ You may assume that duplicates do not exist in the tree.
+
+ */
+public class Solution {
+    /**
+     * inorder: L c R
+     * postorder: L R c
+     * @param inorder
+     * @param postorder
+     * @return
+     */
+    public TreeNode buildTree(int[] inorder, int[] postorder) {
+        return buildTree(inorder, 0, inorder.length, postorder, 0, postorder.length);
+    }
+
+    TreeNode buildTree(int[] in, int s1, int e1, int[] post, int s2, int e2) {
+        if(s1>=e1 || s2>=e2)
+            return null;
+        TreeNode root = new TreeNode(post[e2-1]);
+        int i;
+        for(i=s1; i<e1 && in[i]!=root.val; i++);
+        int len_l = i-s1;
+        TreeNode l = buildTree(in, s1, i, post, s2, s2+len_l);
+        TreeNode r = buildTree(in, i+1, e1, post, s2+len_l, e2-1);
+        root.left = l;
+        root.right = r;
+        return root;
+    }
+}

src/ConstructBinaryTreefromPreorderandInorderTraversal/Solution.java

@@ -0,0 +1,40 @@
+package ConstructBinaryTreefromPreorderandInorderTraversal;
+
+import commons.datastructures.TreeNode;
+
+/**
+ * User: Danyang
+ * Date: 1/27/2015
+ * Time: 16:50
+ *
+ * Given preorder and inorder traversal of a tree, construct the binary tree.
+
+ Note:
+ You may assume that duplicates do not exist in the tree.
+ */
+public class Solution {
+    /**
+     * preorder c L R
+     * inorder L c R
+     * @param preorder
+     * @param inorder
+     * @return
+     */
+    public TreeNode buildTree(int[] preorder, int[] inorder) {
+        return buildTree(preorder, 0, preorder.length, inorder, 0, inorder.length);
+    }
+
+    TreeNode buildTree(int[] preorder, int s1, int e1, int[] inorder, int s2, int e2) {
+        if(s1>=e1 || s2>=e2)
+            return null;
+        TreeNode root = new TreeNode(preorder[s1]);
+        int i = s2;
+        for(; i<e2 && inorder[i]!=root.val; i++);
+        int len_l = i-s2;
+        TreeNode l = buildTree(preorder, s1+1, s1+1+len_l, inorder, s2, i);
+        TreeNode r = buildTree(preorder, s1+1+len_l, e1, inorder, i+1, e2);
+        root.left = l;
+        root.right = r;
+        return root;
+    }
+}

src/ConvertSortedArraytoBinarySearchTree/Solution.java

@@ -0,0 +1,28 @@
+package ConvertSortedArraytoBinarySearchTree;
+
+import commons.datastructures.TreeNode;
+
+/**
+ * User: Danyang
+ * Date: 1/27/2015
+ * Time: 16:46
+ *
+ * Given an array where elements are sorted in ascending order, convert it to a height balanced BST.
+ */
+public class Solution {
+    public TreeNode sortedArrayToBST(int[] num) {
+        return toBST(num, 0, num.length);
+    }
+
+    TreeNode toBST(int[] num, int s, int e) {
+        if(s>=e)
+            return  null;
+        int m = (s+e)/2;
+        TreeNode cur = new TreeNode(num[m]);
+        TreeNode l = toBST(num, s, m);
+        TreeNode r = toBST(num, m+1, e);
+        cur.left = l;
+        cur.right = r;
+        return cur;
+    }
+}