add lab7

Author: Kharukulavat

.DS_Store

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="CheckStyle-IDEA-Module" serialisationVersion="2">
+    <option name="activeLocationsIds" />
+  </component>
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

LAB7_BinarySearchTree/.DS_Store

@@ -0,0 +1,275 @@
+public class BST<T extends Comparable<T>> extends BT<T> {
+	/** Create an empty binary tree */
+	public BST() {
+
+	}
+
+	/** Create a binary tree from an object */
+	public BST(T object) {
+		root.element = object;
+	}
+
+	/** Create a binary tree from an array of objects */
+	public BST(T[] objects) {
+		for (int i = 0; i < objects.length; i++)
+			insert(objects[i]);
+	}
+
+	// ----------------------------------------------
+	/**
+	 * Insert newdata into the binary search tree
+	 */
+	public void insert(T newdata) {
+		// Ex1: Complete this program
+		if (root == null) {
+			// Create a new root
+			root = new BTNode<T>(newdata);
+		} else {
+			// Locate the parent node
+			BTNode<T> parent = null;
+			BTNode<T> current = root;
+			// insert your code
+			while(current != null){
+				parent = current;
+				if (newdata.compareTo(current.element) <= 0){ //if newdata <= current, go left
+					current = current.left;
+				}
+				else if (newdata.compareTo(current.element) > 0){ //if newdata > current, go right
+					current = current.right;
+				}
+			}
+			//when current == null (the leaf node)
+			if (newdata.compareTo(parent.element) <= 0){ //to insert the newnode
+				parent.left = new BTNode<T>(newdata); //if newnode <= its parent, assign newnode to left
+			}
+			else {
+				parent.right = new BTNode<T>(newdata); //if newnode > its parent, assign newnode to right
+			}
+		}
+
+		size++;
+	}
+
+	// ----------------------------------------------
+	/**
+	 * Delete data from the binary search tree
+	 */
+	// Ex2. Complete This Program
+	public T delete(T item) {
+		// Locate the node to be deleted and also locate its parent node
+		BTNode<T> parent = null;
+		BTNode<T> current = root;
+
+		boolean currentIsLeftChild = true;
+
+		while (current != null) {
+			// insert your code
+			//we need to search for the deleted node first
+			if(item.compareTo(current.element) < 0){ //if item < current element, go left
+				parent = current;
+				current = current.left;
+				currentIsLeftChild = true;
+
+			}
+			else if (item.compareTo(current.element) > 0){ //if item > current element, go right
+				parent = current;
+				current = current.right;
+				currentIsLeftChild = false;
+			}
+			else {
+				break;
+			}
+		}
+
+		// Case 0: item is not in the tree
+		if (current == null) {
+			return null;
+		}
+
+		T temp = current.element;
+		// Case 1: current is the leave
+
+		if (current.left == null && current.right == null) {
+			// insert your code
+			if(currentIsLeftChild){
+				parent.left = null;
+			}
+			else {
+				parent.right = null;
+			}
+		}
+
+		// Case 2: If the deleted node has one child
+		// Case 2.1: if its child node is on the right
+		if ((current.left == null)) { // If only has one right child or no children.
+			if (currentIsLeftChild) {
+				// insert your code
+				if(parent == null){ //it is the root (if deleting root)
+					root = current.right; //there's no leftsub for the previous root, so when it deleted the root,
+					// the right child of the root will be the next root
+				}
+				else { //it is not the root, current is left child, it has no current.left so when it deleted current,
+					// it has to link parent.left with the current.right
+					parent.left = current.right;
+					current.right = null; //disconnect the link of temp(current)
+				}
+
+			} else { //current is right child
+				// insert your code
+				if(parent == null){ //it is the root (if deleting root)
+					root = current.right; //there's no leftsub for the previous root, so when it deleted the root,
+					// the right child of the root will be the next root
+				}
+				else { //it is not root, current is right child, it has np current.left so when it deleted current,
+					// it has to link parent.right with the current.right
+					parent.right = current.right;
+					current.right = null; //disconnect the link of temp(current)
+				}
+			}
+		}
+		// Case 2.2: If its child node is on the left
+		else if ((current.right == null)) { // Only one left child
+			if (currentIsLeftChild) {
+				// insert your code
+				if (parent == null){ //it is the root (if deleting root)
+					root = current.left; //there's no rightsub for the previous root, so when it deleted the root,
+					// the left child of the root will be the next root
+				}
+				else{ //it is not root, current is left child, it has no current.right so when it deleted current,
+					// it has to link parent.left with the current.left
+					parent.left = current.left;
+					current.left = null; //disconnect the link of temp(current)
+
+				}
+			} else { //current is right child
+				// insert your code
+				if (parent == null){ //it is the root (if deleting root)
+					root = current.left; //there's no rightsub for the previous root, so when it deleted the root,
+					// the left child of the root will be the next root
+				}
+				else{ //it is not root, current is right child, it has no current.right so when it deleted current,
+					// it has to link parent.right with the current.left
+					parent.right = current.left;
+					current.left = null; //disconnect the link of temp(current)
+				}
+			}
+		} else { // Case 3: Have both children
+			BTNode<T> maxleft = current.left;
+			BTNode<T> maxleftParent = current;
+			while (maxleft.right != null) {
+				maxleftParent = maxleft;
+				maxleft = maxleft.right;
+			}
+			current.element = maxleft.element; //replace the temp(current) with maxleft
+			if (maxleft.left == null && maxleft.right == null) { // Case 3.1 if maxleft is a leave,
+				// then replace the temp(current) with maxleft, then set maxleftParent to have no child (unlink)
+				//insert your code
+				maxleftParent.right = null; //unlink maxleftParent with maxleft
+			} 
+			else if (maxleft.left != null) { // Case 3.2 if maxleft has a left child,
+				// then replace the temp(current) with maxleft, make maxleft.left be the right child of maxleftParent
+				//insert your code
+				maxleftParent.right = maxleft.left; //connect maxleftParent with maxleft.left
+				maxleft.left = null; //unlink maxleft with maxleft.left
+			} 
+			else if (maxleftParent == current) { // Case 3.3 if maxleft is leftchild of current,
+				// then replace the temp(current) with maxleft, make maxleft.left be the leftchild of temp(current.left)
+				//insert your code
+				current.left = maxleft.left; //connect temp(current) with maxleft.left
+				maxleft.left = null; //unlink maxleft with maxleft.left
+			}
+		}
+		size--;
+		return temp;
+	}
+	// ---------------------------------------------------------
+
+	// Search for the data returns true if it finds the data or otherwise false
+	public boolean search(T data) { 
+		// Ex 3: Complete this section.
+		//replace the following line with your code
+		BTNode<T> current = root;
+		while (current != null){
+			if (data.compareTo(current.element) < 0) { //if data <= current, go left in search we compare just for < 0
+				//if we use <= 0 it'll haas a problem when it matches, it will continue going left but it should stop there so we need to use < 0zsz
+				current = current.left;
+			}
+			else if (data.compareTo(current.element) > 0) { //if newdata > current, go right
+				current = current.right;
+			}
+			else { //element matches with current.element
+				return true;
+			}
+		}
+		return false;
+	}
+
+	// ---------------------------------------------------------
+
+	BTNode<T> findSmallest() {
+		return findSmallest(root);
+	}
+
+	// ----------------------------------------------
+	BTNode<T> findSmallest(BTNode<T> start) {
+		// Ex 4: Complete this section.
+		//replace the following line with your code
+		BTNode<T> smallest = start;
+		while (smallest.left != null) {
+			smallest = smallest.left;
+		}
+		if (smallest.left == null){
+			return smallest;
+		}
+		else {
+			return null;
+		}
+	}
+
+	// ----------------------------------------------
+	BTNode<T> findLargest() {
+		return findLargest(root);
+	}
+
+	// ----------------------------------------------
+	BTNode<T> findLargest(BTNode<T> start) { 
+		// Ex 5: Complete this section.
+		//replace the following line with your code
+		BTNode<T> largest = start;
+		while (largest.right != null){
+			largest = largest.right;
+		}
+		if (largest.right == null){
+			return largest;
+		}
+		else {
+			return null;
+		}
+	}
+
+	/** Get the number of nodes in the tree */
+	public int getSize() {
+		return size;
+	}
+
+	/** Returns the root of the tree */
+	public BTNode getRoot() {
+		return root;
+	}
+
+	/** Returns a path from the root leading to the specified element */
+	public java.util.ArrayList<BTNode<T>> path(T e) {
+		java.util.ArrayList<BTNode<T>> list = new java.util.ArrayList<BTNode<T>>();
+		BTNode<T> current = root; // Start from the root
+
+		while (current != null) {
+			list.add(current); // Add the node to the list
+			if (e.compareTo(current.element) < 0) {
+				current = current.left;
+			} else if (e.compareTo(current.element) > 0) {
+				current = current.right;
+			} else
+				break;
+		}
+
+		return list; // Retur

LAB7_BinarySearchTree/.idea/.gitignore

@@ -0,0 +1,274 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+import static java.lang.Math.max;
+
+public class BT<T> {
+
+	int size;
+	BTNode<T> root = null;
+
+	BT() {
+		root = null;
+		size = 0;
+	}
+
+	BT(T data) { //Similar to creating BTNode, it is eventually to create a node
+		this(new BTNode<T>(data));
+	}
+
+	BT(BTNode<T> root) { //create a node by using root of the stack we have
+		this.root = root;
+		size = 1;
+	}
+
+	BT(BTNode<T> root, BT<T> Lsubtree, BT<T> Rsubtree) {
+		this.root = root;
+		root.left = Lsubtree.root;
+		root.right = Rsubtree.root;
+		size = Lsubtree.size + Rsubtree.size + 1;
+	}
+
+	int findHeight() {
+		return findHeight(root);
+	}
+
+	int findHeight(BTNode<T> root) {
+		// Exercise 1 ////////////////
+		if (root == null) {
+		// Replace the following statement with your code.
+			return 0;
+		} else if (isLeaf(root)) {
+		// Replace the following statement with your code.
+			return 1;
+		} else {	
+		// Replace the following statement with your code.
+			return 1 + max(findHeight(root.left), findHeight(root.right));
+		}		
+	}
+
+	boolean isLeaf(BTNode<T> root) {
+		if (root != null && root.left == null && root.right == null) {
+			return true;
+		} 
+		else {
+			return false;
+		}
+	}
+
+	boolean isBalanced() {
+		return isBalanced(root);
+	}
+
+	boolean isBalanced(BTNode<T> root) {
+		if (root == null) {
+			return true;
+		}
+		int LH = findHeight(root.left);
+		int RH = findHeight(root.right);
+		int B = Math.abs(LH - RH);
+		
+		if (B <= 1) {
+			return (isBalanced(root.left) && isBalanced(root.right));
+		} 
+		else {
+			return false;
+		}
+	}
+
+	/* Inorder traversal from the root */
+	public void inorder() { //for the other classes to access and use this method
+		inorder(root);
+	}
+
+	/* Inorder traversal from a subtree */
+	protected void inorder(BTNode<T> root) {
+		// Exercise 2 (a) Complete this method
+		if (root != null) {
+			if (isLeaf(root)){
+				System.out.println(root.element + " ");
+			} else{
+				inorder(root.left);
+				System.out.println(root.element + " ");
+				inorder(root.right);
+			}
+		}
+	}
+
+	/* Postorder traversal from the root */
+	public void postorder() {
+		postorder(root);
+	}
+
+	/* Postorder traversal from a subtree */
+	protected void postorder(BTNode<T> root) {
+		// Exercise 2 (b) Complete this method
+		if (root != null){
+			if(isLeaf(root)){
+				System.out.println(root.element + " ");
+			} else {
+				postorder(root.left);
+				postorder(root.right);
+				System.out.println(root.element + " ");
+			}
+		}
+	}
+
+	/* Preorder traversal from the root */
+	public void preorder() {
+		preorder(root);
+	}
+
+	/* Preorder traversal from a subtree */
+	protected void preorder(BTNode<T> root) {
+	    if (root != null) {
+	       if (isLeaf(root)) {
+	    	   System.out.print(root.element + " ");
+	       } 
+	       else {
+	    	   System.out.print(root.element + " ");
+	    	   preorder(root.left);
+	    	   preorder(root.right);
+	       }
+	    }
+	}
+
+	void PrintDFT() {
+		// Exercise 3 ////////////////
+		Stack<BTNode<T>> S = new Stack<BTNode<T>>();
+
+		BTNode<T> tmp;
+		S.push(root); //insert the root to S
+		//insert your code here
+		while(!S.isEmpty()){
+			tmp = S.pop();
+			if (tmp.right != null){
+				S.push(tmp.right);
+			}
+			if (tmp.left != null){
+				S.push(tmp.left);
+			}
+			System.out.print(tmp.element + " ");
+		}
+	}
+
+	void PrintBFT() {
+		// Exercise 4 ////////////////
+		Queue<BTNode<T>> Q = new Queue<BTNode<T>>();
+
+		BTNode<T> tmp;
+		Q.enqueue(root); //Insert the root to Q
+		//insert your code here
+		while(!Q.isEmpty()){
+			tmp = Q.dequeue();
+			if (tmp.left != null){
+				Q.enqueue(tmp.left);
+			}
+			if (tmp.right != null){
+				Q.enqueue(tmp.right);
+			}
+			System.out.println(tmp.element);
+		}
+	}
+
+	static boolean hasHigherPriority(String sign1, String sign2) {
+		if (sign2.equals("("))
+			return true;
+		else if (sign1.equals("*") && sign2.equals("+"))
+			return true;
+		else if (sign1.equals("*") && sign2.equals("-"))
+			return true;
+		else if (sign1.equals("/") && sign2.equals("+"))
+			return true;
+		else if (sign1.equals("/") && sign2.equals("-"))
+			return true;
+		else if (sign1.equals("%") && sign2.equals("+"))
+			return true;
+		else if (sign1.equals("%") && sign2.equals("-"))
+			return true;
+		else
+			return false;
+
+	}
+
+	// Exercise 5 ///////////////////////////////////////////////
+	public static boolean isOperator(String item)
+	{ 
+		if (item.equals("+") || item.equals("-") || item.equals("*") || item.equals("/") || item.equals("%"))
+			return true;
+		else
+			return false;
+	}
+     
+
+ 
+    public static BT<String> makeExpressionTree(String [] infixArr)
+	{   
+		Stack<BT<String>> BTStack = new Stack<BT<String>>(); //for keeping tree stack (value)
+        Stack<BTNode<String>> parent = new Stack<BTNode<String>>(); //for keeping parent nodes, which is operator
+        String item;
+        int i=0;
+        while(i!=infixArr.length){
+        	item = infixArr[i]; //read item from array 
+        	// Case 1: if item it is an open parenthesis
+        	if (item.equals("(")) {
+        		//add your code here
+				parent.push(new BTNode<String>(item)); //create an operator stack, push it to the stack
+        	} 
+        	else if (isOperator(item)){ //if item is an operator
+        		BTNode<String> temp = new BTNode<String>(item); //temp is an item node
+        		if (parent.isEmpty()) { // stack is empty
+        			// add your code here
+					parent.push(temp);
+        		}
+        		else {// stack is not empty
+              
+        			if(hasHigherPriority(item, parent.peek().element)) {  
+        				// add your code here
+						parent.push(temp);
+        			}
+        			else { //if it isn't higher priority, then we have to calculate it
+        				// add your code here
+						BTNode<String> root = parent.pop(); //root is an operator
+						BT<String> Right = BTStack.pop(); //top is Y as the right operand
+						BT<String> Left = BTStack.pop(); //below top is X as the left operand
+						//operation: X (operator) P
+						BTStack.push(new BT<String>(root, Left, Right)); //push this node to tree stack
+
+						parent.push(new BTNode<String>(item)); //push item to operand stack
+
+        			}
+        		}
+        	}
+        	// Case3: if item is a close parenthesis  
+        	else if (item.equals(")")) {
+        		while (parent.peek().element.equals("(") == false) {
+        			BTNode<String> root = parent.pop();
+        			BT<String> Rsubtree = BTStack.pop();
+        			BT<String> Lsubtree = BTStack.pop();
+        			BT<String> newBT = new BT<String>(root, Lsubtree, Rsubtree);
+        			BTStack.push(newBT);
+        		}
+        		parent.pop(); //pop from operand stack
+        	}
+        	else {// Case 4: it is not an operator (it is a value)
+        		BT<String> newTree = new BT<String>(item);
+        		// add your code here
+				BTStack.push(newTree);
+
+        	}
+        	i++;
+        }
+        while (!parent.isEmpty()) { //if operator stack is not empty
+        	BTNode<String> root = parent.pop();
+        	BT<String> Rsubtree = BTStack.pop();
+        	BT<String> Lsubtree = BTStack.pop();
+        	BT<String> newBT = new BT<String>(root, Lsubtree, Rsubtree);
+        	// add your code here
+			BTStack.push(newBT);
+        }
+        return BTStack.pop(); //return the last result value
+    }
+}

LAB7_BinarySearchTree/.idea/checkstyle-idea.xml

@@ -0,0 +1,11 @@
+public class BTNode<T>
+{
+	T element;
+	BTNode<T> left = null;
+	BTNode<T> right = null;
+
+	public BTNode(T e)
+	{
+		element = e;
+	}
+}

LAB7_BinarySearchTree/.idea/misc.xml

@@ -0,0 +1,28 @@
+/**
+ * The {@code Node} class represents a node in a singly linked list.
+ *
+ * @param <T> The type of data stored in the node.
+ */
+class Node<T> {
+	/**
+	 * The data element stored in the node.
+	 */
+	T element;
+
+	/**
+	 * Reference to the next node in the linked list.
+	 */
+	Node<T> next;
+
+	/**
+	 * Constructs a new node with the specified data element.
+	 *
+	 * @param element The data element to store in the node.
+	 */
+
+	Node(T element) {
+		this.element = element;
+		next = null;
+	}
+
+}

LAB7_BinarySearchTree/.idea/modules.xml

@@ -0,0 +1,125 @@
+/**
+ * A generic queue implementation using a singly linked list.
+ *
+ * @param <T> the type of elements stored in the queue
+ */
+public class Queue<T> {
+	/** The underlying singly linked list for the queue. */
+	SList<T> list = new SList<T>();
+
+	/** Default constructor to initialize an empty queue. */
+	Queue() {
+	}
+
+	/**
+	 * Enqueues an element into the queue.
+	 *
+	 * @param element the element to enqueue
+	 */
+	void enqueue(T element) {
+		// Exercise 1a
+		list.addLast(element);
+	}
+
+	/**
+	 * Dequeues an element from the queue.
+	 *
+	 * @return the dequeued element
+	 */
+	T dequeue() {
+		// Exercise 1b
+		return list.removeFirst();
+	}
+
+	/**
+	 * Gets the element at the front of the queue without removing it.
+	 *
+	 * @return the element at the front of the queue
+	 */
+	T queuefront() {
+		// Exercise 1c
+		return list.getElementAtIndex(0);
+	}
+
+	/**
+	 * Gets the element at the rear of the queue without removing it.
+	 *
+	 * @return the element at the rear of the queue
+	 */
+	T queuerear() {
+		// Exercise 1d
+		return list.getElementAtIndex(list.getSize() - 1);
+//		return list.last.element;
+	}
+
+	/**
+	 * Checks if the queue is empty.
+	 *
+	 * @return true if the queue is empty, false otherwise
+	 */
+	boolean isEmpty() {
+		return list.isEmpty();
+	}
+
+	/**
+	 * Creates a copy of this queue.
+	 *
+	 * @return a new queue containing the same elements as this queue
+	 */
+	Queue<T> copyQueue() { // Exercise 2
+		Queue<T> Q2 = new Queue<T>();
+		// Add your code here
+		int size = list.size;
+		for (int i = 0; i < size; i++) {
+			T element = this.dequeue();
+			Q2.enqueue(element);
+			this.enqueue(element);
+		}
+		return Q2;
+	}
+
+	/**
+	 * Checks if this queue is identical to another queue in terms of content and
+	 * sequence.
+	 *
+	 * @param Q2 the queue to compare with
+	 * @return true if the queues are identical, false otherwise
+	 */
+	boolean isIdentical(Queue<T> Q2) {
+		// Exercise 3
+		if (Q2.list.getSize() != this.list.getSize()){
+			return false;
+		}
+		boolean identical = true;
+		int size = Q2.list.size;
+		Queue<T> copiedQ1 = this.copyQueue();
+		Queue<T> copiedQ2 = Q2.copyQueue();
+
+		for(int i = 0; i < size; i++){
+			T removedQ1 = copiedQ1.dequeue();
+			T removedQ2 = copiedQ2.dequeue();
+			if (removedQ1 == removedQ2){
+				copiedQ1.enqueue(removedQ1);
+				copiedQ2.enqueue(removedQ2);
+			}
+			else{
+				return !identical;
+			}
+		}
+		return identical;
+	}
+
+	/**
+	 * Prints the elements of the queue horizontally. Handles potential
+	 * 
+	 */
+	void printHorizontal() {
+		Node<T> walker = list.first;
+		while (walker != null) {
+			System.out.print(walker.element + " ");
+			walker = walker.next;
+		}
+
+	}
+
+}

LAB7_BinarySearchTree/LAB7_BinarySearchTree.iml

@@ -0,0 +1,252 @@
+/**
+ * The {@code SList} class represents a singly linked list that can hold
+ * elements of a generic type {@code T}. It provides methods for adding elements
+ * to the beginning and end of the list, adding elements at a specified index,
+ * removing elements from the beginning and end of the list, removing elements
+ * at a specified index, checking if the list is empty, obtaining the size of
+ * the list, and searching for elements within the list.
+ *
+ * @param <T> The type of elements stored in the singly linked list.
+ */
+public class SList<T> {
+	/**
+	 * The number of elements currently stored in the singly linked list.
+	 */
+	int size;
+	/**
+	 * The reference to the first node in the singly linked list.
+	 */
+	Node<T> first;
+	/**
+	 * The reference to the last node in the singly linked list.
+	 */
+	Node<T> last;
+
+	/**
+	 * Constructs an empty singly linked list with size 0.
+	 */
+	SList() {
+		size = 0;
+		first = null;
+		last = null;
+	}
+
+	/**
+	 * Adds a new element to the beginning of the singly linked list.
+	 *
+	 * @param element The element to be added to the list.
+	 */
+	void addFirst(T element) {
+		Node<T> newNode = new Node<T>(element);
+		newNode.next = first; //connect with the previous first
+		first = newNode; //update first
+		size++;
+		if (last == null)
+			last = first;
+	}
+
+	/**
+	 * Adds a new element to the end of the singly linked list.
+	 *
+	 * @param element The element to be added to the list.
+	 */
+	void addLast(T element) {
+		// Ex.1 complete the method
+		if (size == 0){
+			addFirst(element);
+		}
+
+		else if (size > 0){ //if we use 'if' instead of 'else if' it will generate
+			Node<T> newnode = new Node<T>(element);
+			last.next = newnode; //connect last with newnode
+			last = newnode; //update last
+			size++;
+		}
+	}
+
+	/**
+	 * Adds a new element at the specified index in the singly linked list. If the
+	 * index is 0, the element is added to the beginning of the list. If the index
+	 * is greater than or equal to the size, the element is added to the end of the
+	 * list.
+	 *
+	 * @param index   The index at which to add the element.
+	 * @param element The element to be added to the list.
+	 */
+	void addAtIndex(int index, T element) {
+		// Ex.2 complete the method
+		if (index <= 0){
+			addFirst(element); //add at index 0 is equal to addFirst(element)
+		}
+//		else if(index < 0){ (optional)
+//			return;
+//		}
+		else if(index >= size){
+			addLast(element); //add at last index or futher is equal to addLast(element)
+		}
+		else {
+			Node<T> current = first;
+			for (int i = 0; i < index-1; i++){
+				current = current.next; //access attributes of the node @i-1
+			}
+			Node<T> newnode = new Node<T>(element);
+			newnode.next = current.next; //connect newnode to the next one
+			current.next = newnode; //newnode is set to current.next
+			size++;
+		}
+	}
+
+	/**
+	 * Removes and returns the first element from the singly linked list.
+	 *
+	 * @return The removed element, or {@code null} if the list is empty.
+	 */
+	T removeFirst() {
+		if (size == 0) { //there's nothing to remove
+			return null;
+		} else if (size == 1) {
+			Node<T> temp = first;
+			first = null;
+			last = null; //if there's nothing left after removed, update last = null
+			size = 0;
+			return temp.element;
+		}
+		else if (size > 1){
+			Node<T> temp = first; //create temp node
+			first = first.next; //move first to the next one
+			size--;
+			return temp.element;
+		}
+		return null;
+	}
+
+	/**
+	 * Removes and returns the last element from the singly linked list.
+	 *
+	 * @return The removed element, or {@code null} if the list is empty.
+	 */
+	T removeLast() {
+		// Ex.3 complete the method
+		if (size == 0) {
+			return null;
+		} else if (size == 1){ //has just only one to remove, need to update first, last = null and size = 0
+			Node<T> temp = first;
+			first = null;
+			last = null;
+			size = 0;
+			return temp.element;
+		} else if (size > 1) {
+			Node<T> current = first;
+			for (int i = 0; i < size - 1; i++){ //access attributes of the 2nd last node
+				current = current.next;
+			}
+			//or access attributes of 2nd node by while loop
+//			while(current.next != last){
+//				current = current.next;
+//			}
+			Node<T> temp = last; //create temp node for removing
+			last = current; //update last to current (2nd last index)
+			last.next = null;  //unlink with the last node
+			size--;
+			return temp.element;
+		}
+		return null;
+	}
+
+	/**
+	 * Removes and returns the element at the specified index in the singly linked
+	 * list.
+	 *
+	 * @param index The index of the element to be removed.
+	 * @return The removed element, or {@code null} if the index is out of bounds.
+	 */
+	T removeAtIndex(int index) {
+		// Ex.4 complete the method
+		if (index <= 0){
+			return removeFirst();
+		} else if (index >= size) {
+			return removeLast();
+		}
+		else{
+			Node<T> current = first;
+			for(int i = 0; i < index - 1; i++){ //access attributes before the index node)
+				current = current.next;
+			}
+			Node<T> temp = current.next; //create temp node for index to be removed
+			current.next = temp.next; //connect the previous node with the next node (from temp)
+			temp.next = null; //break the link of nextnode
+			size--;
+			return temp.element;
+		}
+	}
+
+	/**
+	 * Searches for the first occurrence of a specified item in the singly linked
+	 * list and returns its index.
+	 *
+	 * @param item The item to search for.
+	 * @return The index of the first occurrence of the item, or {@code -1} if not
+	 *         found.
+	 */
+	int search(T item) {
+		// Ex.5 complete the method
+		Node<T> current = first;
+		int i = 0;
+		while(i < size && current.element != item){
+			current = current.next;
+			i++;
+		}
+		if (i <= size - 1) {
+			// The item was found in the list
+			return i;
+		} else {
+			// The item was not found in the list
+			return -1;
+		}
+
+	}
+
+	/**
+	 * Checks whether the singly linked list is empty.
+	 *
+	 * @return {@code true} if the list is empty, {@code false} otherwise.
+	 */
+	boolean isEmpty() {
+		if (size == 0)
+			return true;
+		else
+			return false;
+	}
+
+	/**
+	 * Returns the current size of the singly linked list.
+	 *
+	 * @return The number of elements in the list.
+	 */
+	int getSize() {
+
+		return size;
+	}
+	T getElementAtIndex(int index){
+		Node<T> current = first;
+		for (int i = 0; i < index; i++){
+			current = current.next;
+		}
+		return current.element;
+	}
+
+	/**
+	 * Prints the elements of the singly linked list horizontally, followed by a
+	 * horizontal line separator. This method is primarily used for debugging and
+	 * displaying the contents of the list.
+	 */
+	void printHorizontal() {
+		Node<T> walker = first;
+		for (int i = 0; i < size; i++) {
+			System.out.print(walker.element);
+			System.out.print(" ");
+			walker = walker.next;
+		}
+		System.out.println("\n-----");
+	}
+}

LAB7_BinarySearchTree/out/production/LAB7_BinarySearchTree/BST.class

@@ -0,0 +1,22 @@
+/**
+ * The {@code SListExtension} class provides utility methods for working with singly
+ * linked lists, specifically for printing the elements vertically.
+ */
+public class SListExtension {
+
+    /**
+     * Prints the elements of a singly linked list vertically.
+     *
+     * @param list The singly linked list to be printed vertically.
+     * @param <T>   The type of elements in the linked list.
+     */
+    public static <T> void printVertical(SList<T> list) {
+        Node<T> walker = list.first;
+        while (walker != null) {
+            System.out.println(walker.element);
+            walker = walker.next;
+        }
+        System.out.println("-----");
+    }
+    
+}

LAB7_BinarySearchTree/out/production/LAB7_BinarySearchTree/BT.class

@@ -0,0 +1,194 @@
+/**
+ * The {@code Stack<T>} class represents a generic stack data structure
+ * implemented using a singly linked list. It provides methods for push, pop,
+ * peek, copy, printing, binary conversion, and more.
+ *
+ * @param <T> The type of elements stored in the stack.
+ */
+class Stack<T> {
+
+	private SList<T> list = new SList<T>();
+
+	/**
+	 * Constructs an empty stack.
+	 */
+	Stack() {
+	}
+
+	/**
+	 * Pushes an element onto the top of the stack.
+	 *
+	 * @param element The element to be pushed onto the stack.
+	 */
+	void push(T element) {// Exercise 1a
+		list.addFirst(element);
+	}
+
+	/**
+	 * Removes and returns the element at the top of the stack.
+	 *
+	 * @return The element removed from the top of the stack.
+	 */
+	T pop() {// Exercise 1b
+
+		//T tmp =
+		return list.removeFirst();
+//		return null;
+	}
+
+	/**
+	 * Retrieves the element at the top of the stack without removing it.
+	 *
+	 * @return The element at the top of the stack.
+	 */
+	T peek() {// Exercise 1c
+	//	return list.getElementAtIndex(list.getSize() - 1);
+		return list.first.element;
+//		return null;
+	}
+
+	/**
+	 * Checks if the stack is empty.
+	 *
+	 * @return {@code true} if the stack is empty, {@code false} otherwise.
+	 */
+	boolean isEmpty() {
+
+		return list.isEmpty();
+	}
+
+	/**
+	 * Creates and returns a copy of the stack.
+	 *
+	 * @return A copy of the stack.
+	 */
+	Stack<T> copyStack() {
+		Stack<T> rvStack = reverseStack();
+		return rvStack.reverseStack();
+	}
+
+	/**
+	 * Prints the elements of the stack vertically.
+	 */
+	void printVertical() {
+		SListExtension.printVertical(list);
+	}
+
+	/**
+	 * Converts an integer to binary representation and prints it.
+	 *
+	 * @param x The integer to be converted to binary.
+	 */
+	static void binaryConversion(int x) {// Exercise 2
+		Stack<Integer> answer = new Stack<Integer>();
+		// Write your code here
+		if (x == 0){ //case num = 0
+			answer.push(0);
+		}
+		while (x > 0) {
+			answer.push(x%2);
+			x /= 2;
+		}
+		answer.printVertical();
+	}
+
+	/**
+	 * Reverses the order of elements in the stack.
+	 *
+	 * @return A new stack with the reversed order of elements.
+	 */
+	Stack<T> reverseStack() {// Exercise 3
+		Stack<T> S2 = new Stack<T>();
+		Stack<T> temp = new Stack<T>();
+
+		while (!this.isEmpty()) {
+			T e = this.pop(); //ori is just a variable name
+			S2.push(e); //push into reversedStack
+			temp.push(e); //push into temp stack
+		}
+		while (!temp.isEmpty()) { //to generate back original stack
+			T e = temp.pop();
+//			System.out.println(e);
+			this.push(e);
+//			push(temp.pop());
+			//pop from temp stack and push into a stack (to generate back original stack)
+		}
+		return S2;
+	}
+
+	/**
+	 * Checks if a given string is a palindrome (case-insensitive).
+	 *
+	 * @param word The string to be checked for palindrome.
+	 * @return {@code true} if the string is a palindrome, {@code false} otherwise.
+	 */
+	static boolean isPalindrome(String word) {// Exercise 4
+		Stack<Character> S1 = new Stack<Character>();
+		for (int i = 0; i < word.length(); i++){
+			S1.push(word.charAt(i));
+		}
+		Stack<Character> S2 = S1.reverseStack();
+		while (!S1.isEmpty()){
+			if (S1.pop() != S2.pop()){
+				return false;
+			}
+		}
+		return true;
+	}
+
+	/**
+	 * Checks if a string represents an integer.
+	 *
+	 * @param s The string to be checked.
+	 * @return {@code true} if the string represents an integer, {@code false}
+	 *         otherwise.
+	 */
+	public static boolean isInteger(String s) {
+		try {
+			Integer.parseInt(s);
+		} catch (NumberFormatException nfe) {
+			return false;
+		}
+		return true;
+	}
+
+	/**
+	 * Evaluates a postfix expression and returns the result.
+	 *
+	 * @param input The postfix expression as an array of strings.
+	 * @return The result of evaluating the postfix expression.
+	 */
+	public static Integer evalPostfix(String[] input) {// Exercise 5
+		Stack<Integer> S = new Stack<Integer>();
+		// Write your code here
+		for (int i = 0; i < input.length; i++){
+			if (isInteger(input[i])){
+				S.push(Integer.parseInt(input[i])); //to parse String to int
+			}
+			else if(input[i] == "+"){
+				S.push(S.pop() + S.pop());
+			}
+			else if (input[i] == "-"){
+				S.push(-1*(S.pop() - S.pop()));
+
+			}
+			else if (input[i] == "*"){
+				S.push(S.pop()*  S.pop());
+			}
+			else if (input[i] == "/"){
+				int divider = S.pop();
+				int dividend = S.pop();
+				S.push(dividend/divider);
+
+			}
+			else if (input[i] == "%"){
+				int divider = S.pop();
+				int dividend = S.pop();
+				S.push(dividend%divider);
+
+			}
+
+		}
+		return S.peek();
+		}
+}

LAB7_BinarySearchTree/out/production/LAB7_BinarySearchTree/BTNode.class

@@ -0,0 +1,100 @@
+
+public class TestBST {
+	public static void main(String[] args) {
+		BST<Integer> bst = new BST<Integer>();
+
+		// Ex1. Uncomment below to test insert() //////////////////////////////
+		System.out.println("Testing insert()...");
+		bst.insert(8);
+		bst.insert(19);
+		bst.insert(3);
+		bst.insert(9);
+		bst.insert(5);
+		bst.insert(1);
+		bst.insert(15);
+		System.out.print("BFT of your BST is    ");
+		bst.PrintBFT();
+		System.out.println("\nThe correct answer is 8 3 19 1 5 9 15\n\n");
+
+		System.out.print("Preorder of your BST is ");
+		bst.preorder();
+		System.out.println("\nThe correct answer is   8 3 1 5 19 9 15\n\n");
+
+		System.out.print("Inorder of your BST is ");
+		bst.inorder();
+		System.out.println("\nThe correct answer is  1 3 5 8 9 15 19\n\n");
+
+		System.out.print("Postorder of your BST is ");
+		bst.postorder();
+		System.out.println("\nThe correct answer is    1 5 3 15 9 19 8\n\n");
+		System.out.println("Height of your BST =  " + bst.findHeight());
+		System.out.println("The correct answer is 4");
+
+		// Ex2. Uncomment below to test delete() //////////////////////////////
+		/*System.out.println("\nTesting delete()...");
+
+		if (bst.delete(2) == null) {
+			System.out.println("bst.delete(2) is null");
+		}
+		System.out.println("The correct answer is null\n");
+
+		bst.delete(1);
+		System.out.print("BFT of your BST is    ");
+		bst.PrintBFT();
+		System.out.println("\nThe correct answer is 8 3 19 5 9 15\n");
+
+		bst.delete(19);
+		System.out.print("BFT of your BST is    ");
+		bst.PrintBFT();
+		System.out.println("\nThe correct answer is 8 3 9 5 15\n");
+
+		bst.delete(8);
+		System.out.print("BFT of your BST is    ");
+		bst.PrintBFT();
+		System.out.println("\nThe correct answer is 5 3 9 15\n");
+
+		bst.delete(3);
+		System.out.print("BFT of your BST is    ");
+		bst.PrintBFT();
+		System.out.println("\nThe correct answer is 5 9 15\n");
+
+		bst.delete(5);
+		System.out.print("BFT of your BST is    ");
+		bst.PrintBFT();
+		System.out.println("\nThe correct answer is 9 15\n");
+
+		System.out.println("Height of your BST =  " + bst.findHeight());
+		System.out.println("The correct answer is 2");*/
+
+		// Ex3. Uncomment below to test search() //////////////////////////////
+		/*System.out.println("\nTesting search()...");
+		if (bst.search(12)) {
+			System.out.println("12 is found");
+		} else {
+			System.out.println("12 is not found");
+		}
+		System.out.println("The correct answer is 12 is not found\n");
+
+		if (bst.search(15)) {
+			System.out.println("15 is found");
+		} else {
+			System.out.println("15 is not found");
+		}
+		System.out.println("The correct answer is 15 is found\n");*/
+
+		// Ex4. Uncomment below to test findSmallest() //////////////////////////////
+		/*bst.insert(1);
+		bst.insert(3);
+		bst.insert(19);
+		System.out.println("\nTesting findSmallest()...");
+		System.out.println("The smallest element is " + bst.findSmallest(bst.root).element);
+		System.out.println("The correct answer is 1\n");*/
+
+		// Ex5. Uncomment below to test findLargest() //////////////////////////////
+		/*System.out.println("\nTesting findLargest()...");
+		System.out.println("The largest element is " + bst.findLargest(bst.root).element);
+		System.out.println("The correct answer is 19");*/
+
+	}
+
+}