Merge pull request haoel#71 from lei-cao/master

Java version

Author: haoel

.gitignore

@@ -0,0 +1,2 @@
+.idea
+algorithms-java/out

README.md

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="module-library">
+      <library>
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/junit-4.7.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+  </component>
+</module>

algorithms-java/algorithms-java.iml

@@ -0,0 +1,13 @@
+package balancedBinaryTree;
+
+/**
+ * Created by leicao on 5/10/15.
+ */
+public class TreeNode {
+    public int val;
+    public TreeNode left, right;
+    public TreeNode(int val) {
+        this.val = val;
+        this.left = this.right = null;
+    }
+}

algorithms-java/junit-4.7.jar

@@ -0,0 +1,57 @@
+// Source : https://oj.leetcode.com/problems/balanced-binary-tree/
+// Inspired by : http://www.jiuzhang.com/solutions/balanced-binary-tree/
+// Author : Lei Cao
+// Date   : 2015-10-07
+
+/**********************************************************************************
+ *
+ * Given a binary tree, determine if it is height-balanced.
+ *
+ * For this problem, a height-balanced binary tree is defined as a binary tree in which
+ * the depth of the two subtrees of every node never differ by more than 1.
+ * Example
+ * Given binary tree A={3,9,20,#,#,15,7}, B={3,#,20,15,7}
+ * The binary tree A is a height-balanced binary tree, but B is not.
+ **********************************************************************************/
+
+package balancedBinaryTree;
+
+/**
+ * Created by leicao on 7/10/15.
+ */
+public class balancedBinaryTree {
+    /**
+     * @param root: The root of binary tree.
+     * @return: True if this Binary tree is Balanced, or false.
+     */
+    public boolean isBalanced(TreeNode root) {
+        // write your code here
+        return helper(root, 0).isBalanced;
+    }
+
+    // This is not needed. Can just check the depth
+    private class Result {
+        boolean isBalanced;
+        int height;
+        Result(boolean isBalanced, int height) {
+            this.isBalanced = isBalanced;
+            this.height = height;
+        }
+    }
+    private Result helper(TreeNode root, int depth) {
+        if (root == null) {
+            return new Result(true, depth);
+        }
+        Result left = helper(root.left, depth + 1);
+        Result right = helper(root.right, depth + 1);
+
+        if (!left.isBalanced || !right.isBalanced) {
+            return new Result(false, 0);
+        }
+
+        if (Math.abs(left.height - right.height) > 1) {
+            return new Result(false, 0);
+        }
+        return new Result(true, Math.max(left.height, right.height));
+    }
+}

algorithms-java/src/balancedBinaryTree/TreeNode.java

@@ -0,0 +1,43 @@
+package balancedBinaryTree;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+import static org.junit.Assert.*;
+/**
+ * Created by leicao on 7/10/15.
+ */
+public class balancedBinaryTreeTest {
+
+    @Test
+    public void testIsBalanced() throws Exception {
+        ArrayList<TreeNode> inputes = new ArrayList<TreeNode>();
+        boolean[] results = {false, false};
+        TreeNode n0 = new TreeNode(0);
+        TreeNode n1 = new TreeNode(1);
+        TreeNode n2 = new TreeNode(2);
+        TreeNode n3 = new TreeNode(3);
+
+        n0.left = n1;
+        n1.left = n2;
+        n2.left = n3;
+
+        TreeNode nn0 = new TreeNode(0);
+        TreeNode nn1 = new TreeNode(1);
+        TreeNode nn2 = new TreeNode(2);
+        TreeNode nn3 = new TreeNode(3);
+        nn0.right = nn1;
+        nn1.left = nn2;
+        nn2.left = nn3;
+
+        inputes.add(n0);
+        inputes.add(nn0);
+
+        for (int i = 0; i < results.length; i++) {
+            balancedBinaryTree b = new balancedBinaryTree();
+            assertEquals(results[i], b.isBalanced(inputes.get(i)));
+        }
+
+    }
+}

algorithms-java/src/balancedBinaryTree/balancedBinaryTree.java

@@ -0,0 +1,13 @@
+package binarySearchTreeIterator;
+
+/**
+ * Created by leicao on 5/10/15.
+ */
+public class TreeNode {
+    public int val;
+    public TreeNode left, right;
+    public TreeNode(int val) {
+        this.val = val;
+        this.left = this.right = null;
+    }
+}

algorithms-java/src/balancedBinaryTree/balancedBinaryTreeTest.java

