From f178e9fde0665f9d5fe27f58303b4cda660a6568 Mon Sep 17 00:00:00 2001 From: Joey Eamigh <55670930+JoeyEamigh@users.noreply.github.com> Date: Tue, 31 Oct 2023 20:18:48 -0400 Subject: [PATCH] assignment 4 --- .vscode/launch.json | 7 +++ Justfile | 2 +- src/assn04/BST.java | 51 +++++++++++++++++++++ src/assn04/EmptyBST.java | 55 +++++++++++++++++++++++ src/assn04/Main.java | 45 +++++++++++++++++++ src/assn04/NonEmptyBST.java | 90 +++++++++++++++++++++++++++++++++++++ 6 files changed, 249 insertions(+), 1 deletion(-) create mode 100644 src/assn04/BST.java create mode 100644 src/assn04/EmptyBST.java create mode 100644 src/assn04/Main.java create mode 100644 src/assn04/NonEmptyBST.java diff --git a/.vscode/launch.json b/.vscode/launch.json index 72522da..f223193 100644 --- a/.vscode/launch.json +++ b/.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", diff --git a/Justfile b/Justfile index f6367a6..7c1ba59 100644 --- a/Justfile +++ b/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}} diff --git a/src/assn04/BST.java b/src/assn04/BST.java new file mode 100644 index 0000000..03ab712 --- /dev/null +++ b/src/assn04/BST.java @@ -0,0 +1,51 @@ +package assn04; + +public interface BST> { + + /** + * 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 after insertion + **/ + BST 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 after removal + */ + BST 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 getLeft(); + + BST getRight(); + + T getElement(); + + boolean isEmpty(); +} diff --git a/src/assn04/EmptyBST.java b/src/assn04/EmptyBST.java new file mode 100644 index 0000000..4863dfe --- /dev/null +++ b/src/assn04/EmptyBST.java @@ -0,0 +1,55 @@ +package assn04; + +public class EmptyBST> implements BST { + + @Override + public BST insert(T element) { + return new NonEmptyBST(element); + } + + @Override + public BST 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 getLeft() { + throw new UnsupportedOperationException(); + } + + @Override + public BST getRight() { + throw new UnsupportedOperationException(); + } + + @Override + public T getElement() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean isEmpty() { + return true; + } + +} diff --git a/src/assn04/Main.java b/src/assn04/Main.java new file mode 100644 index 0000000..5121702 --- /dev/null +++ b/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 insertBst = makeInstructorTree(); + insertBst.insert(32); + printAll(insertBst); + + System.out.println("Removing 31:"); + BST removeBst = makeInstructorTree(); + removeBst.remove(31); + printAll(removeBst); + } + + public static > void printAll(BST bst) { + System.out.println("Pre-order traversal:"); + bst.printPreOrderTraversal(); + + System.out.println("\nPost-order traversal:"); + bst.printPostOrderTraversal(); + + System.out.println('\n'); + } + + public static BST makeInstructorTree() { + BST bst = new NonEmptyBST(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; + } +} diff --git a/src/assn04/NonEmptyBST.java b/src/assn04/NonEmptyBST.java new file mode 100644 index 0000000..2454a56 --- /dev/null +++ b/src/assn04/NonEmptyBST.java @@ -0,0 +1,90 @@ +package assn04; + +public class NonEmptyBST> implements BST { + private T _element; + private BST _left; + private BST _right; + + public NonEmptyBST(T element) { + _left = new EmptyBST(); + _right = new EmptyBST(); + _element = element; + } + + @Override + public BST 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 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 getLeft() { + return _left; + } + + @Override + public BST getRight() { + return _right; + } + + @Override + public T getElement() { + return _element; + } + + @Override + public boolean isEmpty() { + return false; + } +}