CCF_100/ASDV-Java
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Reset author name to chosen name ✨

Browse Source
This commit is contained in:
Chloe Fontenot 🏳️‍⚧️
2025-10-19 21:55:26 -05:00
parent a3e71f9673
commit 03c2474f78
1825 changed files with 8916 additions and 8921 deletions
Download Patch File Download Diff File Expand all files Collapse all files

405
Semester 4/Assignments/ProjectTrees_ChloeFontenot/Printed HTMLs/TreeASDV.html Normal file
View File

@@ -0,0 +1,405 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>TreeASDV.java</title>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<style type="text/css">
<!--
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}
.string {color: #6a8759}
.number {color: #6897bb}
.ST2 {color: #9876aa}
.ST3 {color: #ffc66d}
.ST1 {color: #8a653b}
.comment {color: #808080}
.whitespace {color: #505050}
.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}
.ST5 {font-family: monospace; font-weight: bold; font-style: italic}
-->
</style>
</head>
<body>
<table width="100%"><tr><td align="center">/home/chloe/ASDV-Java/Semester 4/Assignments/ProjectTrees_ChloeFontenot/src/main/java/edu/slcc/asdv/chloe/projecttrees_chloefontenot/TreeASDV.java</td></tr></table>
<pre>
<span class="comment">/*</span>
<span class="comment"> * Click </span><span class="ST0">nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt</span><span class="comment"> to change this license</span>
<span class="comment"> * Click </span><span class="ST0">nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java</span><span class="comment"> to edit this template</span>
<span class="comment"> */</span>
<span class="literal">package</span> edu.slcc.asdv.chloe.projecttrees_chloefontenot;
<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="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">chloe</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">implements</span> Cloneable {
<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="ST2">data</span>;
Node&lt;T&gt; <span class="ST2">leftChild</span>;
Node&lt;T&gt; <span class="ST2">rightChild</span>;
}
@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">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="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="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">// 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="ST2">data</span>) &gt;= <span class="number">0</span>) {
parent.<span class="ST2">rightChild</span> = newNode;
} <span class="literal">else</span> {
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="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="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> 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="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="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="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="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="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="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;
<span class="comment">// Find the leftmost node in the right subtree (in-order successor)</span>
<span class="literal">while</span> (current != <span class="literal">null</span>) {
successorParent = successor;
successor = current;
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="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="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">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="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="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="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>);
}
}
}
@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="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="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="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="ST5">max</span>(leftHeight, rightHeight);
}
<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="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="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="ST2">leftChild</span>) + countNodes(node.<span class="ST2">rightChild</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="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="ST2">leftChild</span>;
}
current = stack.pop();
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="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>);
tree.insert(<span class="number">3</span>);
tree.insert(<span class="number">7</span>);
tree.insert(<span class="number">2</span>);
tree.insert(<span class="number">4</span>);
tree.insert(<span class="number">6</span>);
tree.insert(<span class="number">8</span>);
<span class="comment">// Test breadth-first traversal</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="ST4">out</span>.println();
<span class="comment">// Test height calculation</span>
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="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="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();
}
}
</pre></body>
</html>

18
Semester 4/Assignments/ProjectTrees_ChloeFontenot/nb-configuration.xml Normal file
View File

@@ -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>

14
Semester 4/Assignments/ProjectTrees_ChloeFontenot/pom.xml Normal file
View File

@@ -0,0 +1,14 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>edu.slcc.asdv.chloe</groupId>
<artifactId>ProjectTrees_ChloeFontenot</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>20</maven.compiler.source>
<maven.compiler.target>20</maven.compiler.target>
<exec.mainClass>edu.slcc.asdv.chloe.projecttrees_chloefontenot.ProjectTrees_ChloeFontenot</exec.mainClass>
</properties>
</project>

16
Semester 4/Assignments/ProjectTrees_ChloeFontenot/src/main/java/edu/slcc/asdv/caleb/projecttrees_calebfontenot/ProjectTrees_CalebFontenot.java Normal file
View File

@@ -0,0 +1,16 @@
/*
* Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
*/
package edu.slcc.asdv.chloe.projecttrees_chloefontenot;
/**
*
* @author chloe
*/
public class ProjectTrees_ChloeFontenot {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}

374
Semester 4/Assignments/ProjectTrees_ChloeFontenot/src/main/java/edu/slcc/asdv/caleb/projecttrees_calebfontenot/TreeASDV.java Normal file
View File

