From ad38d6421986ccb6e8c23bd04c05f247074e7073 Mon Sep 17 00:00:00 2001 From: Caleb Fontenot Date: Wed, 31 Jan 2024 16:28:12 -0600 Subject: [PATCH] honey, its time for you to learn something else in java! \n yes honey... :depressed: --- .gitignore | 3 + Semester 4/Assignments/HashMapASDV/pom.xml | 14 + .../asdv/caleb/hashmapasdv/HashMapASDV.java | 16 + .../Assignments/HashMapASDV_Ant/ListASDV.jar | Bin 0 -> 20176 bytes .../Assignments/HashMapASDV_Ant/build.xml | 73 + .../Assignments/HashMapASDV_Ant/manifest.mf | 3 + .../HashMapASDV_Ant/nbproject/build-impl.xml | 1771 +++++++++++++++++ .../nbproject/genfiles.properties | 8 + .../nbproject/project.properties | 99 + .../HashMapASDV_Ant/nbproject/project.xml | 15 + .../src/hashmapasdv_ant/EntryASDV.java | 91 + .../src/hashmapasdv_ant/ListASDV.java | 1713 ++++++++++++++++ .../projecttrees_calebfontenot/TreeASDV.java | 152 +- 13 files changed, 3934 insertions(+), 24 deletions(-) create mode 100644 Semester 4/Assignments/HashMapASDV/pom.xml create mode 100644 Semester 4/Assignments/HashMapASDV/src/main/java/edu/slcc/asdv/caleb/hashmapasdv/HashMapASDV.java create mode 100644 Semester 4/Assignments/HashMapASDV_Ant/ListASDV.jar create mode 100644 Semester 4/Assignments/HashMapASDV_Ant/build.xml create mode 100644 Semester 4/Assignments/HashMapASDV_Ant/manifest.mf create mode 100644 Semester 4/Assignments/HashMapASDV_Ant/nbproject/build-impl.xml create mode 100644 Semester 4/Assignments/HashMapASDV_Ant/nbproject/genfiles.properties create mode 100644 Semester 4/Assignments/HashMapASDV_Ant/nbproject/project.properties create mode 100644 Semester 4/Assignments/HashMapASDV_Ant/nbproject/project.xml create mode 100644 Semester 4/Assignments/HashMapASDV_Ant/src/hashmapasdv_ant/EntryASDV.java create mode 100644 Semester 4/Assignments/HashMapASDV_Ant/src/hashmapasdv_ant/ListASDV.java diff --git a/.gitignore b/.gitignore index 4042a10..c27dd3b 100644 --- a/.gitignore +++ b/.gitignore @@ -200,3 +200,6 @@ /Semester 4/Assignments/DataStructures/target/ /MergeSort/target/ /Semester 3/Exams/ProgrammingExam2_CalebFontenot/target/ +/Semester 4/Assignments/HashMapASDV_Ant/nbproject/private/ +/Semester 4/Assignments/HashMapASDV_Ant/build/ +/Semester 4/Assignments/HashMapASDV_Ant/dist/ diff --git a/Semester 4/Assignments/HashMapASDV/pom.xml b/Semester 4/Assignments/HashMapASDV/pom.xml new file mode 100644 index 0000000..01d5ebb --- /dev/null +++ b/Semester 4/Assignments/HashMapASDV/pom.xml @@ -0,0 +1,14 @@ + + + 4.0.0 + edu.slcc.asdv.caleb + HashMapASDV + 1.0-SNAPSHOT + jar + + UTF-8 + 20 + 20 + edu.slcc.asdv.caleb.hashmapasdv.HashMapASDV + + \ No newline at end of file diff --git a/Semester 4/Assignments/HashMapASDV/src/main/java/edu/slcc/asdv/caleb/hashmapasdv/HashMapASDV.java b/Semester 4/Assignments/HashMapASDV/src/main/java/edu/slcc/asdv/caleb/hashmapasdv/HashMapASDV.java new file mode 100644 index 0000000..a888efc --- /dev/null +++ b/Semester 4/Assignments/HashMapASDV/src/main/java/edu/slcc/asdv/caleb/hashmapasdv/HashMapASDV.java @@ -0,0 +1,16 @@ +/* + * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license + */ + +package edu.slcc.asdv.caleb.hashmapasdv; + +/** + * + * @author caleb + */ +public class HashMapASDV { + + public static void main(String[] args) { + System.out.println("Hello World!"); + } +} diff --git a/Semester 4/Assignments/HashMapASDV_Ant/ListASDV.jar b/Semester 4/Assignments/HashMapASDV_Ant/ListASDV.jar new file mode 100644 index 0000000000000000000000000000000000000000..40b491362da3c642f52ad9c520941f6fd9840b57 GIT binary patch literal 20176 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 RaT)^R=j1zN literal 0 HcmV?d00001 diff --git a/Semester 4/Assignments/HashMapASDV_Ant/build.xml b/Semester 4/Assignments/HashMapASDV_Ant/build.xml new file mode 100644 index 0000000..0d69356 --- /dev/null +++ b/Semester 4/Assignments/HashMapASDV_Ant/build.xml @@ -0,0 +1,73 @@ + + + + + + + + + + + Builds, tests, and runs the project HashMapASDV_Ant. + + + diff --git a/Semester 4/Assignments/HashMapASDV_Ant/manifest.mf b/Semester 4/Assignments/HashMapASDV_Ant/manifest.mf new file mode 100644 index 0000000..328e8e5 --- /dev/null +++ b/Semester 4/Assignments/HashMapASDV_Ant/manifest.mf @@ -0,0 +1,3 @@ +Manifest-Version: 1.0 +X-COMMENT: Main-Class will be added automatically by build + diff --git a/Semester 4/Assignments/HashMapASDV_Ant/nbproject/build-impl.xml b/Semester 4/Assignments/HashMapASDV_Ant/nbproject/build-impl.xml new file mode 100644 index 0000000..aa86cf0 --- /dev/null +++ b/Semester 4/Assignments/HashMapASDV_Ant/nbproject/build-impl.xml @@ -0,0 +1,1771 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Must set src.dir + Must set test.src.dir + Must set build.dir + Must set dist.dir + Must set build.classes.dir + Must set dist.javadoc.dir + Must set build.test.classes.dir + Must set build.test.results.dir + Must set build.classes.excludes + Must set dist.jar + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Must set javac.includes + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + No tests executed. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Must set JVM to use for profiling in profiler.info.jvm + Must set profiler agent JVM arguments in profiler.info.jvmargs.agent + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Must select some files in the IDE or set javac.includes + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + To run this application from the command line without Ant, try: + + java -jar "${dist.jar.resolved}" + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Must select one file in the IDE or set run.class + + + + Must select one file in the IDE or set run.class + + + + + + + + + + + + + + + + + + + + + + + Must select one file in the IDE or set debug.class + + + + + Must select one file in the IDE or set debug.class + + + + + Must set fix.includes + + + + + + + + + + This target only works when run from inside the NetBeans IDE. + + + + + + + + + Must select one file in the IDE or set profile.class + This target only works when run from inside the NetBeans IDE. + + + + + + + + + This target only works when run from inside the NetBeans IDE. + + + + + + + + + + + + + This target only works when run from inside the NetBeans IDE. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Must select one file in the IDE or set run.class + + + + + + Must select some files in the IDE or set test.includes + + + + + Must select one file in the IDE or set run.class + + + + + Must select one file in the IDE or set applet.url + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Must select some files in the IDE or set javac.includes + + + + + + + + + + + + + + + + + + + + + + + + Some tests failed; see details above. + + + + + + + + + Must select some files in the IDE or set test.includes + + + + Some tests failed; see details above. + + + + Must select some files in the IDE or set test.class + Must select some method in the IDE or set test.method + + + + Some tests failed; see details above. + + + + + Must select one file in the IDE or set test.class + + + + Must select one file in the IDE or set test.class + Must select some method in the IDE or set test.method + + + + + + + + + + + + + + + Must select one file in the IDE or set applet.url + + + + + + + + + Must select one file in the IDE or set applet.url + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Semester 4/Assignments/HashMapASDV_Ant/nbproject/genfiles.properties b/Semester 4/Assignments/HashMapASDV_Ant/nbproject/genfiles.properties new file mode 100644 index 0000000..7488dc6 --- /dev/null +++ b/Semester 4/Assignments/HashMapASDV_Ant/nbproject/genfiles.properties @@ -0,0 +1,8 @@ +build.xml.data.CRC32=2e2f5c1c +build.xml.script.CRC32=57d558c6 +build.xml.stylesheet.CRC32=f85dc8f2@1.108.0.48 +# This file is used by a NetBeans-based IDE to track changes in generated files such as build-impl.xml. +# Do not edit this file. You may delete it but then the IDE will never regenerate such files for you. +nbproject/build-impl.xml.data.CRC32=2e2f5c1c +nbproject/build-impl.xml.script.CRC32=4a925e01 +nbproject/build-impl.xml.stylesheet.CRC32=12e0a6c2@1.108.0.48 diff --git a/Semester 4/Assignments/HashMapASDV_Ant/nbproject/project.properties b/Semester 4/Assignments/HashMapASDV_Ant/nbproject/project.properties new file mode 100644 index 0000000..a3bd69b --- /dev/null +++ b/Semester 4/Assignments/HashMapASDV_Ant/nbproject/project.properties @@ -0,0 +1,99 @@ +annotation.processing.enabled=true +annotation.processing.enabled.in.editor=false +annotation.processing.processors.list= +annotation.processing.run.all.processors=true +annotation.processing.source.output=${build.generated.sources.dir}/ap-source-output +application.title=HashMapASDV_Ant +application.vendor=caleb +build.classes.dir=${build.dir}/classes +build.classes.excludes=**/*.java,**/*.form +# This directory is removed when the project is cleaned: +build.dir=build +build.generated.dir=${build.dir}/generated +build.generated.sources.dir=${build.dir}/generated-sources +# Only compile against the classpath explicitly listed here: +build.sysclasspath=ignore +build.test.classes.dir=${build.dir}/test/classes +build.test.results.dir=${build.dir}/test/results +# Uncomment to specify the preferred debugger connection transport: +#debug.transport=dt_socket +debug.classpath=\ + ${run.classpath} +debug.modulepath=\ + ${run.modulepath} +debug.test.classpath=\ + ${run.test.classpath} +debug.test.modulepath=\ + ${run.test.modulepath} +# Files in build.classes.dir which should be excluded from distribution jar +dist.archive.excludes= +# This directory is removed when the project is cleaned: +dist.dir=dist +dist.jar=${dist.dir}/HashMapASDV_Ant.jar +dist.javadoc.dir=${dist.dir}/javadoc +dist.jlink.dir=${dist.dir}/jlink +dist.jlink.output=${dist.jlink.dir}/HashMapASDV_Ant +endorsed.classpath= +excludes= +file.reference.ListASDV.jar=ListASDV.jar +includes=** +jar.compress=false +javac.classpath= +# Space-separated list of extra javac options +javac.compilerargs= +javac.deprecation=false +javac.external.vm=true +javac.modulepath= +javac.processormodulepath= +javac.processorpath=\ + ${javac.classpath} +javac.source=20 +javac.target=20 +javac.test.classpath=\ + ${javac.classpath}:\ + ${build.classes.dir} +javac.test.modulepath=\ + ${javac.modulepath} +javac.test.processorpath=\ + ${javac.test.classpath} +javadoc.additionalparam= +javadoc.author=false +javadoc.encoding=${source.encoding} +javadoc.html5=false +javadoc.noindex=false +javadoc.nonavbar=false +javadoc.notree=false +javadoc.private=false +javadoc.splitindex=true +javadoc.use=true +javadoc.version=false +javadoc.windowtitle= +# The jlink additional root modules to resolve +jlink.additionalmodules= +# The jlink additional command line parameters +jlink.additionalparam= +jlink.launcher=true +jlink.launcher.name=HashMapASDV_Ant +main.class=hashmapasdv_ant.HashMapASDV_Ant +manifest.file=manifest.mf +meta.inf.dir=${src.dir}/META-INF +mkdist.disabled=false +platform.active=default_platform +run.classpath=\ + ${javac.classpath}:\ + ${build.classes.dir}:\ + ${file.reference.ListASDV.jar} +# Space-separated list of JVM arguments used when running the project. +# You may also define separate properties like run-sys-prop.name=value instead of -Dname=value. +# To set system properties for unit tests define test-sys-prop.name=value: +run.jvmargs= +run.modulepath=\ + ${javac.modulepath} +run.test.classpath=\ + ${javac.test.classpath}:\ + ${build.test.classes.dir} +run.test.modulepath=\ + ${javac.test.modulepath} +source.encoding=UTF-8 +src.dir=src +test.src.dir=test diff --git a/Semester 4/Assignments/HashMapASDV_Ant/nbproject/project.xml b/Semester 4/Assignments/HashMapASDV_Ant/nbproject/project.xml new file mode 100644 index 0000000..6548cab --- /dev/null +++ b/Semester 4/Assignments/HashMapASDV_Ant/nbproject/project.xml @@ -0,0 +1,15 @@ + + + org.netbeans.modules.java.j2seproject + + + HashMapASDV_Ant + + + + + + + + + diff --git a/Semester 4/Assignments/HashMapASDV_Ant/src/hashmapasdv_ant/EntryASDV.java b/Semester 4/Assignments/HashMapASDV_Ant/src/hashmapasdv_ant/EntryASDV.java new file mode 100644 index 0000000..0bc80ee --- /dev/null +++ b/Semester 4/Assignments/HashMapASDV_Ant/src/hashmapasdv_ant/EntryASDV.java @@ -0,0 +1,91 @@ +/* + * 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 hashmapasdv_ant; + +import java.util.Map.Entry; +import java.util.Objects; + +/** + * + * @author caleb + */ + class EntryASDV implements Entry, Comparable + { + + K key; + V value; + + public EntryASDV(K key, V value) + { + this.key = key; + this.value = value; + } + + @Override + public K getKey() + { + return key; + } + + @Override + public V getValue() + { + return value; + } + + @Override + public V setValue(V value) + { + V oldValue = this.value; + this.value = value; + return oldValue; + } + + @Override + public String toString() + { + return "EntryASDV{" + "key=" + key + ", value=" + value + '}'; + } + + @Override + public boolean equals(Object obj) + { + if (this == obj) + { + return true; + } + if (obj == null) + { + return false; + } + if (getClass() != obj.getClass()) + { + return false; + } + final EntryASDV other = (EntryASDV) obj; + if (!Objects.equals(this.key, other.key)) + { + return false; + } + return true; + } + + /** + * + * @param o + * @return throws IllegalArgumentException if parameter class is not K + */ + @Override + public int compareTo(K o) + { + if (getClass() != o.getClass()) + { + throw new IllegalArgumentException("ellegal parameter " + o); + } + return ((Comparable) key).compareTo(o); + } + + } + diff --git a/Semester 4/Assignments/HashMapASDV_Ant/src/hashmapasdv_ant/ListASDV.java b/Semester 4/Assignments/HashMapASDV_Ant/src/hashmapasdv_ant/ListASDV.java new file mode 100644 index 0000000..61591aa --- /dev/null +++ b/Semester 4/Assignments/HashMapASDV_Ant/src/hashmapasdv_ant/ListASDV.java @@ -0,0 +1,1713 @@ +/* + * 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 hashmapasdv_ant; + +/** + * + * @author caleb + */ +import java.io.Serializable; +import java.math.BigInteger; +import java.util.Arrays; +import java.util.Collection; +import java.util.Deque; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.ListIterator; +import java.util.Map; +import java.util.Map.Entry; +import java.util.NoSuchElementException; +import java.util.Queue; +import java.util.Set; +import java.util.function.Consumer; + +public class ListASDV + implements Serializable, + Cloneable, + Iterable, + Collection, Deque, List, Queue +{ + + public Node head; + public Node tail; + BigInteger size; + + public class Node + { + + public E e; + public Node l; + public Node r; + } + public BigInteger sizeBigInteger() + { + return size; + } + /** + * Constructs an empty list. + */ + public ListASDV() + { + size = new BigInteger("0"); + } + + /** + * Constructs a list containing the elements of the specified collection, in + * the order they are returned by the collection's iterator. + * + * @param c - the collection whose elements are to be placed into this list + * @throws NullPointerException - if the specified collection is null + */ + public ListASDV(Collection c) + { + if (c == null) + { + throw new NullPointerException("Null parameter " + c); + } + this.addAll(c); + size.add(new BigInteger( Integer.toString(c.size()))); + } + + /** + * @return Iteraror with the implementation of: hasNext, next + * forEachRemaining + */ + @Override + public Iterator iterator() + { + Iterator it = new Iterator() + { + Node trailNext = head; + @Override public boolean hasNext() + { + if (trailNext == null) + { + trailNext = head; + return false; + } + return true; + } + @Override public E next() + { + Node temp = trailNext; + trailNext = trailNext.r; + return temp.e; + } + /** + * Performs the given action for each remaining element until all + * elements have been processed or the action throws an exception. + * + * @param action has method accept(T t) which performs this + * operation on the given argument. + */ + @Override public void forEachRemaining(Consumer action) + { + //Node temp = trailNext; + //while (temp != null){action.accept(temp.e);temp = temp.r;} + while (hasNext()) action.accept( next() ); + } + }; + return it; + } + + /** + * Inserts all of the elements in the specified collection into this list, + * starting at the specified position. Shifts the element currently at that + * position (if any) and any subsequent elements to the right (increases + * their indices). The new elements will appear in the list in the order + * that they are returned by the specified collection's iterator. + * + * @param index - index at which to insert the first element from the + * specified collection + * @param c - collection containing elements to be added to this list + * @return true if this list changed as a result of the call + * @throws IndexOutOfBoundsException - if the index is out of range (index + * LESS 0 || index GREATER size()) + * @throws NullPointerException - if the specified collection is null + */ + @Override + public boolean addAll(int index, Collection c) + { + if (index < 0 || index > size()) + { + throw new IndexOutOfBoundsException("IndexOutOfBoundsException, index: " + index); + } + if (c == null) + { + throw new NullPointerException("Null parameter " + c); + } + Node temp = tail; + for (E e : c) + { + add(index++, e); + } + size.add(new BigInteger( Integer.toString(c.size()))); + + return temp != tail; + } + + /** + * Returns the element at the specified position in this list. + * + * @param index - index of the element to return + * @return the element at the specified position in this list + * @throws IndexOutOfBoundsException - if the index is out of range (index + * LT 0 || index GE size()) + */ + @Override + public E get(int index) + { + if (index < 0 || index >= size()) + { + throw new IndexOutOfBoundsException("Out of bounds: " + Integer.toString(index)); + } + + Node temp = head; + for (int i = 0; i < index; ++i) + { + temp = temp.r; + } + return temp.e; + } + + /** + * Replaces the element at the specified position in this list with the + * specified element (optional operation). + * + * @param index - index of the element to replace + * @param element + * @return element - the element previously at the specified position + * @throws ClassCastException - if the class of the specified element + * prevents it from being added to this list + * @throws NullPointerException - if the specified element is null and this + * list does not permit null elements + * @throws IllegalArgumentException - if some property of the specified + * element prevents it from being added to this list + * @throws IndexOutOfBoundsException - if the index is out of range (index L + * 0 || index GE size()) + */ + @Override + public E set(int index, E element) + { + + if (index < 0 || index >= size()) + { + throw new IndexOutOfBoundsException("Out of bounds: " + Integer.toString(index)); + } + if (element == null) + { + throw new NullPointerException("Null parameter " + element); + } + + Node temp = head; + for (int i = 0; i < index; ++i) + { + temp = temp.r; + } + E e = temp.e; + temp.e = element; + return e; + } + + /** + * Inserts the specified element at the specified position in this list. + * Shifts the element currently at that position (if any) and any subsequent + * elements to the right (adds one to their indices). + * + * @param index at which the specified element is to be inserted + * @param element - element to be appended to this list + * @throws IndexOutOfBoundsException - if the index is out of range (index L + * 0 || index G size()) + */ + @Override + public void add(int index, E element) + { + if (index < 0 || index > size()) + { + throw new IndexOutOfBoundsException("Out of bounds: " + Integer.toString(index)); + } + if (element == null) + { + throw new NullPointerException("Null parameter " + element); + } + Node newNode = new Node(); + newNode.e = element; + if (head == null) + { + tail = head = newNode; + } + else + { + if (index == 0)//add in the front + { + newNode.r = head; + head.l = newNode; + head = newNode; + } + else if (index == size())//add in the end + { + newNode.l = tail; + tail.r = newNode; + tail = newNode; + } + else //add in the middle + { + Node temp = head; + for (int i = 0; i < index; ++i) + { + temp = temp.r; + } + + newNode.r = temp; + newNode.l = temp.l; + temp.l.r = newNode; + temp.l = newNode; + + } + } + size.add(new BigInteger( "1")); + + } + + /** + * Removes the element at the specified position in this list. Shifts any + * subsequent elements to the left (subtracts one from their indices). + * Returns the element that was removed from the list. + * + * @param index the index of the element to be removed + * @return the element previously at the specified position, null if empty + * list + * @throws IndexOutOfBoundsException - if the index is out of range (index + * LESS 0 or index GE size() + */ + @Override + public E remove(int index) + { + if (index < 0 || index >= size()) + { + throw new IndexOutOfBoundsException("Index Out of bounds exception : " + index); + } + if (size() == 0) + { + return null; + } + size.subtract(new BigInteger( "1")); + if (size() == 1 && index == 0)//special case just having 1 node + { + Node temp = head; + head = tail = null; + return temp.e; + } + else if (index == 0)//remove the first node + { + Node temp = head; + head = head.r; + head.l = null; + return temp.e; + } + else if (index == size() - 1)//remove last node + { + Node temp = tail; + tail = tail.l; + tail.r = null; + return temp.e; + } + else //remove in the middle + { + Node temp = head; + for (int i = 0; i < index; ++i) + { + temp = temp.r; + } + + temp.l.r = temp.r; + temp.r.l = temp.l; + return temp.e; + } + } + + /** + * Returns the index of the first occurrence of the specified element in + * this list, or -1 if this list does not contain the element. More + * formally, returns the lowest index i such that (o==null ? get(i)==null : + * o.equals(get(i))), or -1 if there is no such index. + * + * + * @param o - element to search for + * @return the index of the first occurrence of the specified element in + * this list, or -1 if this list does not contain the element + * @throws ClassCastException - if the type of the specified element is + * incompatible with this list (optional) + */ + @Override + public int indexOf(Object o) + { + Iterator it = iterator(); + int i = 0; + while (it.hasNext()) + { + E e = it.next(); + if (e.equals(o)) + { + return i; + } + i++; + } + return -1; + } + + /** + * Returns the index of the last occurrence of the specified element in this + * list, or -1 if this list does not contain the element. More formally, + * returns the highest index i such that (o==null ? get(i)==null : + * o.equals(get(i))), or -1 if there is no such index. + * + * + * + * @param o - element to search for + * @return the index of the last occurrence of the specified element in this + * list, or -1 if this list does not contain the element + * @throws:ClassCastException - if the type of the specified element is + * incompatible with this list (optional) + * + */ + @Override + public int lastIndexOf(Object o) + { + Iterator it = this.descendingIterator(); + int index = size() - 1; + while (it.hasNext()) + { + if (it.next().equals(o)) + { + return index; + } + --index; + } + return -1; + } + + /** + * Returns a list-iterator of the elements in this list (in proper + * sequence), starting at the specified position in the list. Obeys the + * general contract of List.listIterator(int). implements : hasNext, next,, + * previous, hasPrevious, nextIndex, previousIndex + * + * @param index - index of the first element to be returned from the + * list-iterator (by a call to next) + * @return a ListIterator of the elements in this list (in proper sequence), + * starting at the specified position in the list + * + * @throws IndexOutOfBoundsException - if the index is out of range (index L + * 0 || index G size()) + */ + @Override + public ListIterator listIterator(int index) + { + ListIterator it = new ListIterator() + { + Node trailNext = trailNextInitialize(); + Node trailPrevious = trailNext.l; + + int nextIndex = index; + int previousIndex = nextIndex - 1; + + Node trailNextInitialize() + { + if (index < 0 || index > size()) + { + throw new IndexOutOfBoundsException("ListIterator index out of bounds: " + index); + } + trailNext = head; + for (int i = 0; i < index; ++i) + { + trailNext = trailNext.r; + } + return trailNext; + } + + /** + * Returns true if this list iterator has more elements when + * traversing the list in the forward direction. (In other words, + * returns true if next() would return an element rather than + * throwing an exception.) + * + * @return returns true if next() would return an element; + */ + @Override + public boolean hasNext() + { + if (trailNext == null) + { + trailNext = head; + trailPrevious = trailNext.l; + nextIndex = 0; + previousIndex = -1; + return false; + } + return true; + } + + /** + * Returns the next element in the list and advances the cursor + * position. This method may be called repeatedly to iterate through + * the list, or intermixed with calls to previous() to go back and + * forth. (Note that alternating calls to next and previous will + * return the same element repeatedly.) Specified by: next in + * interface IteratorLE E> + * NoSuchElementException - if the iteration has no next element + * + * @return the next element in the list + * @throws NoSuchElementException if the iteration has no next element + */ + @Override + public E next() + { + if ( trailNext == null ) + throw new NoSuchElementException( "mo next element exists"); + + Node temp = trailNext; + trailPrevious = trailNext; + trailNext = trailNext.r;//advance the trailNext to the next node + previousIndex = nextIndex;//advance previous index to next + nextIndex++;// advance the next index + + return temp.e; + } + + @Override + public boolean hasPrevious() + { + + if (trailPrevious == null) + { + trailNext = head; + trailPrevious = trailNext.l; + nextIndex = 0; + previousIndex = -1; + return false; + } + return true; + } + + @Override + public E previous() + { + if ( trailPrevious == null ) + throw new NoSuchElementException( "no next element exists"); + + Node temp = trailPrevious; + trailNext = trailPrevious; + trailPrevious = trailPrevious.l; + nextIndex = previousIndex; + previousIndex--; + return temp.e; + } + + @Override + public int nextIndex() + { + return nextIndex; + } + + @Override + public int previousIndex() + { + return previousIndex; + } + + @Override + public void remove() + { + throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. + } + + @Override + public void set(E e) + { + throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. + } + + @Override + public void add(E e) + { + throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. + } + }; + return it; + } + + /** + * One line of code here. Call listIterator(0) + * + * @return ListIterator + */ + @Override + public ListIterator listIterator() + { + return listIterator(0); + } + + /** + * Returns a view of the portion of this list between the specified + * fromIndex, inclusive, and toIndex, exclusive. (If fromIndex and toIndex + * are equal, the returned list is empty.) The returned list is backed by + * this list, so non-structural changes in the returned list are reflected + * in this list, and vice-versa. The returned list supports all of the + * optional list operations supported by this list. + * + * + * @param fromIndex - low endpoint (inclusive) of the subList + * @param toIndex - high endpoint (exclusive) of the subList + * @return a view of the specified range within this list + * @throws Throws: IndexOutOfBoundsException - for an illegal endpoint index + * value (fromIndex L 0 || toIndex G size || fromIndex > toIndex) + */ + @Override + public List subList(int fromIndex, int toIndex) + { + if (fromIndex > toIndex || fromIndex < 0 || toIndex > size()) + { + throw new IndexOutOfBoundsException("Index out of Bounds exception " + fromIndex + " " + toIndex); + } + + E[] a = (E[]) new Object[0]; + a = toArray(a); + a = Arrays.copyOfRange(a, fromIndex, toIndex); + return Arrays.asList(a); + } + + @Override + public int size() + { + Node temp = head; + int count = 0; + while (temp != null) + { + count++; + temp = temp.r; + } + return count; + } + + /** + * Tests is the list is empty + * + * @return true if the list is empty, false otherwise. + */ + @Override + public boolean isEmpty() + { + return head == null; + } + + /** + * + * Returns true if this list contains the specified element. More formally, + * returns true if and only if this list contains at least one element e + * such that (o==null ? e==null : o.equals(e)). + * + * @param o - element whose presence in this list is to be tested + * @return true if this list contains the specified element + * @throws ClassCastException - if the type of the specified element is + * incompatible with this list (optional) + */ + @Override + public boolean contains(Object o) + { + Iterator it = this.iterator(); + while (it.hasNext()) + { + if (it.next().equals(o)) + { + return true; + } + } + return false; + } + + /** + * Returns an array containing all of the elements in this list in proper + * sequence (from first to last element). + * + * The returned array will be "safe" in that no references to it are + * maintained by this list. (In other words, this method must allocate a new + * array even if this list is backed by an array). The caller is thus free + * to modify the returned array. + * + * @return an array containing all of the elements in this list in proper + * sequence + */ + @Override + public Object[] toArray() + { + Object[] ar = new Object[size()]; + Iterator it = iterator(); + int i = 0; + while (it.hasNext()) + { + ar[i++] = it.next(); + } + return ar; + } + + /** + * Returns an array containing all of the elements in this list in proper + * sequence (from first to last element); the runtime type of the returned + * array is that of the specified array. If the list fits in the specified + * array, it is returned therein. Otherwise, a new array is allocated with + * the runtime type of the specified array and the size of this list. If the + * list fits in the specified array with room to spare (i.e., the array has + * more elements than the list), the element in the array immediately + * following the end of the list is set to null. (This is useful in + * determining the length of the list only if the caller knows that the list + * does not contain any null elements.) + * + * Like the toArray() method, this method acts as bridge between array-based + * and collection-based APIs. Further, this method allows precise control + * over the runtime type of the output array, and may, under certain + * circumstances, be used to save allocation costs. + * + * Suppose x is a list known to contain only strings. The following code can + * be used to dump the list into a newly allocated array of String: String[] + * y = x.toArray(new String[0]); Note that toArray(new Object[0]) is + * identical in function to toArray(). + * + * Specified by: toArray in interface Collection Type Parameters: T - the + * runtime type of the array to contain the collection Parameters: a - the + * array into which the elements of this list are to be stored, if it is big + * enough; otherwise, a new array of the same runtime type is allocated for + * this purpose. Returns: an array containing the elements of this list + * Throws: ArrayStoreException - if the runtime type of the specified array + * is not a supertype of the runtime type of every element in this list + * NullPointerException - if the specified array is null + * + * @param - the runtime type of the array to contain the collection + * @param a - the array into which the elements of this list are to be + * stored, if it is big enough; otherwise, a new array of the same runtime + * type is allocated for this purpose. + * + * @return an array containing the elements of this list + * @throws ArrayStoreException - if the runtime type of the specified array + * is not a supertype of the runtime type of every element in this list + * @throws NullPointerException - if the specified array is null + */ + @Override + public T[] toArray(T[] a) + { + if (a == null) + { + throw new NullPointerException("Null pointer exception: parameter is null"); + } + + if (a.length >= this.size()) + { + Iterator it = iterator(); + int i = 0; + while (it.hasNext()) + { + T e = (T) it.next(); + a[i++] = e; + } + return a; + } + else + { + T[] ar = Arrays.copyOf(a, size()); + + Iterator it = iterator(); + int i = 0; + while (it.hasNext()) + { + T e = (T) it.next(); + ar[i++] = e; + } + return ar; + } + + } + + /** + * Appends the specified element to the end of this list. This method is + * equivalent to addLast(E). + * + * @param e element to be appended to this list + * @return true if this collection changed as a result of the call + */ + @Override + public boolean add(E e) + { + Node newNode = new Node(); + newNode.e = e; + if (head == null) + { + head = tail = newNode; + } + else + { + newNode.l = tail; + tail.r = newNode; + tail = newNode; + } + size.add(new BigInteger( "1")); + return true; + } + + /** + * Removes a single instance of the specified element from this collection, + * if it is present (optional operation). More formally, removes an element + * e such that (o==null ? e==null : o.equals(e)), if this collection + * contains one or more such elements. + * + * + * @param o - element to be removed from this collection, if present + * @return true if this collection changed as a result of the call. + * @throws ClassCastException - if the type of the specified element is + * incompatible with this collection (optional) + * @throws NullPointerException - if the specified element is null and this + * collection does not permit null elements (optional) + */ + @Override + public boolean remove(Object o) + { + if (o == null) + { + throw new NullPointerException("Null Pointer exception, cant pass null arguments"); + } + Iterator it = this.iterator(); + int pos = 0; + while (it.hasNext()) + { + if (it.next().equals(o)) + { + remove(pos); + return true; + } + pos++; + } + return false; + } + + /** + * Returns true if this collection contains all of the elements in the + * specified collection. + * + * @param c - collection to be checked for containment in this collection + * @return true if this collection contains all of the elements in the + * specified collection + * @throws ClassCastException - if the types of one or more elements in the + * specified collection are incompatible with this collection (optional) + * @throws NullPointerException - if the specified collection contains one + * or more null elements and this collection does not permit null elements + * (optional), or if the specified collection is null. + */ + @Override + public boolean containsAll(Collection c) + { + for (Object o : c) + { + if (contains(o) == false) + { + return false; + } + } + return true; + } + + /** + * Appends all of the elements in the specified collection to the end of + * this list, in the order that they are returned by the specified + * collection's iterator. The behavior of this operation is undefined if the + * specified collection is modified while the operation is in progress. + * (Note that this will occur if the specified collection is this list, and + * it's nonempty.) + * + * @param c - collection containing elements to be added to this list + * @return true if this list changed as a result of the call + * @throws NullPointerException - if the specified collection is null + */ + @Override + public boolean addAll(Collection c) + { + Node temp = tail; + for (E e : c) + { + add(e); + } + return temp != tail; + } + + /** + * Removes from this list all of its elements that are contained in the + * specified collection (optional operation). + * + * @param c - collection containing elements to be removed from this list + * @return true if this list changed as a result of the call + * @throws ClassCastException - if the class of an element of this list is + * incompatible with the specified collection (optional) + */ + @Override + public boolean removeAll(Collection c) + { + Node temp1 = tail; + Node temp2 = head; + for (Object o : c) + { + while (this.remove(o))//remove all same occurances + ; + } + + return temp1 != tail || temp2 != head; + } + + /** + * Retains only the elements in this list that are contained in the + * specified collection (optional operation). In other words, removes from + * this list all of its elements that are not contained in the specified + * collection. + * + * @param c - collection containing elements to be retained in this list + * @return true if this list changed as a result of the call + * @throws ClassCastException - if the class of an element of this list is + * incompatible with the specified collection (optional) + */ + @Override + public boolean retainAll(Collection c) + { + ListASDV cloner = (ListASDV) this.clone(); + cloner.removeAll(c);//cloner has elements to be deleted in the original list + Iterator it = cloner.iterator(); + while (it.hasNext()) + { + Object o = it.next(); + while (this.remove(o)); + } + return true; + } + + /** + * Clears the list of all elements. + */ + @Override + public void clear() + { + size = new BigInteger( "0"); + head = tail = null; + } + + /** + * Inserts the specified element at the beginning of this list. + * + * @param e - the element to add + */ + @Override + public void addFirst(E e) + { + this.add(0, e); + } + + /** + * Appends the specified element to the end of this list. This method is + * equivalent to add(E). + * + * @param e - the element to add + */ + @Override + public void addLast(E e) + { + this.add(size(), e); + } + + /** + * Inserts the specified element at the front of this deque unless it would + * violate capacity restrictions. When using a capacity-restricted deque, + * this method is generally preferable to the addFirst(E) method, which can + * fail to insert an element only by throwing an exception. + * + * Parameters: e - the element to add Returns: true if the element was added + * to this deque, else false Throws: ClassCastException - if the class of + * the specified element prevents it from being added to this deque + * NullPointerException - if the specified element is null and this deque + * does not permit null elements IllegalArgumentException - if some property + * of the specified element prevents it from being added to this deque + * + * @param e - the element to add + * @return true if the element was added to this deque, else false + * @throws ClassCastException if the class of the specified element prevents + * it from being added to this deque + * @throws IllegalArgumentException - if some property of the specified + * element prevents it from being added to this deque + */ + @Override + public boolean offerFirst(E e) + { + addFirst(e); + return true; + } + + /** + * Inserts the specified element at the end of this deque unless it would + * violate capacity restrictions. When using a capacity-restricted deque, + * this method is generally preferable to the addLast(E) method, which can + * fail to insert an element only by throwing an exception. + * + * Parameters: e - the element to add Returns: true if the element was added + * to this deque, else false Throws: ClassCastException - if the class of + * the specified element prevents it from being added to this deque + * NullPointerException - if the specified element is null and this deque + * does not permit null elements IllegalArgumentException - if some property + * of the specified element prevents it from being added to this deque + * + * @param e - the element to add + * @return true if the element was added to this deque, else false + * @throws ClassCastException - if the class of the specified element + * prevents it from being added to this deque + * @throws IllegalArgumentException - if some property of the specified + * element prevents it from being added to this deque * + */ + @Override + public boolean offerLast(E e) + { + addLast(e); + return true; + } + + /** + * E removeFirst() + * + * Retrieves and removes the first element of this deque. This method + * differs from pollFirst only in that it throws an exception if this deque + * is empty. + * + * @return the head of this deque + * @throws NoSuchElementException - if this deque is empty + */ + @Override + public E removeFirst() + { + if (this.isEmpty()) + { + throw new NoSuchElementException("list is empty"); + } + return this.remove(0); + } + + /** + * Retrieves and removes the last element of this deque. This method differs + * from pollLast only in that it throws an exception if this deque is empty. + * + * @return the tail of this deque + * @thows NoSuchElementException - if this deque is empty + */ + @Override + public E removeLast() + { + if (this.isEmpty()) + { + throw new NoSuchElementException("list is empty"); + } + return this.remove(size() - 1); + } + + /** + * Retrieves and removes the first element of this deque, or returns null if + * this deque is empty. + * + * @return the head of this deque, or null if this deque is empty + */ + @Override + public E pollFirst() + { + return isEmpty() ? null : this.remove(0); + } + + /** + * Retrieves and removes the last element of this deque, or returns null if + * this deque is empty. + * + * @return the tail of this deque, or null if this deque is empty + */ + @Override + public E pollLast() + { + return isEmpty() ? null : this.remove(size() - 1); + } + + /** + * Retrieves, but does not remove, the first element of this deque. This + * method differs from peekFirst only in that it throws an exception if this + * deque is empty. + * + * @return the head of this deque + * @throws NoSuchElementException - if this deque is empty + */ + @Override + public E getFirst() + { + if (isEmpty()) + { + throw new NoSuchElementException("The list is empty"); + } + + return head.e; + } + + /** + * Retrieves, but does not remove, the last element of this deque. This + * method differs from peekLast only in that it throws an exception if this + * deque is empty. + * + * @return the tail of this deque + * @throws Throws: NoSuchElementException - if this deque is empty + */ + @Override + public E getLast() + { + if (isEmpty()) + { + throw new NoSuchElementException("The list is empty"); + } + return tail.e; + } + + /** + * Retrieves, but does not remove, the first element of this deque, or + * returns null if this deque is empty. + * + * @return the head of this deque, or null if this deque is empty + * + */ + @Override + public E peekFirst() + { + return isEmpty() ? null : this.get(0); + } + + /** + * Retrieves, but does not remove, the last element of this deque, or + * returns null if this deque is empty. + * + * @return the tail of this deque, or null if this deque is empty + */ + @Override + public E peekLast() + { + return isEmpty() ? null : this.get(size() - 1); + } + + /** + * Removes the first occurrence of the specified element from this deque. If + * the deque does not contain the element, it is unchanged. More formally, + * removes the first element e such that (o==null ? e==null : o.equals(e)) + * (if such an element exists). Returns true if this deque contained the + * specified element (or equivalently, if this deque changed as a result of + * the call). + * + * @param o - element to be removed from this deque, if present + * @return true if an element was removed as a result of this call + * @throws ClassCastException - if the class of the specified element is + * incompatible with this deque + */ + @Override + public boolean removeFirstOccurrence(Object o) + { + return isEmpty() ? false : this.remove(o); + + } + + /** + * Removes the last occurrence of the specified element from this deque. If + * the deque does not contain the element, it is unchanged. More formally, + * removes the last element e such that (o==null ? e==null : o.equals(e)) + * (if such an element exists). Returns true if this deque contained the + * specified element (or equivalently, if this deque changed as a result of + * the call) + * + * @param o - element to be removed from this deque, if present + * @return true if an element was removed as a result of this call + * @throws ClassCastException - if the class of the specified element is + * incompatible with this deque (optional) + */ + @Override + public boolean removeLastOccurrence(Object o) + { + Node temp = tail; + int index = size() - 1; + while (temp != null) + { + if (this.get(index).equals(o)) + { + this.remove(index); + return true; + } + index--; + temp = temp.l; + } + return false; + } + + /** + * Inserts the specified element into this queue if it is possible to do so + * immediately without violating capacity restrictions. When using a + * capacity-restricted queue, this method is generally preferable to add(E), + * which can fail to insert an element only by throwing an exception. + * + * + * @param e - the element to add + * @return true if the element was added to this queue, else false + * @throws: ClassCastException - if the class of the specified element + * prevents it from being added to this queue + */ + @Override + public boolean offer(E e) + { + return this.offerLast(e); + } + + /** + * Retrieves and removes the head of this queue. This method differs from + * poll only in that it throws an exception if this queue is empty. + * + * @return the head of this queue + * @throws NoSuchElementException - if this queue is empty + * + */ + @Override + public E remove() + { + if (isEmpty()) + { + throw new NoSuchElementException("The list is empty!"); + } + return this.remove(0); + } + + /** + * Retrieves and removes the head of this queue, or returns null if this + * queue is empty. + * + * @return the head of this queue, or null if this queue is empty + * + */ + @Override + public E poll() + { + if (isEmpty()) + { + throw new NoSuchElementException("The list is empty!"); + } + return this.remove(0); + } + + /** + * Retrieves, but does not remove, the head of this queue. This method + * differs from peek only in that it throws an exception if this queue is + * empty. + * + * @return the head of this queue + * @throws: NoSuchElementException - if this queue is empty + * + */ + @Override + public E element() + { + if (isEmpty()) + { + throw new NoSuchElementException("The list is empty!"); + } + return this.get(0); + } + + /** + * Retrieves, but does not remove, the head of this queue, or returns null + * if this queue is empty. + * + * @return the head of this queue, or null if this queue is empty + */ + @Override + public E peek() + { + return isEmpty() ? null : this.get(0); + } + + /** + * Pushes an element onto the stack represented by this list. In other + * words, inserts the element at the front of this list. + * + * This method is equivalent to addFirst(E). Specified by: push in interface + * Deque + * + * @param e - the element to push + */ + @Override + public void push(E e) + { + this.addFirst(e); + } + + /** + * Pops an element from the stack represented by this list. In other words, + * removes and returns the first element of this list. + * + * This method is equivalent to removeFirst(). Specified by: pop in + * interface Deque + * + * @return the element at the front of this list (which is the top of the + * stack represented by this list) + * @throws: NoSuchElementException - if this list is empty + */ + @Override + public E pop() + { + if (isEmpty()) + { + throw new NoSuchElementException("The list is empty!"); + } + return this.remove(0); + } + + /** + * Description copied from interface: Deque Returns an iterator over the + * elements in this deque in reverse sequential order. The elements will be + * returned in order from last (tail) to first (head). + * + * Specified by: descendingIterator in interface Deque + * + * @return an iterator over the elements in this deque in reverse sequence + */ + @Override + public Iterator descendingIterator() + { + + Iterator it = new Iterator() + { + Node trailPrevious = tail; + + @Override + public boolean hasNext() + { + if (trailPrevious == null) + { + trailPrevious = tail; + return false; + } + return true; + } + + @Override + public E next() + { + Node temp = trailPrevious; + trailPrevious = trailPrevious.l; + return temp.e; + } + }; + return it; + } + + /** + * Returns a deep clone of the list. + * + * @return the cloned list + */ + @Override + public Object clone() + { + ListASDV listCloned = new ListASDV(); + Iterator it = this.iterator(); + while (it.hasNext()) + { + + listCloned.add((E) it.next()); + } + return listCloned; + } + + @Override + public String toString() + { + + String s = "ListASDV{ "; + Iterator it = iterator(); + while (it.hasNext()) + { + s += it.next() + " "; + } + s += '}'; + return s; + } + + public static void main(String[] args) + { + Map map = new HashMap(); + map.put(1, "john"); + map.put(2, "mary"); + Set> set1 = map.entrySet(); + } + +/* + public static void main(String[] args) + { + class ASDV_ENTRY implements Entry + { + T1 key; + T2 value; + public ASDV_ENTRY( T1 t1, T2 t2) + { + key = t1; + value = t2; + } + @Override + public T1 getKey() + { + throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. + } + + @Override + public T1 getValue() + { + throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. + } + + @Override + public T1 setValue(T1 value) + { + throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. + } + + + } + Entry e1 = new ASDV_ENTRY("john", 20); + + ListASDV listTest = new ListASDV(); + listTest.add(e1); + + + ListASDV list = new ListASDV(); + list.add(100); + list.addFirst(50); + list.add(1, 75); + list.addLast(200); + List collection = Arrays.asList(new Integer[] + { + 300, 400 + }); + list.addAll(collection); + try + { + list.addAll(8, collection); + } + catch (IndexOutOfBoundsException e) + { + System.out.println(e.getMessage()); + } + + Iterator it = list.iterator(); + System.out.println("\ntest add methods ***************************************"); + while (it.hasNext()) + { + Object o = it.next(); + System.out.print(o + " "); + } + + System.out.println(""); + System.out.println("\nforEachRemaining(action) ***************************************"); + + Consumer action = new Consumer() + { + @Override + public void accept(Integer t) + { + System.out.print("*" + t + " "); + } + + }; + it = list.iterator(); + it.next(); + it.next(); + it.forEachRemaining(action); + System.out.println(""); + while (it.hasNext()) + { + Object o = it.next(); + System.out.print(o + " "); + } + System.out.println(""); + it.forEachRemaining(action); + + System.out.println(""); + System.out.println("indexOf ***************************************"); + System.out.println(list.indexOf(new A())); + System.out.println(list.indexOf(200)); + System.out.println(list.indexOf(800)); + + System.out.println("\nclone() ***************************************"); + ListASDV listCloned = (ListASDV) list.clone(); + list.clear(); + it = listCloned.iterator(); + while (it.hasNext()) + { + Object o = it.next(); + System.out.print(o + " "); + } + System.out.println("\nsize of original list after clear: " + list.size()); + list.addAll(0, listCloned); + System.out.println("\ntoString() ***************************************\n" + list); + + System.out.println("\ncontains ***************************************"); + System.out.println(list.contains(new A())); + System.out.println(list.contains(200)); + System.out.println(list.contains(800)); + + System.out.println("\ncontainsAll ***************************************"); + try + { + System.out.println(list.containsAll((Collection) new A())); + } + catch (ClassCastException e) + { + System.out.println(e.getMessage()); + } + System.out.println(list.containsAll(listCloned)); + System.out.println(list.containsAll(Arrays.asList(new Integer[] + { + 100, 300 + }))); + System.out.println(list.containsAll(Arrays.asList(new Integer[] + { + 10, 300 + }))); + + System.out.println("\ndiscendingIterator ***************************************"); + Iterator descIt = list.descendingIterator(); + while (descIt.hasNext()) + { + Object o = descIt.next(); + System.out.print(o + " "); + } + + System.out.println("\nelement ***************************************"); + System.out.println(list.element()); + System.out.println(list.element()); + listCloned.clear(); + try + { + listCloned.element(); + } + catch (NoSuchElementException e) + { + System.out.println(e.getMessage()); + } + + System.out.println("\nget(int) ***************************************"); + System.out.println(list.get(0)); + System.out.println(list.get(list.size() - 1)); + try + { + list.get(list.size()); + } + catch (IndexOutOfBoundsException e) + { + System.out.println(e.getMessage()); + } + + System.out.println("\ngetFirst() ***************************************"); + System.out.println(list.getFirst()); + System.out.println(list.getFirst()); + try + { + listCloned.getFirst(); + } + catch (NoSuchElementException e) + { + System.out.println(e.getMessage()); + } + + System.out.println("\n getLAst()***************************************"); + System.out.println(list.getLast()); + System.out.println(list.getLast()); + + try + { + listCloned.getLast(); + } + catch (NoSuchElementException e) + { + System.out.println(e.getMessage()); + } + + System.out.println("\n isEmpty()***************************************"); + System.out.println(list.isEmpty()); + System.out.println(listCloned.isEmpty()); + + System.out.println("\n lastIndexOf***************************************"); + list.add(1, -888); + list.add(4, -888); + System.out.println(list); + System.out.println(list.lastIndexOf(-888)); + System.out.println(list.lastIndexOf(12)); + System.out.println(list.lastIndexOf(new A())); + + System.out.println("\nlistIterator( index=3) using next***************************************"); + System.out.println(list); + ListIterator itList = list.listIterator(3); + + while (itList.hasNext()) + { + Object o = itList.next(); + System.out.print("next Index " + itList.nextIndex()); + System.out.print(" previous Index " + itList.previousIndex()); + System.out.println(" node " + o + " "); + } + + System.out.println("\nlistIterator( index=3) using previous ***************************************"); + System.out.println(list); + itList = list.listIterator(3); + + while (itList.hasPrevious()) + { + Object o = itList.previous(); + System.out.print("next Index " + itList.nextIndex()); + System.out.print(" previous Index " + itList.previousIndex()); + System.out.println(" node " + o + " "); + } + + System.out.println("\nlistIterator with next ***************************************"); + System.out.println(list); + itList = list.listIterator(); + + while (itList.hasNext()) + { + Object o = itList.next(); + System.out.print("next Index " + itList.nextIndex()); + System.out.print(" previous Index " + itList.previousIndex()); + System.out.println(" node " + o + " "); + } + + System.out.println("\noffer methods ***************************************"); + list.offer(500); + list.offerLast(600); + list.offerFirst(33); + System.out.println(list); + + System.out.println("\npeek poll methods ***************************************"); + System.out.println(list.peek()); + System.out.println(list.peekFirst()); + System.out.println(list.peekLast()); + System.out.println(listCloned.peekLast()); + System.out.println(list.poll()); + System.out.println(list.pollFirst()); + System.out.println(list.pollLast()); + System.out.println(listCloned.pollFirst()); + + System.out.println("\npush pop methods ***************************************"); + System.out.println(list); + Integer o = list.pop(); + list.push(o); + System.out.println(list); + try + { + listCloned.pop(); + } + catch (NoSuchElementException e) + { + System.out.println(e.getMessage()); + } + + System.out.println("\nremove methods ***************************************"); + System.out.println(list); + System.out.println(list.removeLastOccurrence(-888)); + System.out.println(list); + System.out.println(list.remove()); + System.out.println(list.removeFirst()); + System.out.println(list); + System.out.println(list.remove((Integer) 300)); + try + { + list.remove(null); + } + catch (NullPointerException e) + { + System.out.println(e.getMessage()); + } + try + { + list.remove(200); + } + catch (IndexOutOfBoundsException e) + { + System.out.println(e.getMessage()); + } + System.out.println(list); + + System.out.println("\nremoveAll( Collection c) ***************************************"); + list.add(0, -888); + list.add(2, -888); + list.add(-888); + listCloned = (ListASDV) list.clone(); + System.out.println(list); + List col = Arrays.asList(new Integer[] + { + -888, 200 + }); + list.removeAll(col); + System.out.println(list); + + System.out.println("\nretailAll( Collection c) ***************************************"); + list = (ListASDV) listCloned.clone(); + list.retainAll(col); + System.out.println(list); + + System.out.println("\nset ***************************************"); + list.set(0, 100); + System.out.println(list); + + System.out.println("\nsubList ***************************************"); + List subList = list.subList(1, 3); + System.out.println(subList); + try + { + list.subList(1, 5); + } + catch (IndexOutOfBoundsException e) + { + System.out.println(e.getMessage()); + } + + System.out.println("\ntoArray ***************************************"); + System.out.println(list); + System.out.println(Arrays.asList(list.toArray())); + + Integer[] ar = new Integer[list.size()]; + System.out.println("\ntoArray(T[] ) ***************************************"); + System.out.println(list); + System.out.println(Arrays.asList(list.toArray(ar))); + + ar = new Integer[1]; + System.out.println(Arrays.asList(list.toArray(ar))); + + ar = new Integer[list.size() + list.size()]; + System.out.println(Arrays.asList(list.toArray(ar))); + + ar = null; + try + { + list.toArray(ar); + } + catch (NullPointerException e) + { + System.out.println(e.getMessage()); + } + + } +*/ +} + + +class A +{ +} + diff --git a/Semester 4/Assignments/ProjectTrees_CalebFontenot/src/main/java/edu/slcc/asdv/caleb/projecttrees_calebfontenot/TreeASDV.java b/Semester 4/Assignments/ProjectTrees_CalebFontenot/src/main/java/edu/slcc/asdv/caleb/projecttrees_calebfontenot/TreeASDV.java index f79934f..f84692b 100644 --- a/Semester 4/Assignments/ProjectTrees_CalebFontenot/src/main/java/edu/slcc/asdv/caleb/projecttrees_calebfontenot/TreeASDV.java +++ b/Semester 4/Assignments/ProjectTrees_CalebFontenot/src/main/java/edu/slcc/asdv/caleb/projecttrees_calebfontenot/TreeASDV.java @@ -4,6 +4,8 @@ */ package edu.slcc.asdv.caleb.projecttrees_calebfontenot; +import java.util.ArrayList; +import java.util.Iterator; import java.util.LinkedList; import java.util.ListIterator; import java.util.Queue; @@ -12,8 +14,9 @@ import java.util.Stack; /** * * @author caleb + * @param */ -public class TreeASDV { +public class TreeASDV implements Cloneable { private Node root; @@ -24,7 +27,21 @@ public class TreeASDV { Node rightChild; } - public boolean insert(T t) { + @Override + public Object clone() + { + System.out.println("Cloning..."); + TreeASDV clone = new TreeASDV(); + ArrayList 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 newNode = new Node<>(); newNode.data = t; @@ -55,7 +72,8 @@ public class TreeASDV { return true; } - private void inOrder(Node p) { + private void inOrder(Node p) + { if (p == null) { return; } @@ -65,11 +83,8 @@ public class TreeASDV { inOrder(p.rightChild); } - public void inOrder() { - inOrder(this.root); - } - - public Node findNode(T t) { + public Node findNode(T t) + { Node currentNode = root; while (currentNode != null) { if (t.compareTo(currentNode.data) == 0) { @@ -82,8 +97,9 @@ public class TreeASDV { } return null; } - - public boolean remove(T t) { + + public boolean remove(T t) + { // Initialize parent and current nodes for traversal Node parent = null; Node current = root; @@ -134,7 +150,8 @@ public class TreeASDV { } // Helper method to find in-order successor of a node - private Node getSuccessor(Node node) { + private Node getSuccessor(Node node) + { Node current = node.rightChild; Node successorParent = node; Node successor = node; @@ -156,12 +173,80 @@ public class TreeASDV { return successor; } - public ListIterator listIterator() { - //ListIterator it = new ListIterator(); - return null; + // Inorder ListIterator + public Iterator listIterator() + { + return new InorderIterator(); } - public void breadthFirstTraversal() { + private class InorderIterator implements Iterator { + + private Stack> stack; + + public InorderIterator() + { + stack = new Stack<>(); + pushLeft(root); + } + + private void pushLeft(Node 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 current = stack.pop(); + pushLeft(current.rightChild); + return current.data; + } + + @Override + public void remove() + { + throw new UnsupportedOperationException(); + } + } + + public ArrayList getBreadthFirstArray() + { + ArrayList returnArray = new ArrayList(); + if (root == null) { + return returnArray; + } + Queue> queue = new LinkedList<>(); + + queue.offer(root); + + while (!queue.isEmpty()) { + Node 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; } @@ -182,12 +267,18 @@ public class TreeASDV { } } + @Override + public boolean equals(Object obj) { + return this.getBreadthFirstArray().equals(((TreeASDV) obj).getBreadthFirstArray()); + } - public int height() { + public int height() + { return calculateHeight(root); } - private int calculateHeight(Node node) { + private int calculateHeight(Node node) + { if (node == null) { return 0; } @@ -197,21 +288,24 @@ public class TreeASDV { return 1 + Math.max(leftHeight, rightHeight); } - - public boolean isFullBST() { + + public boolean isFullBST() + { int height = height(); int nodeCount = countNodes(root); return nodeCount == (1 << height) - 1; // Formula for full binary tree } - private int countNodes(Node node) { + private int countNodes(Node node) + { if (node == null) { return 0; } return 1 + countNodes(node.leftChild) + countNodes(node.rightChild); } - - public void inorder() { + + public void inOrder() + { if (root == null) { return; } @@ -230,7 +324,8 @@ public class TreeASDV { } } - public static void main(String[] args) { + public static void main(String[] args) throws CloneNotSupportedException + { TreeASDV tree = new TreeASDV<>(); // Insert some elements into the tree tree.insert(5); @@ -254,7 +349,16 @@ public class TreeASDV { // Test inorder traversal without recursion System.out.println("Inorder Traversal without Recursion:"); - tree.inorder(); + tree.inOrder(); System.out.println(); + System.out.println("array list from breadth traversal"); + System.out.println(tree.getBreadthFirstArray()); + System.out.println("Cloned Tree:"); + TreeASDV clonedTree = (TreeASDV) 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") ); } }