Added binary search tree exercise to the Java track (#191)

* Added binary search tree exercise to the Java track

* Removed pythagorial triplet from config.json

* Removed binary search from config.json

config.json

@@ -51,7 +51,8 @@
     "series",
     "robot-simulator",
     "bracket-push",
-    "pythagorean-triplet"
+    "pythagorean-triplet",
+    "binary-search-tree"
   ],
   "exercises": [
     {
@@ -293,6 +294,11 @@
       "slug": "pythagorean-triplet",
       "difficulty": 1,
       "topics": []
+    },
+    {
+      "slug": "binary-search-tree",
+      "difficulty": 1,
+      "topics": []
     }
   ],
   "deprecated": [

exercises/binary-search-tree/build.gradle

@@ -0,0 +1,18 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testCompile "junit:junit:4.12"
+}
+
+test {
+    testLogging {
+        exceptionFormat = 'full'
+        events = ["passed", "failed", "skipped"]
+    }
+}

exercises/binary-search-tree/src/example/java/BST.java

@@ -0,0 +1,122 @@
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+public class BST<T extends Comparable<T>> {
+
+    public static class Node<T> {
+
+        private T data;
+        private Node<T> left = null;
+        private Node<T> right = null;
+
+        public Node(T data) {
+            this.data = data;
+        }
+
+        public Node<T> getLeft() {
+            return left;
+        }
+
+        public void setLeft(Node<T> left) {
+            this.left = left;
+        }
+
+        public Node<T> getRight() {
+            return right;
+        }
+
+        public void setRight(Node<T> right) {
+            this.right = right;
+        }
+
+        public T getData() {
+            return data;
+        }
+
+    }
+
+    private Node<T> root;
+
+    private int nodeCount = 0;
+
+    public void insert(T value) {
+        if (root == null) {
+            root = new Node<>(value);
+        } else {
+            this.insert(this.root, value);
+        }
+        this.nodeCount++;
+    }
+
+    public List<T> getAsSortedList() {
+        List<T> result = new ArrayList<>(this.nodeCount);
+        this.putInSortedOrderToList(this.root, result);
+        return Collections.unmodifiableList(result);
+    }
+
+    public List<T> getAsLevelOrderList() {
+        List<T> result = new ArrayList<>(this.nodeCount);
+        this.putInLevelOrderToList(this.root, result);
+        return Collections.unmodifiableList(result);
+    }
+
+    public Node<T> getRoot() {
+        return root;
+    }
+
+    private void insert(Node<T> node, T value) {
+        if (value.compareTo(node.getData()) <= 0) {
+            if (node.getLeft() == null) {
+                node.setLeft(new Node<T>(value));
+            } else {
+                insert(node.getLeft(), value);
+            }
+        } else {
+            if (node.getRight() == null) {
+                node.setRight(new Node<T>(value));
+            } else {
+                insert(node.getRight(), value);
+            }
+        }
+    }
+
+    private void putInSortedOrderToList(Node<T> node, List<T> list) {
+        if (node == null || list == null) {
+            return;
+        }
+        if (node.getLeft() != null) {
+            putInSortedOrderToList(node.getLeft(), list);
+        }
+        list.add(node.getData());
+        if (node.getRight() != null) {
+            putInSortedOrderToList(node.getRight(), list);
+        }
+    }
+
+    private void putInLevelOrderToList(Node<T> node, List<T> list) {
+        if (node == null || list == null) {
+            return;
+        }
+        final Queue<Node<T>> queue = new LinkedList<>();
+        Node<T> myNode;
+        Node<T> left;
+        Node<T> right;
+        queue.add(node);
+        while (!queue.isEmpty()) {
+            myNode = queue.poll();
+            list.add(myNode.getData());
+            left = myNode.getLeft();
+            right = myNode.getRight();
+            if (left != null) {
+                queue.add(left);
+            }
+            if (right != null) {
+                queue.add(right);
+            }
+        }
+    }
+}

exercises/binary-search-tree/src/test/java/BSTTest.java