@@ -0,0 +1,374 @@
/*
* Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
* Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
*/
package edu.slcc.asdv.chloe.projecttrees_chloefontenot;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.Queue;
import java.util.Stack;
/**
*
* @author chloe
* @param <T>
*/
public class TreeASDV<T extends Comparable> implements Cloneable {
private Node<T> root;
class Node<T> {
T data;
Node<T> leftChild;
Node<T> rightChild;
}
@Override
public Object clone()
{
System.out.println("Cloning...");
TreeASDV<T> clone = new TreeASDV<T>();
ArrayList<T> oldData = this.getBreadthFirstArray();
for (int i = 0; i < oldData.size(); ++i) {
//System.out.println(oldData.get(i));
clone.insert(oldData.get(i));
}
return clone;
}
public boolean insert(T t)
{
Node<T> newNode = new Node<>();
newNode.data = t;
if (root == null) {
root = newNode;
return true;
}
Node<T> current = root;
Node<T> parent = null;
while (current != null) {
parent = current;
if (t.compareTo(current.data) >= 0) {
current = current.rightChild;
} else {
current = current.leftChild;
}
}
// At this point, 'parent' is the node where the new node should be inserted as a child
if (t.compareTo(parent.data) >= 0) {
parent.rightChild = newNode;
} else {
parent.leftChild = newNode;
}
return true;
}
private void inOrder(Node<T> p)
{
if (p == null) {
return;
}
inOrder(p.leftChild);
System.out.print(p.data + " ");
inOrder(p.rightChild);
}
public Node<T> findNode(T t)
{
Node<T> currentNode = root;
while (currentNode != null) {
if (t.compareTo(currentNode.data) == 0) {
return currentNode;
} else if (t.compareTo(currentNode.data) > 0) {
currentNode = currentNode.rightChild;
} else {
currentNode = currentNode.leftChild;
}
}
return null;
}
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;
}
}
// 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)
{
Node<T> current = node.rightChild;
Node<T> successorParent = node;
Node<T> successor = node;
// Find the leftmost node in the right subtree (in-order successor)
while (current != null) {
successorParent = successor;
successor = current;
current = current.leftChild;
}
// If the successor is not the right child of the node to be removed,
// adjust the successor's parent's leftChild reference
if (successor != node.rightChild) {
successorParent.leftChild = successor.rightChild;
successor.rightChild = node.rightChild;
}
return successor;
}
// Inorder ListIterator
public Iterator<T> listIterator()
{
return new InorderIterator();
}
private class InorderIterator implements Iterator<T> {
private Stack<Node<T>> stack;
public InorderIterator()
{
stack = new Stack<>();
pushLeft(root);
}
private void pushLeft(Node<T> node)
{
while (node != null) {
stack.push(node);
node = node.leftChild;
}
}
@Override
public boolean hasNext()
{
return !stack.isEmpty();
}
@Override
public T next()
{
if (!hasNext()) {
throw new java.util.NoSuchElementException();
}
Node<T> current = stack.pop();
pushLeft(current.rightChild);
return current.data;
}
@Override
public void remove()
{
throw new UnsupportedOperationException();
}
}
public ArrayList<T> getBreadthFirstArray()
{
ArrayList<T> returnArray = new ArrayList<T>();
if (root == null) {
return returnArray;
}
Queue<Node<T>> queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()) {
Node<T> current = queue.poll();
returnArray.add(current.data);
if (current.leftChild != null) {
queue.offer(current.leftChild);
}
if (current.rightChild != null) {
queue.offer(current.rightChild);
}
}
return returnArray;
}
public void breadthFirstTraversal()
{
if (root == null) {
return;
}
Queue<Node<T>> queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()) {
Node<T> current = queue.poll();
System.out.print(current.data + " ");
if (current.leftChild != null) {
queue.offer(current.leftChild);
}
if (current.rightChild != null) {
queue.offer(current.rightChild);
}
}
}
@Override
public boolean equals(Object obj) {
return this.getBreadthFirstArray().equals(((TreeASDV) obj).getBreadthFirstArray());
}
public int height()
{
return calculateHeight(root);
}
private int calculateHeight(Node<T> node)
{
if (node == null) {
return 0;
}
int leftHeight = calculateHeight(node.leftChild);
int rightHeight = calculateHeight(node.rightChild);
return 1 + Math.max(leftHeight, rightHeight);
}
public boolean isFullBST()
{
int height = height();
int nodeCount = countNodes(root);
return nodeCount == (1 << height) - 1; // Formula for full binary tree
}
private int countNodes(Node<T> node)
{
if (node == null) {
return 0;
}
return 1 + countNodes(node.leftChild) + countNodes(node.rightChild);
}
public void inOrder()
{
if (root == null) {
return;
}
Stack<Node<T>> stack = new Stack<>();
Node<T> current = root;
while (current != null || !stack.isEmpty()) {
while (current != null) {
stack.push(current);
current = current.leftChild;
}
current = stack.pop();
System.out.print(current.data + " ");
current = current.rightChild;
}
}
public static void main(String[] args) throws CloneNotSupportedException
{
TreeASDV<Integer> tree = new TreeASDV<>();
// Insert some elements into the tree
tree.insert(5);
tree.insert(3);
tree.insert(7);
tree.insert(2);
tree.insert(4);
tree.insert(6);
tree.insert(8);
// Test breadth-first traversal
System.out.println("Breadth-First Traversal:");
tree.breadthFirstTraversal();
System.out.println();
// Test height calculation
System.out.println("Height of the tree: " + tree.height());
// Test if the tree is a full binary tree
System.out.println("Is the tree a full binary tree? " + tree.isFullBST());
// Test inorder traversal without recursion
System.out.println("Inorder Traversal without Recursion:");
tree.inOrder();
System.out.println();
System.out.println("array list from breadth traversal");
System.out.println(tree.getBreadthFirstArray());
System.out.println("Cloned Tree:");
TreeASDV<Integer> clonedTree = (TreeASDV<Integer>) tree.clone();
clonedTree.breadthFirstTraversal();
System.out.println();
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();
}
}