binary-search-tree: add starter implementation

Since the class signature is rather complicated, starter implementation
should be provided.

Also tidied up the reference implementation.

exercises/binary-search-tree/.meta/src/reference/java/BinarySearchTree.java

@@ -1,49 +1,11 @@
+import java.util.*;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Queue;
-
-public class BinarySearchTree<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;
-        }
-
-    }
+class BinarySearchTree<T extends Comparable<T>> {
 
     private Node<T> root;
-
     private int nodeCount = 0;
 
-    public void insert(T value) {
+    void insert(T value) {
         if (root == null) {
             root = new Node<>(value);
         } else {
@@ -52,19 +14,19 @@ public class BinarySearchTree<T extends Comparable<T>> {
         this.nodeCount++;
     }
 
-    public List<T> getAsSortedList() {
+    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> getAsLevelOrderList() {
         List<T> result = new ArrayList<>(this.nodeCount);
         this.putInLevelOrderToList(this.root, result);
         return Collections.unmodifiableList(result);
     }
 
-    public Node<T> getRoot() {
+    Node<T> getRoot() {
         return root;
     }
 
@@ -119,4 +81,36 @@ public class BinarySearchTree<T extends Comparable<T>> {
             }
         }
     }
+
+    static class Node<T> {
+
+        private T data;
+        private Node<T> left = null;
+        private Node<T> right = null;
+
+        Node(T data) {
+            this.data = data;
+        }
+
+        Node<T> getLeft() {
+            return left;
+        }
+
+        void setLeft(Node<T> left) {
+            this.left = left;
+        }
+
+        Node<T> getRight() {
+            return right;
+        }
+
+        void setRight(Node<T> right) {
+            this.right = right;
+        }
+
+        T getData() {
+            return data;
+        }
+
+    }
 }

exercises/binary-search-tree/src/main/java/BinarySearchTree.java

@@ -0,0 +1,35 @@
+import java.util.List;
+
+class BinarySearchTree<T extends Comparable<T>> {
+    void insert(T value) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    List<T> getAsSortedList() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    List<T> getAsLevelOrderList() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    Node<T> getRoot() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    static class Node<T> {
+
+        Node<T> getLeft() {
+            throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+        }
+
+        Node<T> getRight() {
+            throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+        }
+
+        T getData() {
+            throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+        }
+
+    }
+}