@@ -0,0 +1,163 @@
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import org.junit.Ignore;
+import org.junit.Test;
+
+public class BSTTest {
+
+    @Test
+    public void dataIsRetained() {
+        BST<Integer> sut = new BST();
+        final int actual = 4;
+        sut.insert(actual);
+        final BST.Node<Integer> root = sut.getRoot();
+        assertNotNull(root);
+        final int expected = root.getData();
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void insertsLess() {
+        BST<Integer> sut = new BST();
+        final int expectedRoot = 4;
+        final int expectedLeft = 2;
+
+        sut.insert(expectedRoot);
+        sut.insert(expectedLeft);
+
+        final BST.Node<Integer> root = sut.getRoot();
+        assertNotNull(root);
+        final BST.Node<Integer> left = root.getLeft();
+        assertNotNull(left);
+
+        final int actualRoot = root.getData();
+        final int actualLeft = left.getData();
+        assertEquals(expectedLeft, actualLeft);
+        assertEquals(expectedRoot, actualRoot);
+    }
+
+    @Test
+    @Ignore
+    public void insertsSame() {
+        BST<Integer> sut = new BST();
+        final int expectedRoot = 4;
+        final int expectedLeft = 4;
+
+        sut.insert(expectedRoot);
+        sut.insert(expectedLeft);
+
+        final BST.Node<Integer> root = sut.getRoot();
+        assertNotNull(root);
+        final BST.Node<Integer> left = root.getLeft();
+        assertNotNull(left);
+
+        final int actualRoot = root.getData();
+        final int actualLeft = left.getData();
+        assertEquals(expectedLeft, actualLeft);
+        assertEquals(expectedRoot, actualRoot);
+    }
+
+    @Test
+    @Ignore
+    public void insertsRight() {
+        BST<Integer> sut = new BST();
+        final int expectedRoot = 4;
+        final int expectedRight = 5;
+
+        sut.insert(expectedRoot);
+        sut.insert(expectedRight);
+
+        final BST.Node<Integer> root = sut.getRoot();
+        assertNotNull(root);
+        final BST.Node<Integer> right = root.getRight();
+        assertNotNull(right);
+
+        final int actualRoot = root.getData();
+        final int actualRight = right.getData();
+        assertEquals(expectedRight, actualRight);
+        assertEquals(expectedRoot, actualRoot);
+    }
+
+    @Test
+    @Ignore
+    public void createsComplexTree() {
+        BST<Integer> sut = new BST<>();
+        List<Integer> expected = Collections.unmodifiableList(
+                Arrays.asList(4, 2, 6, 1, 3, 5, 7)
+        );
+
+        List<Integer> treeData = Collections.unmodifiableList(
+                Arrays.asList(4, 2, 6, 1, 3, 7, 5)
+        );
+        treeData.forEach(value -> sut.insert(value));
+
+        List<Integer> actual = sut.getAsLevelOrderList();
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void sortsSingleElement() {
+        BST<Integer> sut = new BST<>();
+        List<Integer> expected = Collections.unmodifiableList(
+                Arrays.asList(4)
+        );
+
+        sut.insert(4);
+
+        List<Integer> actual = sut.getAsSortedList();
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void sortsCollectionOfTwoIfSecondInsertedIsSmallerThanFirst() {
+        BST<Integer> sut = new BST<>();
+        List<Integer> expected = Collections.unmodifiableList(
+                Arrays.asList(2, 4)
+        );
+
+        sut.insert(4);
+        sut.insert(2);
+
+        List<Integer> actual = sut.getAsSortedList();
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void sortsCollectionOfTwoIfSecondInsertedIsBiggerThanFirst() {
+        BST<Integer> sut = new BST<>();
+        List<Integer> expected = Collections.unmodifiableList(
+                Arrays.asList(4, 5)
+        );
+
+        sut.insert(4);
+        sut.insert(5);
+
+        List<Integer> actual = sut.getAsSortedList();
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void iteratesOverComplexTree() {
+        BST<Integer> sut = new BST<>();
+        List<Integer> expected = Collections.unmodifiableList(
+                Arrays.asList(1, 2, 3, 4, 5, 6, 7)
+        );
+
+        List<Integer> treeData = Collections.unmodifiableList(
+                Arrays.asList(4, 2, 1, 3, 6, 7, 5)
+        );
+        treeData.forEach(value -> sut.insert(value));
+
+        List<Integer> actual = sut.getAsSortedList();
+        assertEquals(expected, actual);
+    }
+}

exercises/settings.gradle

@@ -5,7 +5,7 @@ include 'anagram'
 include 'atbash-cipher'
 include 'beer-song'
 include 'binary'
-include 'binary-search'
+include 'binary-search-tree'
 include 'bob'
 include 'bracket-push'
 include 'crypto-square'