Starting with binary search tree

Author: vtrbtf

classical/data-structures/binary-search-tree/java/.classpath

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="main"/>
+	<classpathentry kind="src" path="test"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

classical/data-structures/binary-search-tree/java/.gitignore

@@ -0,0 +1 @@
+/bin/

classical/data-structures/binary-search-tree/java/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>BinarySearchTree</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

classical/data-structures/binary-search-tree/java/main/BinarySearchTree.java

@@ -0,0 +1,88 @@
+
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+public class BinarySearchTree<T extends Comparable<T>> {
+	
+	private List<T> bst = new ArrayList<>();
+	
+	private Comparator<T> customComparator = Comparator.naturalOrder();
+	
+	public BinarySearchTree(Comparator<T> customComparator) {
+		this.customComparator = customComparator;
+	}
+	
+	public void insert(T e){
+		if (contains(e)) {
+			bst.add(e);
+			Collections.sort(bst, customComparator);
+		}				
+	}
+	
+	public T root(){
+		return bst.get(rootIndex());
+	}
+	
+	private int rootIndex(){
+		return isOdd() ? halfSize() + 1 : halfSize();
+	}
+	
+	private int midpoint(List<T> l){
+		return isOdd(l) ? halfSize(l) + 1 : halfSize(l);
+	}
+	
+	private int midpointIndex(List<T> l){
+		return midpoint(l) - 1;
+	}
+	
+	
+	public boolean contains(T e){		
+		List<T> searchTree = bst;
+		int upperBound = bst.size() - 1;
+		int lowerBound = 0;		
+		
+		while (lowerBound < upperBound) {
+			if (e.equals(searchTree.get(midpointIndex(searchTree)))) {
+				return true;
+			} else {
+				if (customComparator.) {
+					
+				}
+				
+				
+			}
+		}
+	}
+	
+	public void remove(T e){
+		bst.remove(e);
+	}
+	
+	public int size(){
+		return bst.size();
+	}
+	
+	public List<T> childs(T e){
+		
+	}
+	
+	
+	private boolean isOdd() {
+		return isOdd(bst);
+	}
+	
+	private boolean isOdd(List<T> l) {
+		return halfSize(l) != 0;
+	}
+
+	private int halfSize() {
+		return halfSize(bst);
+	}
+	
+	private int halfSize(List<T> l) {
+		return l.size()/2;
+	}
+}