@@ -0,0 +1,70 @@
+// Source : https://oj.leetcode.com/problems/balanced-binary-tree/
+// Inspired by : http://www.jiuzhang.com/solutions/binary-search-tree-iterator/
+// Author : Lei Cao
+// Date   : 2015-10-07
+
+/********************************************************************************** 
+ * 
+ * Implement an iterator over a binary search tree (BST). Your iterator will be initialized with the root node of a BST.
+ * 
+ * Calling next() will return the next smallest number in the BST.
+ * 
+ * Note: next() and hasNext() should run in average O(1) time and uses O(h) memory, where h is the height of the tree. 
+ * 
+ * Credits:Special thanks to @ts for adding this problem and creating all test cases.
+ *               
+ **********************************************************************************/
+
+package binarySearchTreeIterator;
+
+import java.util.Stack;
+
+/**
+ * Definition of TreeNode:
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left, right;
+ *     public TreeNode(int val) {
+ *         this.val = val;
+ *         this.left = this.right = null;
+ *     }
+ * }
+ * Example of iterate a tree:
+ * Solution iterator = new Solution(root);
+ * while (iterator.hasNext()) {
+ *    TreeNode node = iterator.next();
+ *    do something for node
+ * }
+ */
+public class binarySearchTreeIterator {
+    private TreeNode currentNode = null;
+    private Stack<TreeNode> stack = new Stack<TreeNode>();
+    //@param root: The root of binary tree.
+    public binarySearchTreeIterator(TreeNode root) {
+        if (root != null) {
+            currentNode = root;
+        }
+    }
+
+    //@return: True if there has next node, or false
+    public boolean hasNext() {
+        // write your code here
+        return currentNode != null || !stack.isEmpty();
+    }
+
+    //@return: return next node
+    public TreeNode next() {
+        // write your code here
+        while (currentNode != null) {
+            stack.push(currentNode);
+            currentNode = currentNode.left;
+        }
+
+        currentNode = stack.pop();
+        TreeNode node = currentNode;
+        currentNode = currentNode.right;
+
+        return node;
+    }
+}
+

algorithms-java/src/binarySearchTreeIterator/TreeNode.java

@@ -0,0 +1,44 @@
+package binarySearchTreeIterator;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+import static org.junit.Assert.*;
+
+/**
+ * Created by leicao on 11/10/15.
+ */
+public class binarySearchTreeIteratorTest {
+    @Test
+    public void testIterator() throws Exception {
+        ArrayList<TreeNode> inputs = new ArrayList<TreeNode>();
+        TreeNode t0 = new TreeNode(10);
+        TreeNode t1 = new TreeNode(1);
+        TreeNode t2 = new TreeNode(11);
+        TreeNode t3 = new TreeNode(6);
+        TreeNode t4 = new TreeNode(12);
+        t0.left = t1;
+        t0.right = t2;
+        t1.right = t3;
+        t2.right = t4;
+
+        inputs.add(t0);
+
+        int[][] results = {
+                {1,6,10,11,12}
+        };
+
+        for (int i = 0; i < results.length; i++) {
+            binarySearchTreeIterator it = new binarySearchTreeIterator(inputs.get(i));
+            int j = 0;
+            while (it.hasNext()) {
+                TreeNode r = it.next();
+                assertEquals(results[i][j], r.val);
+                j++;
+            }
+        }
+
+    }
+
+}

algorithms-java/src/binarySearchTreeIterator/binarySearchTreeIterator.java

@@ -0,0 +1,11 @@
+package binaryTreeBFSTraversal;
+
+/**
+ * Created by leicao on 5/10/15.
+ */
+public class TreeNode {
+     int val;
+     TreeNode left;
+     TreeNode right;
+     TreeNode(int x) { val = x; }
+}

algorithms-java/src/binarySearchTreeIterator/binarySearchTreeIteratorTest.java

@@ -0,0 +1,35 @@
+package binaryTreeBFSTraversal;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+/**
+ * Created by leicao on 5/10/15.
+ */
+public class binaryTreeBFSTraversal {
+    public List<Integer> bfsTraversal(TreeNode root) {
+        List<Integer>  results = new ArrayList<Integer>();
+        if (root == null) {
+            return results;
+        }
+
+        Queue<TreeNode> q = new LinkedList<TreeNode>();
+
+        q.offer(root);
+        while (q.size() != 0) {
+            TreeNode n = q.remove();
+            results.add(n.val);
+            if (n.left != null) {
+                q.offer(n.left);
+            }
+            if (n.right != null) {
+                q.offer(n.right);
+            }
+        }
+
+        return results;
+
+    }
+}

algorithms-java/src/binaryTreeBFSTraversal/TreeNode.java

@@ -0,0 +1,70 @@
+package binaryTreeBFSTraversal;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Created by leicao on 6/10/15.
+ */
+public class binaryTreeBFSTraversalTest {
+
+    /**
+     *          0
+     *        /   \
+     *      1      2
+     *     / \      \
+     *   3    4      6
+     *      /
+     *      5
+     */
+    @Test
+    public void testPreorderTraversal() throws Exception {
+        TreeNode t0 = new TreeNode(0);
+
+        TreeNode n0 = new TreeNode(0);
+        TreeNode n1 = new TreeNode(1);
+        TreeNode n2 = new TreeNode(2);
+        TreeNode n3 = new TreeNode(3);
+        TreeNode n4 = new TreeNode(4);
+        TreeNode n5 = new TreeNode(5);
+        TreeNode n6 = new TreeNode(6);
+
+        n0.left = n1;
+        n0.right = n2;
+        n1.left = n3;
+        n1.right = n4;
+        n4.left = n5;
+        n2.right = n6;
+
+
+        ArrayList<TreeNode> inputes = new ArrayList<TreeNode>();
+        inputes.add(t0);
+        inputes.add(n0);
+
+        List<List<Integer>> results = new ArrayList<List<Integer>>(){{
+            add(new ArrayList<Integer>(){{
+                   add(0);
+            }});
+            add(new ArrayList<Integer>(){{
+                add(0);
+                add(1);
+                add(2);
+                add(3);
+                add(4);
+                add(6);
+                add(5);
+            }});
+        }};
+
+        binaryTreeBFSTraversal b = new binaryTreeBFSTraversal();
+        for (int i = 0; i < results.size(); i++) {
+            List<Integer> r = b.bfsTraversal(inputes.get(i));
+            assertEquals(results.get(i), r);
+        }
+
+    }
+}