assignment 4

.vscode/launch.json

@@ -4,6 +4,13 @@
   // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
   "version": "0.2.0",
   "configurations": [
+    {
+      "type": "java",
+      "name": "Main",
+      "request": "launch",
+      "mainClass": "assn04.Main",
+      "projectName": "COMP210_238a5b6"
+    },
     {
       "type": "java",
       "name": "Main",

Justfile

@@ -1,7 +1,7 @@
 default: run
 
 recentFile := `find src -type f -printf '%T@ %p\n' | sort -n | cut -d " " -f 2- | tail -1`
-recentFolder := `find src -type d -printf '%T@ %p\n' | sort -n | cut -d' ' -f 2- | sed 's/src\///' | tail -2 | head -1`
+recentFolder := `find src -type d -printf '%T@ %p\n' | sort -n | cut -d' ' -f 2- | sed 's/src\///' | tail -2 | grep -v "src"`
 
 echo:
   echo {{recentFile}}

src/assn04/BST.java

@@ -0,0 +1,51 @@
+package assn04;
+
+public interface BST<T extends Comparable<T>> {
+
+  /**
+   * Inserts element into the tree in the appropriate position.
+   * Either returns the mutated tree after insertion or a new tree
+   * with the inserted element.
+   *
+   * @param element to be added to the tree
+   * @return BST<T> after insertion
+   **/
+  BST<T> insert(T element);
+
+  /**
+   * Removes the element from the tree if it is present.
+   * Either returns the possibly mutated tree after removal or an empty tree.
+   *
+   * @param element to be removed from tree
+   * @return BST<T> after removal
+   */
+  BST<T> remove(T element);
+
+  /**
+   * Prints the tree in depth-first pre-order traversal.
+   * Print the elements all in one line with a space after each element.
+   */
+  void printPreOrderTraversal();
+
+  /**
+   * Prints the tree in post-order traversal.
+   * Print the elements all in one line with a space after each element.
+   */
+  void printPostOrderTraversal();
+
+  // @return int which is based on the number of edges. -1 for an EmptyBST.
+  int getHeight();
+
+  /**
+   * Following are some methods which are self-explanatory.
+   */
+  T findMin();
+
+  BST<T> getLeft();
+
+  BST<T> getRight();
+
+  T getElement();
+
+  boolean isEmpty();
+}

src/assn04/EmptyBST.java

@@ -0,0 +1,55 @@
+package assn04;
+
+public class EmptyBST<T extends Comparable<T>> implements BST<T> {
+
+	@Override
+	public BST<T> insert(T element) {
+		return new NonEmptyBST<T>(element);
+	}
+
+	@Override
+	public BST<T> remove(T element) {
+		return this;
+	}
+
+	@Override
+	public int getHeight() {
+		return -1;
+	}
+
+	@Override
+	public void printPreOrderTraversal() {
+		return;
+	}
+
+	@Override
+	public T findMin() {
+		throw new UnsupportedOperationException();
+	}
+
+	@Override
+	public void printPostOrderTraversal() {
+		return;
+	}
+
+	@Override
+	public BST<T> getLeft() {
+		throw new UnsupportedOperationException();
+	}
+
+	@Override
+	public BST<T> getRight() {
+		throw new UnsupportedOperationException();
+	}
+
+	@Override
+	public T getElement() {
+		throw new UnsupportedOperationException();
+	}
+
+	@Override
+	public boolean isEmpty() {
+		return true;
+	}
+
+}

src/assn04/Main.java

@@ -0,0 +1,45 @@
+package assn04;
+
+public class Main {
+  public static void main(String[] args) {
+
+    System.out.println("Original tree:");
+    printAll(makeInstructorTree());
+
+    System.out.println("Inserting 32:");
+    BST<Integer> insertBst = makeInstructorTree();
+    insertBst.insert(32);
+    printAll(insertBst);
+
+    System.out.println("Removing 31:");
+    BST<Integer> removeBst = makeInstructorTree();
+    removeBst.remove(31);
+    printAll(removeBst);
+  }
+
+  public static <T extends Comparable<T>> void printAll(BST<T> bst) {
+    System.out.println("Pre-order traversal:");
+    bst.printPreOrderTraversal();
+
+    System.out.println("\nPost-order traversal:");
+    bst.printPostOrderTraversal();
+
+    System.out.println('\n');
+  }
+
+  public static BST<Integer> makeInstructorTree() {
+    BST<Integer> bst = new NonEmptyBST<Integer>(78);
+
+    bst = bst.insert(84);
+    bst = bst.insert(31);
+    bst = bst.insert(13);
+    bst = bst.insert(38);
+    bst = bst.insert(10);
+    bst = bst.insert(12);
+    bst = bst.insert(40);
+    bst = bst.insert(39);
+    bst = bst.insert(47);
+
+    return bst;
+  }
+}

src/assn04/NonEmptyBST.java

@@ -0,0 +1,90 @@
+package assn04;
+
+public class NonEmptyBST<T extends Comparable<T>> implements BST<T> {
+	private T _element;
+	private BST<T> _left;
+	private BST<T> _right;
+
+	public NonEmptyBST(T element) {
+		_left = new EmptyBST<T>();
+		_right = new EmptyBST<T>();
+		_element = element;
+	}
+
+	@Override
+	public BST<T> insert(T element) {
+		if (element.compareTo(_element) < 0)
+			_left = _left.insert(element);
+		else if (element.compareTo(_element) > 0 || element.compareTo(_element) == 0)
+			_right = _right.insert(element);
+
+		return this;
+	}
+
+	@Override
+	public T findMin() {
+		if (_left.isEmpty())
+			return _element;
+		else
+			return _left.findMin();
+	}
+
+	@Override
+	public BST<T> remove(T element) {
+		if (element.compareTo(_element) < 0)
+			_left = _left.remove(element);
+		else if (element.compareTo(_element) > 0)
+			_right = _right.remove(element);
+		else {
+			if (_left.isEmpty())
+				return _right;
+			else if (_right.isEmpty())
+				return _left;
+			else {
+				_element = _right.findMin();
+				_right = _right.remove(_element);
+			}
+		}
+
+		return this;
+	}
+
+	@Override
+	public void printPreOrderTraversal() {
+		System.out.print(_element + " ");
+		_left.printPreOrderTraversal();
+		_right.printPreOrderTraversal();
+	}
+
+	@Override
+	public void printPostOrderTraversal() {
+		_left.printPostOrderTraversal();
+		_right.printPostOrderTraversal();
+		System.out.print(_element + " ");
+	}
+
+	@Override
+	public int getHeight() {
+		return Math.max(_left.getHeight(), _right.getHeight()) + 1;
+	}
+
+	@Override
+	public BST<T> getLeft() {
+		return _left;
+	}
+
+	@Override
+	public BST<T> getRight() {
+		return _right;
+	}
+
+	@Override
+	public T getElement() {
+		return _element;
+	}
+
+	@Override
+	public boolean isEmpty() {
+		return false;
+	}
+}