agh

Semester 4/Assignments/MP1_ManyToMany_CalebFontenot/nb-configuration.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project-shared-configuration>
+    <!--
+This file contains additional configuration written by modules in the NetBeans IDE.
+The configuration is intended to be shared among all the users of project and
+therefore it is assumed to be part of version control checkout.
+Without this configuration present, some functionality in the IDE may be limited or fail altogether.
+-->
+    <properties xmlns="http://www.netbeans.org/ns/maven-properties-data/1">
+        <!--
+Properties that influence various parts of the IDE, especially code formatting and the like. 
+You can copy and paste the single properties, into the pom.xml file and the IDE will pick them up.
+That way multiple projects can share the same settings (useful for formatting rules for example).
+Any value defined here will override the pom.xml file value but is only applicable to the current project.
+-->
+        <netbeans.hint.jdkPlatform>Graal_JDK_20</netbeans.hint.jdkPlatform>
+    </properties>
+</project-shared-configuration>

Semester 4/Assignments/MP1_ManyToMany_CalebFontenot/src/main/java/edu/slcc/asdv/caleb/mp1_manytomany_calebfontenot/ManyToManyFactory.java

@@ -27,7 +27,7 @@ public class ManyToManyFactory {
             createManyToMany()
     {
         return new ManyToMany<Many1, Many2>() {
-            private HashSet parents = new HashSet();
+            //private HashSet parents = new HashSet();
             
             private Map<Object, Object> left = new HashMap();
             private Map<Object, Object> right = new HashMap();
@@ -39,7 +39,9 @@ public class ManyToManyFactory {
             }
 
             /**
-             * Creates a Many to Many relationship between the parentLeft and the childrenRight. Example for ( Many1 a, Many2 1, 2, 3) it creates --> (a 1) ( a 2 ) ( a 3 ) and ( 1, a ), ( 2, a ), ( 3, a). No duplicate values of Many2 are allowed.
+             * Creates a Many to Many relationship between the parentLeft and the childrenRight. 
+             * Example for ( Many1 a, Many2 1, 2, 3) it creates --> (a 1) ( a 2 ) ( a 3 ) and ( 1, a ), ( 2, a ), ( 3, a). 
+             * No duplicate values of Many2 are allowed.
              *
              * @param parentLeft - exactly one Many1 object.
              * @param childrenRight - one or more Many2 objects.
@@ -53,17 +55,13 @@ public class ManyToManyFactory {
             public List<Many2> add(Many1 parentLeft, Many2... childrenRight)
             {
                 List<Many2> returnList = new ArrayList<Many2>();
-                // Check to see if values already exist in this many to many object
-                if (this.left != parentLeft && this.left != null) {
-                    returnList.add((Many2) this.left);
-                    this.left = (Map<Object, Object>) parentLeft;
-                }
-                if (this.left != childrenRight && this.right != null) {
-                    returnList.add((Many2) this.right);
-                    this.left = (Map<Object, Object>) childrenRight;
-                        left.put(parentLeft, Arrays.asList(childrenRight));
-                    
+                
+                // Check for exceptions
+                if (!childrenRight.equals(parentLeft.getClass())) {
+                    throw new ClassCastException();
                 }
+                left.put(parentLeft, new ArrayList<Many2>(Arrays.asList(childrenRight)));
+                return returnList;
             }
 
             @Override

Semester 4/Assignments/ProjectTrees_CalebFontenot/Printed HTMLs/TreeASDV.html

@@ -8,17 +8,18 @@
 body {color: #a9b7c6; background-color: #2b2b2b; font-family: monospace; font-weight: bold}
 pre {color: #a9b7c6; background-color: #2b2b2b; font-family: monospace; font-weight: bold}
 table {color: #888888; background-color: #313335; font-family: monospace; font-weight: bold}
-.number {color: #6897bb}
 .string {color: #6a8759}
-.ST1 {color: #9876aa}
-.ST2 {color: #ffc66d}
+.number {color: #6897bb}
+.ST2 {color: #9876aa}
+.ST3 {color: #ffc66d}
+.ST1 {color: #8a653b}
 .comment {color: #808080}
 .whitespace {color: #505050}
-.ST3 {color: #9876aa; font-family: monospace; font-weight: bold; font-style: italic}
-.ST5 {color: #ffc66d; font-family: monospace; font-weight: bold; font-style: italic}
+.ST4 {color: #9876aa; font-family: monospace; font-weight: bold; font-style: italic}
+.ST6 {color: #ffc66d; font-family: monospace; font-weight: bold; font-style: italic}
 .ST0 {color: #287bde}
 .literal {color: #cc7832}
-.ST4 {font-family: monospace; font-weight: bold; font-style: italic}
+.ST5 {font-family: monospace; font-weight: bold; font-style: italic}
 -->
 </style>
 </head>
@@ -31,138 +32,163 @@ table {color: #888888; background-color: #313335; font-family: monospace; font-w
 <span class="comment"> */</span>
 <span class="literal">package</span> edu.slcc.asdv.caleb.projecttrees_calebfontenot;
 
+<span class="literal">import</span> java.util.ArrayList;
+<span class="literal">import</span> java.util.Iterator;
 <span class="literal">import</span> java.util.LinkedList;
-<span class="literal">import</span> java.util.ListIterator;
+<span class="comment">import</span> <span class="comment">java</span><span class="comment">.</span><span class="comment">util</span><span class="comment">.</span><span class="comment">ListIterator</span><span class="comment">;</span>
 <span class="literal">import</span> java.util.Queue;
 <span class="literal">import</span> java.util.Stack;
 
 <span class="comment">/**</span>
 <span class="comment"> *</span>
 <span class="comment"> * </span><span class="comment">@author</span> <span class="comment">caleb</span>
+<span class="comment"> * </span><span class="comment">@param</span> <span class="ST1">&lt;T&gt;</span>
  <span class="comment">*/</span>
-<span class="literal">public</span> <span class="literal">class</span> TreeASDV&lt;T <span class="literal">extends</span> Comparable&gt; {
+<span class="literal">public</span> <span class="literal">class</span> TreeASDV&lt;T <span class="literal">extends</span> Comparable&gt; <span class="literal">implements</span> Cloneable {
 
-    <span class="literal">private</span> Node&lt;T&gt; <span class="ST1">root</span>;
+    <span class="literal">private</span> Node&lt;T&gt; <span class="ST2">root</span>;
 
     <span class="literal">class</span> Node&lt;T&gt; {
 
-        T <span class="ST1">data</span>;
-        Node&lt;T&gt; <span class="ST1">leftChild</span>;
-        Node&lt;T&gt; <span class="ST1">rightChild</span>;
+        T <span class="ST2">data</span>;
+        Node&lt;T&gt; <span class="ST2">leftChild</span>;
+        Node&lt;T&gt; <span class="ST2">rightChild</span>;
     }
 
-    <span class="literal">public</span> <span class="literal">boolean</span> <span class="ST2">insert</span>(T t) {
-        Node&lt;T&gt; newNode = <span class="literal">new</span> Node&lt;&gt;();
-        newNode.<span class="ST1">data</span> = t;
+    @Override
+    <span class="literal">public</span> Object <span class="ST3">clone</span>()
+    {
+        System.<span class="ST4">out</span>.println(<span class="string">&quot;</span><span class="string">Cloning...</span><span class="string">&quot;</span>);
+        TreeASDV&lt;T&gt; clone = <span class="literal">new</span> TreeASDV&lt;T&gt;();
+        ArrayList&lt;T&gt; oldData = <span class="literal">this</span>.getBreadthFirstArray();
+        <span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; oldData.size(); ++i) {
+            <span class="comment">//System.out.println(oldData.get(i));</span>
+            clone.insert(oldData.get(i));
+        }
+        <span class="literal">return</span> clone;
+    }
 
-        <span class="literal">if</span> (<span class="ST1">root</span> == <span class="literal">null</span>) {
-            <span class="ST1">root</span> = newNode;
+    <span class="literal">public</span> <span class="literal">boolean</span> <span class="ST3">insert</span>(T t)
+    {
+        Node&lt;T&gt; newNode = <span class="literal">new</span> Node&lt;&gt;();
+        newNode.<span class="ST2">data</span> = t;
+
+        <span class="literal">if</span> (<span class="ST2">root</span> == <span class="literal">null</span>) {
+            <span class="ST2">root</span> = newNode;
             <span class="literal">return</span> <span class="literal">true</span>;
         }
 
-        Node&lt;T&gt; current = <span class="ST1">root</span>;
+        Node&lt;T&gt; current = <span class="ST2">root</span>;
         Node&lt;T&gt; parent = <span class="literal">null</span>;
 
         <span class="literal">while</span> (current != <span class="literal">null</span>) {
             parent = current;
-            <span class="literal">if</span> (t.compareTo(current.<span class="ST1">data</span>) &gt;= <span class="number">0</span>) {
-                current = current.<span class="ST1">rightChild</span>;
+            <span class="literal">if</span> (t.compareTo(current.<span class="ST2">data</span>) &gt;= <span class="number">0</span>) {
+                current = current.<span class="ST2">rightChild</span>;
             } <span class="literal">else</span> {
-                current = current.<span class="ST1">leftChild</span>;
+                current = current.<span class="ST2">leftChild</span>;
             }
         }
 
         <span class="comment">// At this point, &#39;parent&#39; is the node where the new node should be inserted as a child</span>
-        <span class="literal">if</span> (t.compareTo(parent.<span class="ST1">data</span>) &gt;= <span class="number">0</span>) {
-            parent.<span class="ST1">rightChild</span> = newNode;
+        <span class="literal">if</span> (t.compareTo(parent.<span class="ST2">data</span>) &gt;= <span class="number">0</span>) {
+            parent.<span class="ST2">rightChild</span> = newNode;
         } <span class="literal">else</span> {
-            parent.<span class="ST1">leftChild</span> = newNode;
+            parent.<span class="ST2">leftChild</span> = newNode;
         }
 
         <span class="literal">return</span> <span class="literal">true</span>;
     }
 
-    <span class="literal">private</span> <span class="literal">void</span> <span class="ST2">inOrder</span>(Node&lt;T&gt; p) {
+    <span class="literal">private</span> <span class="literal">void</span> <span class="comment">inOrder</span>(Node&lt;T&gt; p)
+    {
         <span class="literal">if</span> (p == <span class="literal">null</span>) {
             <span class="literal">return</span>;
         }
 
-        inOrder(p.<span class="ST1">leftChild</span>);
-        System.<span class="ST3">out</span>.print(p.<span class="ST1">data</span> + <span class="string">&quot;</span> <span class="string">&quot;</span>);
-        inOrder(p.<span class="ST1">rightChild</span>);
+        inOrder(p.<span class="ST2">leftChild</span>);
+        System.<span class="ST4">out</span>.print(p.<span class="ST2">data</span> + <span class="string">&quot;</span> <span class="string">&quot;</span>);
+        inOrder(p.<span class="ST2">rightChild</span>);
     }
 
-    <span class="literal">public</span> <span class="literal">void</span> <span class="ST2">inOrder</span>() {
-        inOrder(<span class="literal">t</span><span class="literal">his</span>.<span class="ST1">root</span>);
-    }
-
-    <span class="literal">public</span> Node&lt;T&gt; <span class="ST2">findNode</span>(T t) {
-        Node&lt;T&gt; currentNode = <span class="ST1">root</span>;
+    <span class="literal">public</span> Node&lt;T&gt; <span class="ST3">findNode</span>(T t)
+    {
+        Node&lt;T&gt; currentNode = <span class="ST2">root</span>;
         <span class="literal">while</span> (currentNode != <span class="literal">null</span>) {
-            <span class="literal">if</span> (t.compareTo(currentNode.<span class="ST1">data</span>) == <span class="number">0</span>) {
+            <span class="literal">if</span> (t.compareTo(currentNode.<span class="ST2">data</span>) == <span class="number">0</span>) {
                 <span class="literal">return</span> currentNode;
-            } <span class="literal">else</span> <span class="literal">if</span> (t.compareTo(currentNode.<span class="ST1">data</span>) &gt; <span class="number">0</span>) {
-                currentNode = currentNode.<span class="ST1">rightChild</span>;
+            } <span class="literal">else</span> <span class="literal">if</span> (t.compareTo(currentNode.<span class="ST2">data</span>) &gt; <span class="number">0</span>) {
+                currentNode = currentNode.<span class="ST2">rightChild</span>;
             } <span class="literal">else</span> {
-                currentNode = currentNode.<span class="ST1">leftChild</span>;
+                currentNode = currentNode.<span class="ST2">leftChild</span>;
             }
         }
         <span class="literal">return</span> <span class="literal">null</span>;
     }
+    
+<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST3">remove</span>(T t) {
+    <span class="comment">// Initialize parent and current nodes for traversal</span>
+    Node&lt;T&gt; parent = <span class="literal">null</span>;
+    Node&lt;T&gt; current = <span class="ST2">root</span>;
 
-    <span class="literal">public</span> <span class="literal">boolean</span> <span class="ST2">remove</span>(T t) {
-        <span class="comment">// Initialize parent and current nodes for traversal</span>
-        Node&lt;T&gt; parent = <span class="literal">null</span>;
-        Node&lt;T&gt; current = <span class="ST1">root</span>;
-
-        <span class="comment">// Search for the node to be removed</span>
-        <span class="literal">while</span> (current != <span class="literal">null</span> &amp;&amp; !current.<span class="ST1">data</span>.equals(t)) {
-            parent = current;
-            <span class="literal">if</span> (t.compareTo(current.<span class="ST1">data</span>) &gt; <span class="number">0</span>) {
-                current = current.<span class="ST1">rightChild</span>;
-            } <span class="literal">else</span> {
-                current = current.<span class="ST1">leftChild</span>;
-            }
+    <span class="comment">// Search for the node to be removed</span>
+    <span class="literal">while</span> (current != <span class="literal">null</span> &amp;&amp; !current.<span class="ST2">data</span>.equals(t)) {
+        parent = current;
+        <span class="literal">if</span> (t.compareTo(current.<span class="ST2">data</span>) &gt; <span class="number">0</span>) {
+            current = current.<span class="ST2">rightChild</span>;
+        } <span class="literal">else</span> {
+            current = current.<span class="ST2">leftChild</span>;
         }
-
-        <span class="comment">// If node not found, return false</span>
-        <span class="literal">if</span> (current == <span class="literal">null</span>) {
-            <span class="literal">return</span> <span class="literal">false</span>;
-        }
-
-        <span class="comment">// Case 1: Node with no children</span>
-        <span class="literal">if</span> (current.<span class="ST1">leftChild</span> == <span class="literal">null</span> &amp;&amp; current.<span class="ST1">rightChild</span> == <span class="literal">null</span>) {
-            <span class="literal">if</span> (current == <span class="ST1">root</span>) {
-                <span class="ST1">root</span> = <span class="literal">null</span>; <span class="comment">// Removing root node</span>
-            } <span class="literal">else</span> <span class="literal">if</span> (parent.<span class="ST1">leftChild</span> == current) {
-                parent.<span class="ST1">leftChild</span> = <span class="literal">null</span>; <span class="comment">// Removing a left child</span>
-            } <span class="literal">else</span> {
-                parent.<span class="ST1">rightChild</span> = <span class="literal">null</span>; <span class="comment">// Removing a right child</span>
-            }
-        } <span class="comment">// Case 2: Node with one child</span>
-        <span class="literal">else</span> <span class="literal">if</span> (current.<span class="ST1">leftChild</span> == <span class="literal">null</span> || current.<span class="ST1">rightChild</span> == <span class="literal">null</span>) {
-            Node&lt;T&gt; child = (current.<span class="ST1">leftChild</span> != <span class="literal">null</span>) ? current.<span class="ST1">leftChild</span> : current.<span class="ST1">rightChild</span>;
-            <span class="literal">if</span> (current == <span class="ST1">root</span>) {
-                <span class="ST1">root</span> = child; <span class="comment">// Replace root with its child</span>
-            } <span class="literal">else</span> <span class="literal">if</span> (parent.<span class="ST1">leftChild</span> == current) {
-                parent.<span class="ST1">leftChild</span> = child; <span class="comment">// Replace parent&#39;s left child with the node&#39;s child</span>
-            } <span class="literal">else</span> {
-                parent.<span class="ST1">rightChild</span> = child; <span class="comment">// Replace parent&#39;s right child with the node&#39;s child</span>
-            }
-        } <span class="comment">// Case 3: Node with two children</span>
-        <span class="literal">else</span> {
-            Node&lt;T&gt; successor = getSuccessor(current);
-            current.<span class="ST1">data</span> = successor.<span class="ST1">data</span>; <span class="comment">// Replace data with successor&#39;s data</span>
-            <span class="comment">// Remove successor node (successor will have at most one right child)</span>
-            remove(successor.<span class="ST1">data</span>);
-        }
-
-        <span class="literal">return</span> <span class="literal">true</span>;
     }
 
+    <span class="comment">// If node not found, return false</span>
+    <span class="literal">if</span> (current == <span class="literal">null</span>) {
+        <span class="literal">return</span> <span class="literal">false</span>;
+    }
+
+    <span class="comment">// Case 1: Node with no children</span>
+    <span class="literal">if</span> (current.<span class="ST2">leftChild</span> == <span class="literal">null</span> &amp;&amp; current.<span class="ST2">rightChild</span> == <span class="literal">null</span>) {
+        <span class="literal">if</span> (current == <span class="ST2">root</span>) {
+            <span class="ST2">root</span> = <span class="literal">null</span>; <span class="comment">// Removing root node</span>
+        } <span class="literal">else</span> <span class="literal">if</span> (parent.<span class="ST2">leftChild</span> == current) {
+            parent.<span class="ST2">leftChild</span> = <span class="literal">null</span>; <span class="comment">// Removing a left child</span>
+        } <span class="literal">else</span> {
+            parent.<span class="ST2">rightChild</span> = <span class="literal">null</span>; <span class="comment">// Removing a right child</span>
+        }
+    } <span class="comment">// Case 2: Node with one child</span>
+    <span class="literal">else</span> <span class="literal">if</span> (current.<span class="ST2">leftChild</span> == <span class="literal">null</span> || current.<span class="ST2">rightChild</span> == <span class="literal">null</span>) {
+        Node&lt;T&gt; child = (current.<span class="ST2">leftChild</span> != <span class="literal">null</span>) ? current.<span class="ST2">leftChild</span> : current.<span class="ST2">rightChild</span>;
+        <span class="literal">if</span> (current == <span class="ST2">root</span>) {
+            <span class="ST2">root</span> = child; <span class="comment">// Replace root with its child</span>
+        } <span class="literal">else</span> <span class="literal">if</span> (parent.<span class="ST2">leftChild</span> == current) {
+            parent.<span class="ST2">leftChild</span> = child; <span class="comment">// Replace parent&#39;s left child with the node&#39;s child</span>
+        } <span class="literal">else</span> {
+            parent.<span class="ST2">rightChild</span> = child; <span class="comment">// Replace parent&#39;s right child with the node&#39;s child</span>
+        }
+    } <span class="comment">// Case 3: Node with two children</span>
+    <span class="literal">else</span> {
+        Node&lt;T&gt; successorParent = current;
+        Node&lt;T&gt; successor = current.<span class="ST2">rightChild</span>;
+        <span class="literal">while</span> (successor.<span class="ST2">leftChild</span> != <span class="literal">null</span>) {
+            successorParent = successor;
+            successor = successor.<span class="ST2">leftChild</span>;
+        }
+        current.<span class="ST2">data</span> = successor.<span class="ST2">data</span>; <span class="comment">// Replace data with successor&#39;s data</span>
+        <span class="literal">if</span> (successorParent == current) {
+            successorParent.<span class="ST2">rightChild</span> = successor.<span class="ST2">rightChild</span>;
+        } <span class="literal">else</span> {
+            successorParent.<span class="ST2">leftChild</span> = successor.<span class="ST2">rightChild</span>;
+        }
+    }
+
+    <span class="literal">return</span> <span class="literal">true</span>;
+}
+
+
 <span class="comment">// Helper method to find in-order successor of a node</span>
-    <span class="literal">private</span> Node&lt;T&gt; <span class="ST2">getSuccessor</span>(Node&lt;T&gt; node) {
-        Node&lt;T&gt; current = node.<span class="ST1">rightChild</span>;
+    <span class="literal">private</span> Node&lt;T&gt; <span class="comment">getSuccessor</span>(Node&lt;T&gt; node)
+    {
+        Node&lt;T&gt; current = node.<span class="ST2">rightChild</span>;
         Node&lt;T&gt; successorParent = node;
         Node&lt;T&gt; successor = node;
 
@@ -170,94 +196,172 @@ table {color: #888888; background-color: #313335; font-family: monospace; font-w
         <span class="literal">while</span> (current != <span class="literal">null</span>) {
             successorParent = successor;
             successor = current;
-            current = current.<span class="ST1">leftChild</span>;
+            current = current.<span class="ST2">leftChild</span>;
         }
 
         <span class="comment">// If the successor is not the right child of the node to be removed,</span>
         <span class="comment">// adjust the successor&#39;s parent&#39;s leftChild reference</span>
-        <span class="literal">if</span> (successor != node.<span class="ST1">rightChild</span>) {
-            successorParent.<span class="ST1">leftChild</span> = successor.<span class="ST1">rightChild</span>;
-            successor.<span class="ST1">rightChild</span> = node.<span class="ST1">rightChild</span>;
+        <span class="literal">if</span> (successor != node.<span class="ST2">rightChild</span>) {
+            successorParent.<span class="ST2">leftChild</span> = successor.<span class="ST2">rightChild</span>;
+            successor.<span class="ST2">rightChild</span> = node.<span class="ST2">rightChild</span>;
         }
 
         <span class="literal">return</span> successor;
     }
 
-    <span class="literal">public</span> ListIterator&lt;T&gt; <span class="ST2">listIterator</span>() {
-        <span class="comment">//ListIterator it = new ListIterator&lt;T&gt;();</span>
-        <span class="literal">return</span> <span class="literal">null</span>;
+    <span class="comment">// Inorder ListIterator</span>
+    <span class="literal">public</span> Iterator&lt;T&gt; <span class="ST3">listIterator</span>()
+    {
+        <span class="literal">return</span> <span class="literal">new</span> InorderIterator();
     }
 
-       <span class="literal">public</span> <span class="literal">void</span> <span class="ST2">breadthFirstTraversal</span>() {
-        <span class="literal">if</span> (<span class="ST1">root</span> == <span class="literal">null</span>) {
+    <span class="literal">private</span> <span class="literal">class</span> InorderIterator <span class="literal">implements</span> Iterator&lt;T&gt; {
+
+        <span class="literal">private</span> Stack&lt;Node&lt;T&gt;&gt; <span class="ST2">stack</span>;
+
+        <span class="literal">public</span> InorderIterator()
+        {
+            <span class="ST2">stack</span> = <span class="literal">new</span> Stack&lt;&gt;();
+            pushLeft(<span class="ST2">r</span><span class="ST2">oot</span>);
+        }
+
+        <span class="literal">private</span> <span class="literal">void</span> <span class="ST3">pushLeft</span>(Node&lt;T&gt; node)
+        {
+            <span class="literal">while</span> (node != <span class="literal">null</span>) {
+                <span class="ST2">stack</span>.push(node);
+                node = node.<span class="ST2">leftChild</span>;
+            }
+        }
+
+        @Override
+        <span class="literal">public</span> <span class="literal">boolean</span> <span class="ST3">hasNext</span>()
+        {
+            <span class="literal">return</span> !<span class="ST2">stack</span>.isEmpty();
+        }
+
+        @Override
+        <span class="literal">public</span> T <span class="ST3">next</span>()
+        {
+            <span class="literal">if</span> (!hasNext()) {
+                <span class="literal">throw</span> <span class="literal">new</span> java.util.NoSuchElementException();
+            }
+            Node&lt;T&gt; current = <span class="ST2">stack</span>.pop();
+            pushLeft(current.<span class="ST2">rightChild</span>);
+            <span class="literal">return</span> current.<span class="ST2">data</span>;
+        }
+
+        @Override
+        <span class="literal">public</span> <span class="literal">void</span> <span class="ST3">remove</span>()
+        {
+            <span class="literal">throw</span> <span class="literal">new</span> UnsupportedOperationException();
+        }
+    }
+    
+     <span class="literal">public</span> ArrayList&lt;T&gt; <span class="ST3">getBreadthFirstArray</span>()
+    {
+        ArrayList&lt;T&gt; returnArray = <span class="literal">new</span> ArrayList&lt;T&gt;();
+        <span class="literal">if</span> (<span class="ST2">root</span> == <span class="literal">null</span>) {
+            <span class="literal">return</span> returnArray;
+        }
+        Queue&lt;Node&lt;T&gt;&gt; queue = <span class="literal">new</span> LinkedList&lt;&gt;();
+        
+        queue.offer(<span class="ST2">r</span><span class="ST2">oot</span>);
+
+        <span class="literal">while</span> (!queue.isEmpty()) {
+            Node&lt;T&gt; current = queue.poll();
+            returnArray.add(current.<span class="ST2">data</span>);
+
+            <span class="literal">if</span> (current.<span class="ST2">leftChild</span> != <span class="literal">null</span>) {
+                queue.offer(current.<span class="ST2">leftChild</span>);
+            }
+            <span class="literal">if</span> (current.<span class="ST2">rightChild</span> != <span class="literal">null</span>) {
+                queue.offer(current.<span class="ST2">rightChild</span>);
+            }
+        }
+        <span class="literal">return</span> returnArray;
+    }
+
+    <span class="literal">public</span> <span class="literal">void</span> <span class="ST3">breadthFirstTraversal</span>()
+    {
+        <span class="literal">if</span> (<span class="ST2">root</span> == <span class="literal">null</span>) {
             <span class="literal">return</span>;
         }
 
         Queue&lt;Node&lt;T&gt;&gt; queue = <span class="literal">new</span> LinkedList&lt;&gt;();
-        queue.offer(<span class="ST1">r</span><span class="ST1">oot</span>);
+        queue.offer(<span class="ST2">r</span><span class="ST2">oot</span>);
 
         <span class="literal">while</span> (!queue.isEmpty()) {
             Node&lt;T&gt; current = queue.poll();
-            System.<span class="ST3">out</span>.print(current.<span class="ST1">data</span> + <span class="string">&quot;</span> <span class="string">&quot;</span>);
+            System.<span class="ST4">out</span>.print(current.<span class="ST2">data</span> + <span class="string">&quot;</span> <span class="string">&quot;</span>);
 
-            <span class="literal">if</span> (current.<span class="ST1">leftChild</span> != <span class="literal">null</span>) {
-                queue.offer(current.<span class="ST1">leftChild</span>);
+            <span class="literal">if</span> (current.<span class="ST2">leftChild</span> != <span class="literal">null</span>) {
+                queue.offer(current.<span class="ST2">leftChild</span>);
             }
-            <span class="literal">if</span> (current.<span class="ST1">rightChild</span> != <span class="literal">null</span>) {
-                queue.offer(current.<span class="ST1">rightChild</span>);
+            <span class="literal">if</span> (current.<span class="ST2">rightChild</span> != <span class="literal">null</span>) {
+                queue.offer(current.<span class="ST2">rightChild</span>);
             }
         }
     }
 
+       @Override
+    <span class="literal">public</span> <span class="literal">boolean</span> <span class="ST3">equals</span>(Object obj) {
+        <span class="literal">return</span> <span class="literal">this</span>.getBreadthFirstArray().equals(((TreeASDV) obj).getBreadthFirstArray());
+    }
     
-    <span class="literal">public</span> <span class="literal">int</span> <span class="ST2">height</span>() {
-        <span class="literal">return</span> calculateHeight(<span class="ST1">r</span><span class="ST1">oot</span>);
+    <span class="literal">public</span> <span class="literal">int</span> <span class="ST3">height</span>()
+    {
+        <span class="literal">return</span> calculateHeight(<span class="ST2">r</span><span class="ST2">oot</span>);
     }
 
-    <span class="literal">private</span> <span class="literal">int</span> <span class="ST2">calculateHeight</span>(Node&lt;T&gt; node) {
+    <span class="literal">private</span> <span class="literal">int</span> <span class="ST3">calculateHeight</span>(Node&lt;T&gt; node)
+    {
         <span class="literal">if</span> (node == <span class="literal">null</span>) {
             <span class="literal">return</span> <span class="number">0</span>;
         }
 
-        <span class="literal">int</span> leftHeight = calculateHeight(node.<span class="ST1">leftChild</span>);
-        <span class="literal">int</span> rightHeight = calculateHeight(node.<span class="ST1">rightChild</span>);
+        <span class="literal">int</span> leftHeight = calculateHeight(node.<span class="ST2">leftChild</span>);
+        <span class="literal">int</span> rightHeight = calculateHeight(node.<span class="ST2">rightChild</span>);
 
-        <span class="literal">return</span> <span class="number">1</span> + Math.<span class="ST4">max</span>(leftHeight, rightHeight);
+        <span class="literal">return</span> <span class="number">1</span> + Math.<span class="ST5">max</span>(leftHeight, rightHeight);
     }
-    
-    <span class="literal">public</span> <span class="literal">boolean</span> <span class="ST2">isFullBST</span>() {
+
+    <span class="literal">public</span> <span class="literal">boolean</span> <span class="ST3">isFullBST</span>()
+    {
         <span class="literal">int</span> height = height();
-        <span class="literal">int</span> nodeCount = countNodes(<span class="ST1">r</span><span class="ST1">oot</span>);
+        <span class="literal">int</span> nodeCount = countNodes(<span class="ST2">r</span><span class="ST2">oot</span>);
         <span class="literal">return</span> nodeCount == (<span class="number">1</span> &lt;&lt; height) - <span class="number">1</span>; <span class="comment">// Formula for full binary tree</span>
     }
 
-    <span class="literal">private</span> <span class="literal">int</span> <span class="ST2">countNodes</span>(Node&lt;T&gt; node) {
+    <span class="literal">private</span> <span class="literal">int</span> <span class="ST3">countNodes</span>(Node&lt;T&gt; node)
+    {
         <span class="literal">if</span> (node == <span class="literal">null</span>) {
             <span class="literal">return</span> <span class="number">0</span>;
         }
-        <span class="literal">return</span> <span class="number">1</span> + countNodes(node.<span class="ST1">leftChild</span>) + countNodes(node.<span class="ST1">rightChild</span>);
+        <span class="literal">return</span> <span class="number">1</span> + countNodes(node.<span class="ST2">leftChild</span>) + countNodes(node.<span class="ST2">rightChild</span>);
     }
-    
-    <span class="literal">public</span> <span class="literal">void</span> <span class="ST2">inorder</span>() {
-        <span class="literal">if</span> (<span class="ST1">root</span> == <span class="literal">null</span>) {
+
+    <span class="literal">public</span> <span class="literal">void</span> <span class="ST3">inOrder</span>()
+    {
+        <span class="literal">if</span> (<span class="ST2">root</span> == <span class="literal">null</span>) {
             <span class="literal">return</span>;
         }
 
         Stack&lt;Node&lt;T&gt;&gt; stack = <span class="literal">new</span> Stack&lt;&gt;();
-        Node&lt;T&gt; current = <span class="ST1">root</span>;
+        Node&lt;T&gt; current = <span class="ST2">root</span>;
 
         <span class="literal">while</span> (current != <span class="literal">null</span> || !stack.isEmpty()) {
             <span class="literal">while</span> (current != <span class="literal">null</span>) {
                 stack.push(current);
-                current = current.<span class="ST1">leftChild</span>;
+                current = current.<span class="ST2">leftChild</span>;
             }
             current = stack.pop();
-            System.<span class="ST3">out</span>.print(current.<span class="ST1">data</span> + <span class="string">&quot;</span> <span class="string">&quot;</span>);
-            current = current.<span class="ST1">rightChild</span>;
+            System.<span class="ST4">out</span>.print(current.<span class="ST2">data</span> + <span class="string">&quot;</span> <span class="string">&quot;</span>);
+            current = current.<span class="ST2">rightChild</span>;
         }
     }
 
-    <span class="literal">public</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST5">main</span>(String[] args) {
+    <span class="literal">public</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST6">main</span>(String[] args) <span class="literal">throws</span> CloneNotSupportedException
+    {
         TreeASDV&lt;Integer&gt; tree = <span class="literal">new</span> TreeASDV&lt;&gt;();
         <span class="comment">// Insert some elements into the tree</span>
         tree.insert(<span class="number">5</span>);
@@ -269,20 +373,31 @@ table {color: #888888; background-color: #313335; font-family: monospace; font-w
         tree.insert(<span class="number">8</span>);
 
         <span class="comment">// Test breadth-first traversal</span>
-        System.<span class="ST3">out</span>.println(<span class="string">&quot;</span><span class="string">Breadth-First Traversal:</span><span class="string">&quot;</span>);
+        System.<span class="ST4">out</span>.println(<span class="string">&quot;</span><span class="string">Breadth-First Traversal:</span><span class="string">&quot;</span>);
         tree.breadthFirstTraversal();
-        System.<span class="ST3">out</span>.println();
+        System.<span class="ST4">out</span>.println();
 
         <span class="comment">// Test height calculation</span>
-        System.<span class="ST3">out</span>.println(<span class="string">&quot;</span><span class="string">Height of the tree: </span><span class="string">&quot;</span> + tree.height());
+        System.<span class="ST4">out</span>.println(<span class="string">&quot;</span><span class="string">Height of the tree: </span><span class="string">&quot;</span> + tree.height());
 
         <span class="comment">// Test if the tree is a full binary tree</span>
-        System.<span class="ST3">out</span>.println(<span class="string">&quot;</span><span class="string">Is the tree a full binary tree? </span><span class="string">&quot;</span> + tree.isFullBST());
+        System.<span class="ST4">out</span>.println(<span class="string">&quot;</span><span class="string">Is the tree a full binary tree? </span><span class="string">&quot;</span> + tree.isFullBST());
 
         <span class="comment">// Test inorder traversal without recursion</span>
-        System.<span class="ST3">out</span>.println(<span class="string">&quot;</span><span class="string">Inorder Traversal without Recursion:</span><span class="string">&quot;</span>);
-        tree.inorder();
-        System.<span class="ST3">out</span>.println();
+        System.<span class="ST4">out</span>.println(<span class="string">&quot;</span><span class="string">Inorder Traversal without Recursion:</span><span class="string">&quot;</span>);
+        tree.inOrder();
+        System.<span class="ST4">out</span>.println();
+        System.<span class="ST4">out</span>.println(<span class="string">&quot;</span><span class="string">array list from breadth traversal</span><span class="string">&quot;</span>);
+        System.<span class="ST4">out</span>.println(tree.getBreadthFirstArray());
+        System.<span class="ST4">out</span>.println(<span class="string">&quot;</span><span class="string">Cloned Tree:</span><span class="string">&quot;</span>);
+        TreeASDV&lt;Integer&gt; clonedTree = (TreeASDV&lt;Integer&gt;) tree.clone();
+        clonedTree.breadthFirstTraversal();
+        System.<span class="ST4">out</span>.println();
+        System.<span class="ST4">out</span>.println(<span class="string">&quot;</span><span class="string">Does the original tree and the clone tree equal? </span><span class="string">&quot;</span> + (tree.equals(clonedTree) ? <span class="string">&quot;</span><span class="string">yes</span><span class="string">&quot;</span> : <span class="string">&quot;</span><span class="string">no</span><span class="string">&quot;</span>) );
+        tree.insert(<span class="number">3</span><span class="number">000000</span>);
+        System.<span class="ST4">out</span>.println(<span class="string">&quot;</span><span class="string">Does the original tree and the clone tree equal? </span><span class="string">&quot;</span> + (tree.equals(clonedTree) ? <span class="string">&quot;</span><span class="string">yes</span><span class="string">&quot;</span> : <span class="string">&quot;</span><span class="string">no</span><span class="string">&quot;</span>) );
+        tree.remove(<span class="number">5</span>);
+        tree.breadthFirstTraversal();
     }
 }
 

Semester 4/Assignments/ProjectTrees_CalebFontenot/src/main/java/edu/slcc/asdv/caleb/projecttrees_calebfontenot/TreeASDV.java

@@ -98,57 +98,65 @@ public class TreeASDV<T extends Comparable> implements Cloneable {
         return null;
     }
     
-    public boolean remove(T t)
-    {
-        // Initialize parent and current nodes for traversal
-        Node<T> parent = null;
-        Node<T> current = root;
+public boolean remove(T t) {
+    // Initialize parent and current nodes for traversal
+    Node<T> parent = null;
+    Node<T> current = root;
 
-        // Search for the node to be removed
-        while (current != null && !current.data.equals(t)) {
-            parent = current;
-            if (t.compareTo(current.data) > 0) {
-                current = current.rightChild;
-            } else {
-                current = current.leftChild;
-            }
+    // Search for the node to be removed
+    while (current != null && !current.data.equals(t)) {
+        parent = current;
+        if (t.compareTo(current.data) > 0) {
+            current = current.rightChild;
+        } else {
+            current = current.leftChild;
         }
-
-        // If node not found, return false
-        if (current == null) {
-            return false;
-        }
-
-        // Case 1: Node with no children
-        if (current.leftChild == null && current.rightChild == null) {
-            if (current == root) {
-                root = null; // Removing root node
-            } else if (parent.leftChild == current) {
-                parent.leftChild = null; // Removing a left child
-            } else {
-                parent.rightChild = null; // Removing a right child
-            }
-        } // Case 2: Node with one child
-        else if (current.leftChild == null || current.rightChild == null) {
-            Node<T> child = (current.leftChild != null) ? current.leftChild : current.rightChild;
-            if (current == root) {
-                root = child; // Replace root with its child
-            } else if (parent.leftChild == current) {
-                parent.leftChild = child; // Replace parent's left child with the node's child
-            } else {
-                parent.rightChild = child; // Replace parent's right child with the node's child
-            }
-        } // Case 3: Node with two children
-        else {
-            Node<T> successor = getSuccessor(current);
-            current.data = successor.data; // Replace data with successor's data
-            // Remove successor node (successor will have at most one right child)
-            remove(successor.data);
-        }
-
-        return true;
     }
 
+    // If node not found, return false
+    if (current == null) {
+        return false;
+    }
+
+    // Case 1: Node with no children
+    if (current.leftChild == null && current.rightChild == null) {
+        if (current == root) {
+            root = null; // Removing root node
+        } else if (parent.leftChild == current) {
+            parent.leftChild = null; // Removing a left child
+        } else {
+            parent.rightChild = null; // Removing a right child
+        }
+    } // Case 2: Node with one child
+    else if (current.leftChild == null || current.rightChild == null) {
+        Node<T> child = (current.leftChild != null) ? current.leftChild : current.rightChild;
+        if (current == root) {
+            root = child; // Replace root with its child
+        } else if (parent.leftChild == current) {
+            parent.leftChild = child; // Replace parent's left child with the node's child
+        } else {
+            parent.rightChild = child; // Replace parent's right child with the node's child
+        }
+    } // Case 3: Node with two children
+    else {
+        Node<T> successorParent = current;
+        Node<T> successor = current.rightChild;
+        while (successor.leftChild != null) {
+            successorParent = successor;
+            successor = successor.leftChild;
+        }
+        current.data = successor.data; // Replace data with successor's data
+        if (successorParent == current) {
+            successorParent.rightChild = successor.rightChild;
+        } else {
+            successorParent.leftChild = successor.rightChild;
+        }
+    }
+
+    return true;
+}
+
+
 // Helper method to find in-order successor of a node
     private Node<T> getSuccessor(Node<T> node)
     {
@@ -360,5 +368,7 @@ public class TreeASDV<T extends Comparable> implements Cloneable {
         System.out.println("Does the original tree and the clone tree equal? " + (tree.equals(clonedTree) ? "yes" : "no") );
         tree.insert(3000000);
         System.out.println("Does the original tree and the clone tree equal? " + (tree.equals(clonedTree) ? "yes" : "no") );
+        tree.remove(5);
+        tree.breadthFirstTraversal();
     }
 }