PriorityQueue.java

2023-11-15 21:08:23 +07:00 · 2023-11-15 21:08:23 +07:00 · cf4d08f752
parent 490f041804
commit cf4d08f752
2 changed files with 1101 additions and 73 deletions
--- a/3/Assignments/MP6_CalebFontenot/Printed
+++ b/3/Assignments/MP6_CalebFontenot/Printed
@ -0,0 +1,944 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
+<html>
+<head>
+<title>PriorityQueueASDV.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}
+.comment {color: #808080}
+.whitespace {color: #505050}
+.ST2 {color: #9999ff; font-family: monospace; font-style: italic}
+.ST5 {font-family: monospace; font-weight: bold; font-style: italic}
+.string {color: #6a8759}
+.number {color: #6897bb}
+.ST1 {color: #9876aa}
+.ST4 {color: #ffc66d}
+.ST3 {color: #8a653b}
+.ST6 {color: #9876aa; font-family: monospace; font-weight: bold; font-style: italic}
+.ST7 {color: #ffc66d; font-family: monospace; font-weight: bold; font-style: italic}
+.ST0 {color: #287bde}
+.literal {color: #cc7832}
+-->
+</style>
+</head>
+<body>
+<table width="100%"><tr><td align="center">/home/caleb/ASDV-Java/Semester 3/Assignments/MP6_CalebFontenot/src/main/java/edu/slcc/asdv/caleb/mp6_calebfontenot/PriorityQueueASDV.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.caleb.mp6_calebfontenot;
+
+<span class="comment">/**</span>
+<span class="comment"> *</span>
+<span class="comment"> * </span><span class="comment">@author</span> <span class="comment">caleb</span>
+ <span class="comment">*/</span>
+<span class="literal">import</span> java.util.ArrayList;
+<span class="literal">import</span> java.util.Arrays;
+<span class="literal">import</span> java.util.Collection;
+<span class="literal">import</span> java.util.Iterator;
+<span class="literal">import</span> java.util.List;
+<span class="literal">import</span> java.util.NoSuchElementException;
+<span class="literal">import</span> java.util.PriorityQueue;
+<span class="literal">import</span> java.util.Queue;
+<span class="literal">import</span> java.util.function.Consumer;
+
+<span class="literal">public</span> <span class="literal">class</span> PriorityQueueASDV&lt;E <span class="literal">extends</span> Comparable&lt;E&gt;&gt;
+        <span class="literal">implements</span> Queue&lt;E&gt;, Cloneable {
+
+    <span class="literal">private</span> Node&lt;E&gt; <span class="ST1">head</span>;<span class="comment">//head</span>
+    <span class="literal">private</span> Node&lt;E&gt; <span class="ST1">tail</span>;<span class="comment">//tail</span>
+
+    <span class="literal">class</span> Node&lt;E&gt; {
+
+        E <span class="ST1">e</span>;
+        Node&lt;E&gt; <span class="ST1">l</span>;
+        Node&lt;E&gt; <span class="ST1">r</span>;
+    }
+
+    <span class="comment">/**</span>
+<span class="comment">     * </span><span class="comment">Inserts</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</span> <span class="comment">into</span> <span class="comment">this</span> <span class="comment">queue</span> <span class="comment">if</span> <span class="comment">it</span> <span class="comment">is</span> <span class="comment">possible</span> <span class="comment">to</span> <span class="comment">do</span> <span class="comment">so</span> <span class="comment">immediately</span> <span class="comment">without</span> <span class="comment">violating</span> <span class="comment">capacity</span> <span class="comment">restrictions</span><span class="comment">, </span><span class="comment">returning</span> <span class="comment">true</span> <span class="comment">upon</span> <span class="comment">success</span> <span class="comment">and</span> <span class="comment">throwing</span> <span class="comment">an</span> <span class="comment">IllegalStateException</span> <span class="comment">if</span> <span class="comment">no</span> <span class="comment">space</span> <span class="comment">is</span> <span class="comment">currently</span> <span class="comment">available</span><span class="comment">.</span>
+<span class="comment">     *</span>
+<span class="comment">     * </span><span class="comment">Specified</span> <span class="comment">by</span><span class="comment">: </span><span class="comment">add</span> <span class="comment">in</span> <span class="comment">interface</span> <span class="comment">Collection</span><span class="ST2">&lt;E&gt;</span>
+<span class="comment">     * </span><span class="comment">Parameters</span><span class="comment">: </span><span class="comment">e</span><span class="comment"> - </span><span class="comment">the</span> <span class="comment">element</span> <span class="comment">to</span> <span class="comment">add</span> <span class="comment">Returns</span><span class="comment">: </span><span class="comment">true</span><span class="comment"> (</span><span class="comment">as</span> <span class="comment">specified</span> <span class="comment">by</span> <span class="comment">Collection</span><span class="comment">.</span><span class="comment">add</span><span class="comment">(</span><span class="comment">E</span><span class="comment">)) </span><span class="comment">Throws</span><span class="comment">: </span><span class="comment">IllegalStateException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">element</span> <span class="comment">cannot</span> <span class="comment">be</span> <span class="comment">added</span> <span class="comment">at</span> <span class="comment">this</span> <span class="comment">time</span> <span class="comment">due</span> <span class="comment">to</span> <span class="comment">capacity</span> <span class="comment">restrictions</span> <span class="comment">ClassCastException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">class</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</span> <span class="comment">prevents</span> <span class="comment">it</span> <span class="comment">from</span> <span class="comment">being</span> <span class="comment">added</span> <span class="comment">to</span> <span class="comment">this</span> <span class="comment">queue</span> <span class="comment">NullPointerException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</span> <span class="comment">is</span> <span class="comment">null</span> <span class="comment">and</span> <span class="comment">this</span> <span class="comment">queue</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">permit</span> <span class="comment">null</span> <span class="comment">elements</span> <span class="comment">IllegalArgumentException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">some</span> <span class="comment">property</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">element</span> <span class="comment">prevents</span> <span class="comment">it</span> <span class="comment">from</span> <span class="comment">being</span> <span class="comment">added</span> <span class="comment">to</span> <span class="comment">this</span> <span class="comment">queue</span>
+<span class="comment">     *</span>
+<span class="comment">     * </span><span class="comment">@param</span> <span class="ST3">e</span><span class="comment"> - </span><span class="comment">the</span> <span class="comment">element</span> <span class="comment">to</span> <span class="comment">add</span>
+<span class="comment">     * </span><span class="comment">@return</span> <span class="comment">true</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">changed</span> <span class="comment">as</span> <span class="comment">a</span> <span class="comment">result</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">call</span>
+<span class="comment">     * </span><span class="comment">@throws</span> <span class="comment">IllegalStateException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">element</span> <span class="comment">cannot</span> <span class="comment">be</span> <span class="comment">added</span> <span class="comment">at</span> <span class="comment">this</span> <span class="comment">time</span> <span class="comment">due</span> <span class="comment">to</span> <span class="comment">capacity</span> <span class="comment">restrictions</span>
+<span class="comment">     * </span><span class="comment">@throws</span> <span class="comment">ClassCastException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">class</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</span>
+<span class="comment">     * </span><span class="comment">@throws</span> <span class="comment">NullPointerException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</span> <span class="comment">is</span> <span class="comment">null</span> <span class="comment">and</span> <span class="comment">this</span> <span class="comment">queue</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">permit</span> <span class="comment">null</span> <span class="comment">elements</span>
+<span class="comment">     * </span><span class="comment">@throws</span> <span class="comment">IllegalArgumentException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">some</span> <span class="comment">property</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">element</span> <span class="comment">prevents</span> <span class="comment">it</span> <span class="comment">from</span> <span class="comment">being</span> <span class="comment">added</span> <span class="comment">to</span> <span class="comment">this</span> <span class="comment">queue</span>
+     <span class="comment">*/</span>
+    @Override
+    <span class="literal">public</span> <span class="literal">boolean</span> <span class="ST4">add</span>(E e) {
+        <span class="literal">if</span> (e == <span class="literal">null</span>) {
+            <span class="literal">throw</span> <span class="literal">new</span> NullPointerException(<span class="string">&quot;</span><span class="string">NULL elements not allowed!</span><span class="string">&quot;</span>);
+        }
+
+        Node&lt;E&gt; newNode = <span class="literal">new</span> Node&lt;E&gt;();
+        newNode.<span class="ST1">e</span> = e;
+
+        <span class="comment">//1. empty queue</span>
+        <span class="literal">if</span> (<span class="literal">this</span>.<span class="ST1">head</span> == <span class="literal">null</span> &amp;&amp; <span class="literal">this</span>.<span class="ST1">tail</span> == <span class="literal">null</span>) {
+            <span class="literal">this</span>.<span class="ST1">head</span> = <span class="literal">this</span>.<span class="ST1">tail</span> = newNode;
+            <span class="literal">return</span> <span class="literal">true</span>;
+        }
+
+        <span class="literal">int</span> index = findCorrectPositionToInsertElement(e);
+        <span class="comment">//int index = findCorrectPositionToInsertElementHashCode(e);</span>
+
+        <span class="comment">//2. we add at size ( last node)</span>
+        <span class="literal">if</span> (index == size()) {
+            <span class="ST1">tail</span>.<span class="ST1">r</span> = newNode;<span class="comment">//1</span>
+            newNode.<span class="ST1">l</span> = <span class="ST1">tail</span>;<span class="comment">//2</span>
+            <span class="ST1">tail</span> = newNode;<span class="comment">//3</span>
+        } <span class="comment">//3. we add at 0 in the front</span>
+        <span class="literal">else</span> <span class="literal">if</span> (index == <span class="number">0</span>) {
+            newNode.<span class="ST1">r</span> = <span class="ST1">head</span>;
+            <span class="literal">this</span>.<span class="ST1">head</span>.<span class="ST1">l</span> = newNode;
+            <span class="literal">this</span>.<span class="ST1">head</span> = newNode;
+            <span class="literal">if</span> (size() == <span class="number">1</span>) {
+                <span class="ST1">tail</span> = <span class="ST1">head</span>;
+            }
+        } <span class="comment">//4. we add in the middle</span>
+        <span class="literal">else</span> {
+            Node&lt;E&gt; p = <span class="ST1">head</span>;
+
+            <span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; index - <span class="number">1</span>; ++i) {
+                p = p.<span class="ST1">r</span>;
+            }
+
+            <span class="comment">//after for loop p point one position before insertion</span>
+            newNode.<span class="ST1">l</span> = p;<span class="comment">//we connect the left of the new node </span>
+            <span class="comment">//to the node that is BEFORE </span>
+            <span class="comment">//the node to be inserted</span>
+
+            newNode.<span class="ST1">r</span> = p.<span class="ST1">r</span>;<span class="comment">//we connect the right of the new node</span>
+            <span class="comment">// to the node thta is AFTER </span>
+            <span class="comment">//the node to be inserted</span>
+
+            p.<span class="ST1">r</span> = newNode; <span class="comment">//we connect the right the  node BEFORE the node</span>
+            <span class="comment">//to be inserted to the new node</span>
+
+            p.<span class="ST1">r</span>.<span class="ST1">r</span>.<span class="ST1">l</span> = newNode;<span class="comment">//we connect the left of the node AFTER the node </span>
+            <span class="comment">//to be iserted to the new node</span>
+        }
+
+        <span class="literal">return</span> <span class="literal">true</span>;
+    }
+
+    @Override
+    <span class="literal">public</span> <span class="literal">int</span> <span class="ST4">size</span>() {
+        Node&lt;E&gt; p = <span class="literal">this</span>.<span class="ST1">head</span>;
+        <span class="literal">int</span> count = <span class="number">0</span>;
+        <span class="literal">while</span> (p != <span class="literal">null</span>) {
+            p = p.<span class="ST1">r</span>;
+            count++;
+        }
+        <span class="literal">return</span> count;
+    }
+
+    <span class="literal">private</span> <span class="literal">int</span> <span class="ST4">findCorrectPositionToInsertElement</span>(E e) {
+        Node&lt;E&gt; p = <span class="literal">this</span>.<span class="ST1">head</span>;
+        <span class="literal">int</span> pos = <span class="number">0</span>;
+        <span class="literal">while</span> (p != <span class="literal">null</span>) {
+            <span class="literal">if</span> (e.compareTo(p.<span class="ST1">e</span>) &gt; <span class="number">0</span>) {
+                p = p.<span class="ST1">r</span>;
+                ++pos;
+            } <span class="literal">else</span> {
+                <span class="literal">break</span>;
+            }
+        }
+
+        <span class="literal">return</span> pos;
+    }
+
+    <span class="literal">private</span> <span class="literal">int</span> <span class="comment">findCorrectPositionToInsertElementHashCode</span>(E e) {
+        Node&lt;E&gt; p = <span class="literal">this</span>.<span class="ST1">head</span>;
+        <span class="literal">int</span> pos = <span class="number">0</span>;
+        <span class="literal">while</span> (p != <span class="literal">null</span>) {
+            <span class="literal">if</span> (e.hashCode() &gt; p.<span class="ST1">e</span>.hashCode()) {
+                p = p.<span class="ST1">r</span>;
+                ++pos;
+            } <span class="literal">else</span> {
+                <span class="literal">break</span>;
+            }
+        }
+
+        <span class="literal">return</span> pos;
+    }
+
+    <span class="comment">/**</span>
+<span class="comment">     * </span><span class="comment">Inserts</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</span> <span class="comment">into</span> <span class="comment">this</span> <span class="comment">queue</span> <span class="comment">if</span> <span class="comment">it</span> <span class="comment">is</span> <span class="comment">possible</span> <span class="comment">to</span> <span class="comment">do</span> <span class="comment">so</span> <span class="comment">immediately</span> <span class="comment">without</span> <span class="comment">violating</span> <span class="comment">capacity</span> <span class="comment">restrictions</span><span class="comment">.</span> <span class="comment">When</span> <span class="comment">using</span> <span class="comment">a</span> <span class="comment">capacity</span><span class="comment">-</span><span class="comment">restricted</span> <span class="comment">queue</span><span class="comment">, </span><span class="comment">this</span> <span class="comment">method</span> <span class="comment">is</span> <span class="comment">generally</span> <span class="comment">preferable</span> <span class="comment">to</span> <span class="comment">add</span><span class="comment">(</span><span class="comment">E</span><span class="comment">), </span><span class="comment">which</span> <span class="comment">can</span> <span class="comment">fail</span> <span class="comment">to</span> <span class="comment">insert</span> <span class="comment">an</span> <span class="comment">element</span> <span class="comment">only</span> <span class="comment">by</span> <span class="comment">throwing</span> <span class="comment">an</span> <span class="comment">exception</span><span class="comment">.</span>
+<span class="comment">     *</span>
+<span class="comment">     * </span><span class="comment">@param</span> <span class="ST3">e</span><span class="comment"> - </span><span class="comment">the</span> <span class="comment">element</span> <span class="comment">to</span> <span class="comment">add</span>
+<span class="comment">     * </span><span class="comment">@throws</span> <span class="comment">IllegalStateException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">element</span> <span class="comment">cannot</span> <span class="comment">be</span> <span class="comment">added</span> <span class="comment">at</span> <span class="comment">this</span> <span class="comment">time</span> <span class="comment">due</span> <span class="comment">to</span> <span class="comment">capacity</span> <span class="comment">restrictions</span>
+<span class="comment">     * </span><span class="comment">@throws</span> <span class="comment">ClassCastException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">class</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</span>
+<span class="comment">     * </span><span class="comment">@throws</span> <span class="comment">NullPointerException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</span> <span class="comment">is</span> <span class="comment">null</span> <span class="comment">and</span> <span class="comment">this</span> <span class="comment">queue</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">permit</span> <span class="comment">null</span> <span class="comment">elements</span>
+<span class="comment">     * </span><span class="comment">@throws</span> <span class="comment">IllegalArgumentException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">some</span> <span class="comment">property</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">element</span> <span class="comment">prevents</span> <span class="comment">it</span> <span class="comment">from</span> <span class="comment">being</span> <span class="comment">added</span> <span class="comment">to</span> <span class="comment">this</span> <span class="comment">queue</span>
+<span class="comment">     * </span><span class="comment">@return</span> <span class="comment">true</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">element</span> <span class="comment">was</span> <span class="comment">added</span>
+     <span class="comment">*/</span>
+    @Override
+    <span class="literal">public</span> <span class="literal">boolean</span> <span class="ST4">offer</span>(E e) {
+        <span class="literal">return</span> add(e);
+    }
+
+    <span class="comment">/**</span>
+<span class="comment">     * </span><span class="comment">Retrieves</span> <span class="comment">and</span> <span class="comment">removes</span> <span class="comment">the</span> <span class="comment">head</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">queue</span><span class="comment">.</span> <span class="comment">This</span> <span class="comment">method</span> <span class="comment">differs</span> <span class="comment">from</span><span class="comment"> {</span><span class="comment">@link</span> <span class="comment">#</span><span class="comment">poll</span> <span class="comment">poll</span><span class="comment">} </span><span class="comment">only</span> <span class="comment">in</span> <span class="comment">that</span> <span class="comment">it</span> <span class="comment">throws</span> <span class="comment">an</span> <span class="comment">exception</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">queue</span> <span class="comment">is</span> <span class="comment">empty</span><span class="comment">.</span>
+<span class="comment">     *</span>
+<span class="comment">     * </span><span class="ST2">&lt;p&gt;</span>
+<span class="comment">     * </span><span class="comment">This</span> <span class="comment">implementation</span> <span class="comment">returns</span> <span class="comment">the</span> <span class="comment">result</span> <span class="comment">of</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">poll</span><span class="comment">}</span> <span class="comment">unless</span> <span class="comment">the</span> <span class="comment">queue</span> <span class="comment">is</span> <span class="comment">empty</span><span class="comment">.</span>
+<span class="comment">     *</span>
+<span class="comment">     * </span><span class="comment">@return</span> <span class="comment">the</span> <span class="comment">head</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">queue</span>
+<span class="comment">     * </span><span class="comment">@throws</span> <span class="comment">NoSuchElementException</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">queue</span> <span class="comment">is</span> <span class="comment">empty</span>
+     <span class="comment">*/</span>
+    @Override
+    <span class="literal">public</span> E <span class="ST4">remove</span>() {
+        Node&lt;E&gt; <span class="comment">pointer</span> = <span class="ST1">head</span>.<span class="ST1">r</span>;
+        E removedElement = <span class="ST1">head</span>.<span class="ST1">e</span>;
+        <span class="ST1">head</span> = <span class="ST1">head</span>.<span class="ST1">r</span>;
+        <span class="ST1">head</span>.<span class="ST1">l</span> = <span class="literal">null</span>;
+
+        <span class="literal">return</span> removedElement;
+    }
+
+    <span class="comment">/**</span>
+<span class="comment">     * </span><span class="comment">Retrieves</span> <span class="comment">and</span> <span class="comment">removes</span> <span class="comment">the</span> <span class="comment">head</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">queue</span><span class="comment">, </span><span class="comment">or</span> <span class="comment">returns</span> <span class="comment">null</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">queue</span> <span class="comment">is</span> <span class="comment">empty</span><span class="comment">.</span>
+<span class="comment">     *</span>
+<span class="comment">     * </span><span class="comment">Returns</span><span class="comment">: </span><span class="comment">the</span> <span class="comment">head</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">queue</span><span class="comment">, </span><span class="comment">or</span> <span class="comment">null</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">queue</span> <span class="comment">is</span> <span class="comment">empty</span>
+<span class="comment">     *</span>
+<span class="comment">     * </span><span class="comment">@return</span>
+     <span class="comment">*/</span>
+    @Override
+    <span class="literal">public</span> E <span class="ST4">poll</span>() {
+        <span class="literal">if</span> (size() == <span class="number">0</span>) {
+            <span class="literal">return</span> <span class="literal">null</span>;
+        }
+        <span class="literal">if</span> (size() &gt; <span class="number">1</span>) {
+            <span class="ST1">head</span> = <span class="ST1">head</span>.<span class="ST1">r</span>;
+
+            E e = <span class="ST1">head</span>.<span class="ST1">l</span>.<span class="ST1">e</span>;
+            <span class="ST1">head</span>.<span class="ST1">l</span> = <span class="literal">null</span>;
+            <span class="literal">return</span> e;
+        } <span class="literal">else</span> <span class="comment">//size 1</span>
+        {
+            E e = <span class="ST1">head</span>.<span class="ST1">e</span>;
+            <span class="ST1">head</span> = <span class="ST1">tail</span> = <span class="literal">null</span>;
+            <span class="literal">return</span> e;
+        }
+    }
+
+    <span class="comment">/**</span>
+<span class="comment">     * </span><span class="comment">Retrieves</span><span class="comment">, </span><span class="comment">but</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">remove</span><span class="comment">, </span><span class="comment">the</span> <span class="comment">head</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">queue</span><span class="comment">.</span> <span class="comment">This</span> <span class="comment">method</span> <span class="comment">differs</span> <span class="comment">from</span><span class="comment"> {</span><span class="comment">@link</span> <span class="comment">#</span><span class="comment">peek</span> <span class="comment">peek</span><span class="comment">} </span><span class="comment">only</span> <span class="comment">in</span> <span class="comment">that</span> <span class="comment">it</span> <span class="comment">throws</span> <span class="comment">an</span> <span class="comment">exception</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">queue</span> <span class="comment">is</span> <span class="comment">empty</span><span class="comment">.</span>
+<span class="comment">     *</span>
+<span class="comment">     * </span><span class="comment">@return</span> <span class="comment">the</span> <span class="comment">head</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">queue</span>
+<span class="comment">     * </span><span class="comment">@throws</span> <span class="comment">NoSuchElementException</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">queue</span> <span class="comment">is</span> <span class="comment">empty</span>
+     <span class="comment">*/</span>
+    @Override
+    <span class="literal">public</span> E <span class="ST4">element</span>() {
+        <span class="literal">if</span> (<span class="ST1">head</span> != <span class="literal">null</span>) {
+            <span class="literal">return</span> (E) <span class="ST1">head</span>;
+        } <span class="literal">else</span> {
+            <span class="literal">throw</span> <span class="literal">new</span> NoSuchElementException(<span class="string">&quot;</span><span class="string">Element does not exist.</span><span class="string">&quot;</span>);
+        }
+    }
+
+    <span class="comment">/**</span>
+<span class="comment">     * </span><span class="comment">Retrieves</span><span class="comment">, </span><span class="comment">but</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">remove</span><span class="comment">, </span><span class="comment">the</span> <span class="comment">head</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">queue</span><span class="comment">, </span><span class="comment">or</span> <span class="comment">returns</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">null</span><span class="comment">}</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">queue</span> <span class="comment">is</span> <span class="comment">empty</span><span class="comment">.</span>
+<span class="comment">     *</span>
+<span class="comment">     * </span><span class="comment">@return</span> <span class="comment">the</span> <span class="comment">head</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">queue</span><span class="comment">, </span><span class="comment">or</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">null</span><span class="comment">}</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">queue</span> <span class="comment">is</span> <span class="comment">empty</span>
+     <span class="comment">*/</span>
+    @Override
+    <span class="literal">public</span> E <span class="ST4">peek</span>() {
+        <span class="literal">return</span> (E) <span class="ST1">head</span>;
+    }
+
+    @Override
+    <span class="literal">public</span> <span class="literal">boolean</span> <span class="ST4">isEmpty</span>() {
+        <span class="literal">return</span> <span class="ST1">head</span> == <span class="literal">null</span> &amp;&amp; <span class="ST1">tail</span> == <span class="literal">null</span> ? <span class="literal">true</span> : <span class="literal">false</span>;
+
+    }
+
+    <span class="comment">/**</span>
+<span class="comment">     * </span><span class="comment">Returns</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">true</span><span class="comment">}</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">contains</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</span><span class="comment">.</span> <span class="comment">More</span> <span class="comment">formally</span><span class="comment">, </span><span class="comment">returns</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">true</span><span class="comment">}</span> <span class="comment">if</span> <span class="comment">and</span> <span class="comment">only</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">contains</span> <span class="comment">at</span> <span class="comment">least</span> <span class="comment">one</span> <span class="comment">element</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">e</span><span class="comment">}</span> <span class="comment">such</span> <span class="comment">that</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">Objects</span><span class="comment">.</span><span class="comment">equals</span><span class="comment">(</span><span class="comment">o</span><span class="comment">, </span><span class="comment">e</span><span class="comment">)</span><span class="comment">}</span><span class="comment">.</span>
+<span class="comment">     *</span>
+<span class="comment">     * </span><span class="comment">@param</span> <span class="ST3">o</span> <span class="comment">element</span> <span class="comment">whose</span> <span class="comment">presence</span> <span class="comment">in</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">is</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">tested</span>
+<span class="comment">     * </span><span class="comment">@return</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">true</span><span class="comment">}</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">contains</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</span>
+<span class="comment">     * </span><span class="comment">@throws</span> <span class="comment">ClassCastException</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">type</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</span> <span class="comment">is</span> <span class="comment">incompatible</span> <span class="comment">with</span> <span class="comment">this</span> <span class="comment">collection</span><span class="comment"> ({</span><span class="comment">@linkplain</span> <span class="comment">Collection</span><span class="comment">#</span><span class="comment">#</span><span class="comment">optional</span><span class="comment">-</span><span class="comment">restrictions</span> <span class="comment">optional</span><span class="comment">})</span>
+<span class="comment">     * </span><span class="comment">@throws</span> <span class="comment">NullPointerException</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</span> <span class="comment">is</span> <span class="comment">null</span> <span class="comment">and</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">permit</span> <span class="comment">null</span> <span class="comment">elements</span><span class="comment"> ({</span><span class="comment">@linkplain</span> <span class="comment">Collection</span><span class="comment">#</span><span class="comment">#</span><span class="comment">optional</span><span class="comment">-</span><span class="comment">restrictions</span> <span class="comment">optional</span><span class="comment">})</span>
+     <span class="comment">*/</span>
+    @Override
+    <span class="literal">public</span> <span class="literal">boolean</span> <span class="ST4">contains</span>(Object o) {
+        Node&lt;E&gt; pointer = <span class="ST1">head</span>;
+        <span class="literal">do</span> {
+            <span class="literal">if</span> (pointer.equals(o)) {
+                <span class="literal">return</span> <span class="literal">true</span>;
+            } <span class="literal">else</span> {
+                pointer = pointer.<span class="ST1">r</span>;
+            }
+        } <span class="literal">while</span> (pointer != <span class="literal">null</span>);
+        <span class="literal">return</span> <span class="literal">false</span>;
+    }
+
+    @Override
+    <span class="literal">public</span> Iterator&lt;E&gt; <span class="ST4">iterator</span>() {
+        Iterator&lt;E&gt; it = <span class="literal">new</span> Iterator&lt;E&gt;() {
+            Node&lt;E&gt; <span class="ST1">p</span> = <span class="ST1">head</span>;
+
+            @Override
+            <span class="literal">public</span> <span class="literal">boolean</span> <span class="ST4">hasNext</span>() {
+                <span class="literal">return</span> <span class="ST1">p</span> == <span class="literal">null</span> ? <span class="literal">false</span> : <span class="literal">true</span>;
+            }
+
+            @Override
+            <span class="literal">public</span> E <span class="ST4">next</span>() {
+                <span class="literal">if</span> (hasNext() == <span class="literal">false</span>) {
+                    <span class="literal">throw</span> <span class="literal">new</span> NoSuchElementException(<span class="string">&quot;</span><span class="string">the is no next element</span><span class="string">&quot;</span>);
+                }
+                E e = <span class="ST1">p</span>.<span class="ST1">e</span>;
+                <span class="ST1">p</span> = <span class="ST1">p</span>.<span class="ST1">r</span>;
+                <span class="literal">return</span> e;
+            }
+
+            @Override
+            <span class="literal">public</span> <span class="literal">void</span> <span class="ST4">forEachRemaining</span>(Consumer&lt;? <span class="literal">super</span> E&gt; action) {
+                <span class="literal">while</span> (hasNext()) {
+                    action.accept(<span class="ST1">p</span>.<span class="ST1">e</span>);
+                    <span class="ST1">p</span> = <span class="ST1">p</span>.<span class="ST1">r</span>;
+                }
+            }
+        };
+
+        <span class="literal">return</span> it;
+
+    }
+
+    @Override
+    <span class="literal">public</span> Object[] <span class="ST4">toArray</span>() {
+        Node&lt;E&gt; pointer = <span class="ST1">head</span>;
+        Object[] returnArray = <span class="literal">new</span> Object[<span class="literal">this</span>.size()];
+        <span class="literal">int</span> i = <span class="number">0</span>;
+        <span class="literal">while</span> (pointer.<span class="ST1">r</span> != <span class="literal">null</span>) {
+            returnArray[i++] = pointer.<span class="ST1">e</span>;
+            pointer = pointer.<span class="ST1">r</span>;
+        }
+        returnArray[i++] = pointer.<span class="ST1">e</span>;
+        <span class="literal">return</span> returnArray;
+    }
+
+    <span class="comment">/**</span>
+<span class="comment">     * </span><span class="comment">Returns</span> <span class="comment">an</span> <span class="comment">array</span> <span class="comment">containing</span> <span class="comment">all</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">elements</span> <span class="comment">in</span> <span class="comment">this</span> <span class="comment">collection</span><span class="comment">; </span><span class="comment">the</span> <span class="comment">runtime</span> <span class="comment">type</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">returned</span> <span class="comment">array</span> <span class="comment">is</span> <span class="comment">that</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">array</span><span class="comment">.</span> <span class="comment">If</span> <span class="comment">the</span> <span class="comment">collection</span> <span class="comment">fits</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">array</span><span class="comment">, </span><span class="comment">it</span> <span class="comment">is</span> <span class="comment">returned</span> <span class="comment">therein</span><span class="comment">.</span> <span class="comment">Otherwise</span><span class="comment">, </span><span class="comment">a</span> <span class="comment">new</span> <span class="comment">array</span> <span class="comment">is</span> <span class="comment">allocated</span> <span class="comment">with</span> <span class="comment">the</span> <span class="comment">runtime</span> <span class="comment">type</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">array</span> <span class="comment">and</span> <span class="comment">the</span> <span class="comment">size</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">collection</span><span class="comment">.</span>
+<span class="comment">     *</span>
+<span class="comment">     * </span><span class="ST2">&lt;p&gt;</span>
+<span class="comment">     * </span><span class="comment">If</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">fits</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">array</span> <span class="comment">with</span> <span class="comment">room</span> <span class="comment">to</span> <span class="comment">spare</span><span class="comment"> (</span><span class="comment">i</span><span class="comment">.</span><span class="comment">e</span><span class="comment">.</span><span class="comment">, </span><span class="comment">the</span> <span class="comment">array</span> <span class="comment">has</span> <span class="comment">more</span> <span class="comment">elements</span> <span class="comment">than</span> <span class="comment">this</span> <span class="comment">collection</span><span class="comment">), </span><span class="comment">the</span> <span class="comment">element</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">array</span> <span class="comment">immediately</span> <span class="comment">following</span> <span class="comment">the</span> <span class="comment">end</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">collection</span> <span class="comment">is</span> <span class="comment">set</span> <span class="comment">to</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">null</span><span class="comment">}</span><span class="comment">.</span><span class="comment"> (</span><span class="comment">This</span> <span class="comment">is</span> <span class="comment">useful</span> <span class="comment">in</span> <span class="comment">determining</span> <span class="comment">the</span> <span class="comment">length</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="ST2">&lt;i&gt;</span><span class="comment">only</span><span class="ST2">&lt;/i&gt;</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">caller</span> <span class="comment">knows</span> <span class="comment">that</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">contain</span> <span class="comment">any</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">null</span><span class="comment">}</span> <span class="comment">elements</span><span class="comment">.</span><span class="comment">)</span>
+<span class="comment">     *</span>
+<span class="comment">     * </span><span class="ST2">&lt;p&gt;</span>
+<span class="comment">     * </span><span class="comment">If</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">makes</span> <span class="comment">any</span> <span class="comment">guarantees</span> <span class="comment">as</span> <span class="comment">to</span> <span class="comment">what</span> <span class="comment">order</span> <span class="comment">its</span> <span class="comment">elements</span> <span class="comment">are</span> <span class="comment">returned</span> <span class="comment">by</span> <span class="comment">its</span> <span class="comment">iterator</span><span class="comment">, </span><span class="comment">this</span> <span class="comment">method</span> <span class="comment">must</span> <span class="comment">return</span> <span class="comment">the</span> <span class="comment">elements</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">same</span> <span class="comment">order</span><span class="comment">.</span>
+<span class="comment">     *</span>
+<span class="comment">     * </span><span class="comment">@apiNote</span> <span class="comment">This</span> <span class="comment">method</span> <span class="comment">acts</span> <span class="comment">as</span> <span class="comment">a</span> <span class="comment">bridge</span> <span class="comment">between</span> <span class="comment">array</span><span class="comment">-</span><span class="comment">based</span> <span class="comment">and</span> <span class="comment">collection</span><span class="comment">-</span><span class="comment">based</span> <span class="comment">APIs</span><span class="comment">.</span> <span class="comment">It</span> <span class="comment">allows</span> <span class="comment">an</span> <span class="comment">existing</span> <span class="comment">array</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">reused</span> <span class="comment">under</span> <span class="comment">certain</span> <span class="comment">circumstances</span><span class="comment">.</span> <span class="comment">Use</span><span class="comment"> {</span><span class="comment">@link</span> <span class="comment">#</span><span class="comment">toArray</span><span class="comment">()} </span><span class="comment">to</span> <span class="comment">create</span> <span class="comment">an</span> <span class="comment">array</span> <span class="comment">whose</span> <span class="comment">runtime</span> <span class="comment">type</span> <span class="comment">is</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">Object</span><span class="comment">[]</span><span class="comment">}, </span><span class="comment">or</span> <span class="comment">use</span><span class="comment"> {</span><span class="comment">@link</span> <span class="comment">#</span><span class="comment">toArray</span><span class="comment">(</span><span class="comment">IntFunction</span><span class="comment">)} </span><span class="comment">to</span> <span class="comment">control</span> <span class="comment">the</span> <span class="comment">runtime</span> <span class="comment">type</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">array</span><span class="comment">.</span>
+<span class="comment">     *</span>
+<span class="comment">     * </span><span class="ST2">&lt;p&gt;</span>
+<span class="comment">     * </span><span class="comment">Suppose</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">x</span><span class="comment">}</span> <span class="comment">is</span> <span class="comment">a</span> <span class="comment">collection</span> <span class="comment">known</span> <span class="comment">to</span> <span class="comment">contain</span> <span class="comment">only</span> <span class="comment">strings</span><span class="comment">.</span> <span class="comment">The</span> <span class="comment">following</span> <span class="comment">code</span> <span class="comment">can</span> <span class="comment">be</span> <span class="comment">used</span> <span class="comment">to</span> <span class="comment">dump</span> <span class="comment">the</span> <span class="comment">collection</span> <span class="comment">into</span> <span class="comment">a</span> <span class="comment">previously</span> <span class="comment">allocated</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">String</span><span class="comment">}</span> <span class="comment">array</span><span class="comment">:</span>
+<span class="comment">     *</span>
+<span class="comment">     * </span><span class="ST2">&lt;pre&gt;</span>
+<span class="comment">     *     </span><span class="comment">String</span><span class="comment">[] </span><span class="comment">y</span><span class="comment"> = </span><span class="comment">new</span> <span class="comment">String</span><span class="comment">[</span><span class="comment">SIZE</span><span class="comment">];</span>
+<span class="comment">     *     </span><span class="comment">.</span><span class="comment">.</span><span class="comment">.</span>
+<span class="comment">     *     </span><span class="comment">y</span><span class="comment"> = </span><span class="comment">x</span><span class="comment">.</span><span class="comment">toArray</span><span class="comment">(</span><span class="comment">y</span><span class="comment">);</span><span class="ST2">&lt;/pre&gt;</span>
+<span class="comment">     *</span>
+<span class="comment">     * </span><span class="ST2">&lt;p&gt;</span>
+<span class="comment">     * </span><span class="comment">The</span> <span class="comment">return</span> <span class="comment">value</span> <span class="comment">is</span> <span class="comment">reassigned</span> <span class="comment">to</span> <span class="comment">the</span> <span class="comment">variable</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">y</span><span class="comment">}</span><span class="comment">, </span><span class="comment">because</span> <span class="comment">a</span> <span class="comment">new</span> <span class="comment">array</span> <span class="comment">will</span> <span class="comment">be</span> <span class="comment">allocated</span> <span class="comment">and</span> <span class="comment">returned</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">collection</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">x</span><span class="comment">}</span> <span class="comment">has</span> <span class="comment">too</span> <span class="comment">many</span> <span class="comment">elements</span> <span class="comment">to</span> <span class="comment">fit</span> <span class="comment">into</span> <span class="comment">the</span> <span class="comment">existing</span> <span class="comment">array</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">y</span><span class="comment">}</span><span class="comment">.</span>
+<span class="comment">     *</span>
+<span class="comment">     * </span><span class="ST2">&lt;p&gt;</span>
+<span class="comment">     * </span><span class="comment">Note</span> <span class="comment">that</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">toArray</span><span class="comment">(</span><span class="comment">new</span> <span class="comment">Object</span><span class="comment">[0])</span><span class="comment">} </span><span class="comment">is</span> <span class="comment">identical</span> <span class="comment">in</span> <span class="comment">function</span> <span class="comment">to</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">toArray</span><span class="comment">()</span><span class="comment">}</span><span class="comment">.</span>
+<span class="comment">     *</span>
+<span class="comment">     * </span><span class="comment">@param</span> <span class="ST3">&lt;T&gt;</span> <span class="comment">the</span> <span class="comment">component</span> <span class="comment">type</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">array</span> <span class="comment">to</span> <span class="comment">contain</span> <span class="comment">the</span> <span class="comment">collection</span>
+<span class="comment">     * </span><span class="comment">@param</span> <span class="ST3">a</span> <span class="comment">the</span> <span class="comment">array</span> <span class="comment">into</span> <span class="comment">which</span> <span class="comment">the</span> <span class="comment">elements</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">are</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">stored</span><span class="comment">, </span><span class="comment">if</span> <span class="comment">it</span> <span class="comment">is</span> <span class="comment">big</span> <span class="comment">enough</span><span class="comment">; </span><span class="comment">otherwise</span><span class="comment">, </span><span class="comment">a</span> <span class="comment">new</span> <span class="comment">array</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">same</span> <span class="comment">runtime</span> <span class="comment">type</span> <span class="comment">is</span> <span class="comment">allocated</span> <span class="comment">for</span> <span class="comment">this</span> <span class="comment">purpose</span><span class="comment">.</span>
+<span class="comment">     * </span><span class="comment">@return</span> <span class="comment">an</span> <span class="comment">array</span> <span class="comment">containing</span> <span class="comment">all</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">elements</span> <span class="comment">in</span> <span class="comment">this</span> <span class="comment">collection</span>
+<span class="comment">     * </span><span class="comment">@throws</span> <span class="comment">ArrayStoreException</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">runtime</span> <span class="comment">type</span> <span class="comment">of</span> <span class="comment">any</span> <span class="comment">element</span> <span class="comment">in</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">is</span> <span class="comment">not</span> <span class="comment">assignable</span> <span class="comment">to</span> <span class="comment">the</span><span class="comment"> {</span><span class="comment">@linkplain</span> <span class="comment">Class</span><span class="comment">#</span><span class="comment">getComponentType</span>
+<span class="comment">     *         </span><span class="comment">runtime</span> <span class="comment">component</span> <span class="comment">type</span><span class="comment">} </span><span class="comment">of</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">array</span>
+<span class="comment">     * </span><span class="comment">@throws</span> <span class="comment">NullPointerException</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">array</span> <span class="comment">is</span> <span class="comment">null</span>
+     <span class="comment">*/</span>
+    @Override
+    <span class="literal">public</span> &lt;T&gt; T[] <span class="ST4">toArray</span>(T[] a) {
+        a = Arrays.<span class="ST5">copyOf</span>(a, <span class="literal">t</span><span class="literal">his</span>.size());
+        Node&lt;E&gt; pointer = <span class="ST1">head</span>;
+        System.<span class="ST6">out</span>.println(a.getClass());
+        System.<span class="ST6">out</span>.println(pointer.getClass());
+        System.<span class="ST6">out</span>.println(pointer.<span class="ST1">e</span>.getClass());
+
+        <span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; <span class="literal">this</span>.size(); ++i) {
+            a[i] = (T) pointer.<span class="ST1">e</span>;
+            pointer = pointer.<span class="ST1">r</span>;
+        }
+        <span class="literal">return</span> a;
+    }
+
+    <span class="comment">/**</span>
+<span class="comment">     * </span><span class="comment">Removes</span> <span class="comment">a</span> <span class="comment">single</span> <span class="comment">instance</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</span> <span class="comment">from</span> <span class="comment">this</span> <span class="comment">collection</span><span class="comment">, </span><span class="comment">if</span> <span class="comment">it</span> <span class="comment">is</span> <span class="comment">present</span><span class="comment"> (</span><span class="comment">optional</span> <span class="comment">operation</span><span class="comment">)</span><span class="comment">.</span> <span class="comment">More</span> <span class="comment">formally</span><span class="comment">, </span><span class="comment">removes</span> <span class="comment">an</span> <span class="comment">element</span> <span class="comment">e</span> <span class="comment">such</span> <span class="comment">that</span><span class="comment"> (</span><span class="comment">o</span><span class="comment">==</span><span class="comment">null</span><span class="comment"> ? </span><span class="comment">e</span><span class="comment">==</span><span class="comment">null</span><span class="comment"> : </span><span class="comment">o</span><span class="comment">.</span><span class="comment">equals</span><span class="comment">(</span><span class="comment">e</span><span class="comment">)), </span><span class="comment">if</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">contains</span> <span class="comment">one</span> <span class="comment">or</span> <span class="comment">more</span> <span class="comment">such</span> <span class="comment">elements</span><span class="comment">.</span> <span class="comment">Returns</span> <span class="comment">true</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">contained</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</span><span class="comment"> (</span><span class="comment">or</span> <span class="comment">equivalently</span><span class="comment">, </span><span class="comment">if</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">changed</span> <span class="comment">as</span> <span class="comment">a</span> <span class="comment">result</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">call</span><span class="comment">)</span><span class="comment">.</span>
+<span class="comment">     *</span>
+<span class="comment">     * </span><span class="comment">@param</span> <span class="ST3">o</span><span class="comment"> - </span><span class="comment">element</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">removed</span> <span class="comment">from</span> <span class="comment">this</span> <span class="comment">collection</span><span class="comment">, </span><span class="comment">if</span> <span class="comment">present</span>
+<span class="comment">     * </span><span class="comment">@throws</span> <span class="comment">ClassCastException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">type</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</span> <span class="comment">is</span> <span class="comment">incompatible</span> <span class="comment">with</span> <span class="comment">this</span> <span class="comment">collection</span>
+<span class="comment">     * </span><span class="comment">@throws</span> <span class="comment">NullPointerException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</span> <span class="comment">is</span> <span class="comment">null</span> <span class="comment">and</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">permit</span> <span class="comment">null</span> <span class="comment">elements</span>
+<span class="comment">     * </span><span class="comment">@return</span> <span class="comment">true</span> <span class="comment">if</span> <span class="comment">an</span> <span class="comment">element</span> <span class="comment">was</span> <span class="comment">removed</span> <span class="comment">as</span> <span class="comment">a</span> <span class="comment">result</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">call</span>
+     <span class="comment">*/</span>
+    @Override
+    <span class="literal">public</span> <span class="literal">boolean</span> <span class="ST4">remove</span>(Object o) {
+        <span class="literal">if</span> (o == <span class="literal">null</span>) {
+            <span class="literal">throw</span> <span class="literal">new</span> NullPointerException(<span class="string">&quot;</span><span class="string">null vales not allowed</span><span class="string">&quot;</span>);
+        }
+        <span class="literal">if</span> (size() == <span class="number">0</span>) {
+            <span class="literal">return</span> <span class="literal">false</span>;
+        }
+
+        Node&lt;E&gt; p = <span class="literal">this</span>.<span class="ST1">head</span>;
+        <span class="literal">int</span> pos = <span class="number">0</span>;
+        <span class="literal">while</span> (p != <span class="literal">this</span>.<span class="ST1">tail</span>) {
+            <span class="literal">if</span> (p.<span class="ST1">e</span>.equals(o)) {
+                <span class="literal">if</span> (size() == <span class="number">1</span>) {
+                    <span class="literal">this</span>.<span class="ST1">head</span> = <span class="literal">this</span>.<span class="ST1">tail</span> = <span class="literal">null</span>;
+                    <span class="literal">return</span> <span class="literal">true</span>;
+                }
+                <span class="literal">this</span>.removeAt(pos, (E) o);
+                <span class="literal">break</span>;
+            }
+            ++pos;
+            p = p.<span class="ST1">r</span>;
+        }
+        <span class="literal">if</span> (p == <span class="ST1">tail</span> &amp;&amp; p.<span class="ST1">e</span>.equals(o)) {
+            <span class="literal">this</span>.removeAt(size() - <span class="number">1</span>, (E) o);
+        }
+        <span class="literal">return</span> <span class="literal">true</span>;
+    }
+
+    <span class="comment">/**</span>
+<span class="comment">     *</span>
+<span class="comment">     * </span><span class="comment">@param</span> <span class="ST3">pos</span>
+<span class="comment">     * </span><span class="comment">@param</span> <span class="ST3">e</span>
+<span class="comment">     * </span><span class="comment">@throws</span> <span class="comment">IndexOutOfBoundsException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">pos</span> <span class="comment">less</span><span class="comment"> 0 </span><span class="comment">OR</span> <span class="comment">pos</span> <span class="comment">greater</span><span class="comment">-</span><span class="comment">equal</span> <span class="comment">size</span><span class="comment">()</span>
+<span class="comment">     * </span><span class="comment">@return</span>
+     <span class="comment">*/</span>
+    <span class="literal">private</span> <span class="literal">boolean</span> <span class="ST4">removeAt</span>(<span class="literal">int</span> pos, E <span class="comment">e</span>) {
+        <span class="literal">if</span> (pos &lt; <span class="number">0</span> || pos &gt;= size()) {
+            <span class="literal">throw</span> <span class="literal">new</span> IndexOutOfBoundsException(pos + <span class="string">&quot;</span><span class="string"> is out of bounds</span><span class="string">&quot;</span>);
+        }
+        <span class="comment">//1.list is empty</span>
+        <span class="literal">if</span> (isEmpty()) {
+            <span class="literal">return</span> <span class="literal">false</span>;
+        } <span class="comment">//2. one node exists</span>
+        <span class="literal">else</span> <span class="literal">if</span> (size() == <span class="number">1</span>) {
+            <span class="literal">this</span>.<span class="ST1">head</span> = <span class="literal">this</span>.<span class="ST1">tail</span> = <span class="literal">null</span>;
+        } <span class="comment">//3. remove in the front( head)</span>
+        <span class="literal">else</span> <span class="literal">if</span> (pos == <span class="number">0</span>) {
+            <span class="literal">this</span>.<span class="ST1">head</span> = <span class="literal">this</span>.<span class="ST1">head</span>.<span class="ST1">r</span>;
+            <span class="ST1">head</span>.<span class="ST1">l</span> = <span class="literal">null</span>;
+        } <span class="comment">//4. remove in the end ( tail)</span>
+        <span class="literal">else</span> <span class="literal">if</span> (pos == size() - <span class="number">1</span>) {
+            <span class="literal">this</span>.<span class="ST1">tail</span> = <span class="literal">this</span>.<span class="ST1">tail</span>.<span class="ST1">l</span>;
+            <span class="literal">this</span>.<span class="ST1">tail</span>.<span class="ST1">r</span> = <span class="literal">null</span>;
+        } <span class="comment">//5. remove in the middle ( at least 3 nodes are in the queue)</span>
+        <span class="literal">else</span> {
+            Node&lt;E&gt; p = <span class="ST1">head</span>;
+            <span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; pos - <span class="number">1</span>; ++i) {
+                p = p.<span class="ST1">r</span>;
+            }
+            p.<span class="ST1">r</span> = p.<span class="ST1">r</span>.<span class="ST1">r</span>;
+            p.<span class="ST1">r</span>.<span class="ST1">l</span> = p;
+        }
+        <span class="literal">return</span> <span class="literal">true</span>;
+    }
+
+    <span class="comment">/**</span>
+<span class="comment">     * </span><span class="comment">Returns</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">true</span><span class="comment">}</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">contains</span> <span class="comment">all</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">elements</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span><span class="comment">.</span>
+<span class="comment">     *</span>
+<span class="comment">     * </span><span class="comment">@param</span> <span class="ST3">c</span> <span class="comment">collection</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">checked</span> <span class="comment">for</span> <span class="comment">containment</span> <span class="comment">in</span> <span class="comment">this</span> <span class="comment">collection</span>
+<span class="comment">     * </span><span class="comment">@return</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">true</span><span class="comment">}</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">contains</span> <span class="comment">all</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">elements</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span>
+<span class="comment">     * </span><span class="comment">@throws</span> <span class="comment">ClassCastException</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">types</span> <span class="comment">of</span> <span class="comment">one</span> <span class="comment">or</span> <span class="comment">more</span> <span class="comment">elements</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span> <span class="comment">are</span> <span class="comment">incompatible</span> <span class="comment">with</span> <span class="comment">this</span> <span class="comment">collection</span><span class="comment"> ({</span><span class="comment">@linkplain</span> <span class="comment">Collection</span><span class="comment">#</span><span class="comment">#</span><span class="comment">optional</span><span class="comment">-</span><span class="comment">restrictions</span> <span class="comment">optional</span><span class="comment">})</span>
+<span class="comment">     * </span><span class="comment">@throws</span> <span class="comment">NullPointerException</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span> <span class="comment">contains</span> <span class="comment">one</span> <span class="comment">or</span> <span class="comment">more</span> <span class="comment">null</span> <span class="comment">elements</span> <span class="comment">and</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">permit</span> <span class="comment">null</span> <span class="comment">elements</span><span class="comment"> ({</span><span class="comment">@linkplain</span> <span class="comment">Collection</span><span class="comment">#</span><span class="comment">#</span><span class="comment">optional</span><span class="comment">-</span><span class="comment">restrictions</span> <span class="comment">optional</span><span class="comment">}) </span><span class="comment">or</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span> <span class="comment">is</span> <span class="comment">null</span><span class="comment">.</span>
+<span class="comment">     * </span><span class="comment">@see</span> <span class="comment">#</span><span class="comment">contains</span><span class="comment">(</span><span class="comment">Object</span><span class="comment">)</span>
+     <span class="comment">*/</span>
+    @Override
+    <span class="literal">public</span> <span class="literal">boolean</span> <span class="ST4">containsAll</span>(Collection&lt;?&gt; c) {
+        <span class="comment">// Java already throws a CastCastException if you give it the wrong type, so we don&#39;t have to throw that ourselves</span>
+        <span class="literal">if</span> (c.contains(<span class="literal">n</span><span class="literal">ull</span>) || c == <span class="literal">null</span>) {
+            <span class="literal">throw</span> <span class="literal">new</span> NullPointerException(<span class="string">&quot;</span><span class="string">The collection you passed to containsAll() contains a null element. Cannot continue.</span><span class="string">&quot;</span>);
+        }
+        <span class="comment">// Unpack the collection so we can compare them</span>
+        Object[] compareArray = c.toArray();
+        Node&lt;E&gt; pointer = <span class="literal">null</span>;
+        <span class="literal">int</span> matchCount = <span class="number">0</span>;
+        <span class="literal">for</span> (Object compare : compareArray) {
+            pointer = <span class="ST1">head</span>;
+            <span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; size() - <span class="number">1</span>; ++i) {
+                <span class="literal">if</span> (pointer.<span class="ST1">e</span>.equals(compare)) {
+                    matchCount++;
+                }
+                pointer = pointer.<span class="ST1">r</span>;
+            }
+        }
+        <span class="literal">if</span> (matchCount == compareArray.<span class="ST1">length</span> - <span class="number">1</span>) {
+            <span class="literal">return</span> <span class="literal">true</span>;
+        }
+        <span class="literal">return</span> <span class="literal">false</span>;
+    }
+
+    <span class="comment">/**</span>
+<span class="comment">     * </span><span class="comment">Adds</span> <span class="comment">all</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">elements</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span> <span class="comment">to</span> <span class="comment">this</span> <span class="comment">collection</span><span class="comment"> (</span><span class="comment">optional</span> <span class="comment">operation</span><span class="comment">)</span><span class="comment">.</span> <span class="comment">The</span> <span class="comment">behavior</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">operation</span> <span class="comment">is</span> <span class="comment">undefined</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span> <span class="comment">is</span> <span class="comment">modified</span> <span class="comment">while</span> <span class="comment">the</span> <span class="comment">operation</span> <span class="comment">is</span> <span class="comment">in</span> <span class="comment">progress</span><span class="comment">.</span><span class="comment"> (</span><span class="comment">This</span> <span class="comment">implies</span> <span class="comment">that</span> <span class="comment">the</span> <span class="comment">behavior</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">call</span> <span class="comment">is</span> <span class="comment">undefined</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span> <span class="comment">is</span> <span class="comment">this</span> <span class="comment">collection</span><span class="comment">, </span><span class="comment">and</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">is</span> <span class="comment">nonempty</span><span class="comment">.</span><span class="comment">)</span>
+<span class="comment">     *</span>
+<span class="comment">     * </span><span class="comment">@param</span> <span class="ST3">c</span><span class="comment"> - </span><span class="comment">collection</span> <span class="comment">containing</span> <span class="comment">elements</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">added</span> <span class="comment">to</span> <span class="comment">this</span> <span class="comment">collection</span>
+<span class="comment">     * </span><span class="comment">@throws</span> <span class="comment">ClassCastException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">class</span> <span class="comment">of</span> <span class="comment">an</span> <span class="comment">element</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span> <span class="comment">prevents</span> <span class="comment">it</span> <span class="comment">from</span> <span class="comment">being</span> <span class="comment">added</span> <span class="comment">to</span> <span class="comment">this</span> <span class="comment">collection</span><span class="comment">.</span>
+<span class="comment">     * </span><span class="comment">@throws</span> <span class="comment">NullPointerException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span> <span class="comment">contains</span> <span class="comment">a</span> <span class="comment">null</span> <span class="comment">element</span> <span class="comment">and</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">permit</span> <span class="comment">null</span> <span class="comment">elements</span><span class="comment">, </span><span class="comment">or</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span> <span class="comment">is</span> <span class="comment">null</span>
+<span class="comment">     * </span><span class="comment">@throws</span> <span class="comment">IllegalArgumentException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">some</span> <span class="comment">property</span> <span class="comment">of</span> <span class="comment">an</span> <span class="comment">element</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span> <span class="comment">prevents</span> <span class="comment">it</span> <span class="comment">from</span> <span class="comment">being</span> <span class="comment">added</span> <span class="comment">to</span> <span class="comment">this</span> <span class="comment">collection</span>
+<span class="comment">     * </span><span class="comment">@throws</span> <span class="comment">IllegalArgumentException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">some</span> <span class="comment">property</span> <span class="comment">of</span> <span class="comment">an</span> <span class="comment">element</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span> <span class="comment">prevents</span> <span class="comment">it</span> <span class="comment">from</span> <span class="comment">being</span> <span class="comment">added</span> <span class="comment">to</span> <span class="comment">this</span> <span class="comment">collection</span>
+<span class="comment">     * </span><span class="comment">@return</span> <span class="comment">true</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">changed</span> <span class="comment">as</span> <span class="comment">a</span> <span class="comment">result</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">call</span>
+     <span class="comment">*/</span>
+    @Override
+    <span class="literal">public</span> <span class="literal">boolean</span> <span class="ST4">addAll</span>(Collection&lt;? <span class="literal">extends</span> E&gt; c) {
+        <span class="literal">int</span> sizeBefore = size();
+        <span class="literal">for</span> (E e : c) {
+            add(e);
+        }
+        <span class="literal">int</span> sizeAfter = size();
+        <span class="literal">return</span> sizeAfter &gt; sizeBefore;
+    }
+
+    <span class="comment">/**</span>
+<span class="comment">     * </span><span class="comment">Removes</span> <span class="comment">all</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">collection</span><span class="comment">&#39;</span><span class="comment">s</span> <span class="comment">elements</span> <span class="comment">that</span> <span class="comment">are</span> <span class="comment">also</span> <span class="comment">contained</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span><span class="comment"> (</span><span class="comment">optional</span> <span class="comment">operation</span><span class="comment">)</span><span class="comment">.</span> <span class="comment">After</span> <span class="comment">this</span> <span class="comment">call</span> <span class="comment">returns</span><span class="comment">, </span><span class="comment">this</span> <span class="comment">collection</span> <span class="comment">will</span> <span class="comment">contain</span> <span class="comment">no</span> <span class="comment">elements</span> <span class="comment">in</span> <span class="comment">common</span> <span class="comment">with</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span><span class="comment">.</span>
+<span class="comment">     *</span>
+<span class="comment">     * </span><span class="comment">@implSpec</span> <span class="comment">This</span> <span class="comment">implementation</span> <span class="comment">iterates</span> <span class="comment">over</span> <span class="comment">this</span> <span class="comment">collection</span><span class="comment">, </span><span class="comment">checking</span> <span class="comment">each</span> <span class="comment">element</span> <span class="comment">returned</span> <span class="comment">by</span> <span class="comment">the</span> <span class="comment">iterator</span> <span class="comment">in</span> <span class="comment">turn</span> <span class="comment">to</span> <span class="comment">see</span> <span class="comment">if</span> <span class="comment">it</span><span class="comment">&#39;</span><span class="comment">s</span> <span class="comment">contained</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span><span class="comment">.</span> <span class="comment">If</span> <span class="comment">it</span><span class="comment">&#39;</span><span class="comment">s</span> <span class="comment">so</span> <span class="comment">contained</span><span class="comment">, </span><span class="comment">it</span><span class="comment">&#39;</span><span class="comment">s</span> <span class="comment">removed</span> <span class="comment">from</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">with</span> <span class="comment">the</span> <span class="comment">iterator</span><span class="comment">&#39;</span><span class="comment">s</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">remove</span><span class="comment">}</span> <span class="comment">method</span><span class="comment">.</span>
+<span class="comment">     *</span>
+<span class="comment">     * </span><span class="ST2">&lt;p&gt;</span>
+<span class="comment">     * </span><span class="comment">Note</span> <span class="comment">that</span> <span class="comment">this</span> <span class="comment">implementation</span> <span class="comment">will</span> <span class="comment">throw</span> <span class="comment">an</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">UnsupportedOperationException</span><span class="comment">}</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">iterator</span> <span class="comment">returned</span> <span class="comment">by</span> <span class="comment">the</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">iterator</span><span class="comment">}</span> <span class="comment">method</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">implement</span> <span class="comment">the</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">remove</span><span class="comment">}</span> <span class="comment">method</span> <span class="comment">and</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">contains</span> <span class="comment">one</span> <span class="comment">or</span> <span class="comment">more</span> <span class="comment">elements</span> <span class="comment">in</span> <span class="comment">common</span> <span class="comment">with</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span><span class="comment">.</span>
+<span class="comment">     *</span>
+<span class="comment">     * </span><span class="comment">@throws</span> <span class="comment">UnsupportedOperationException</span><span class="comment"> {</span><span class="comment">@inheritDoc</span><span class="comment">}</span>
+<span class="comment">     * </span><span class="comment">@throws</span> <span class="comment">ClassCastException</span><span class="comment"> {</span><span class="comment">@inheritDoc</span><span class="comment">}</span>
+<span class="comment">     * </span><span class="comment">@throws</span> <span class="comment">NullPointerException</span><span class="comment"> {</span><span class="comment">@inheritDoc</span><span class="comment">}</span>
+<span class="comment">     *</span>
+<span class="comment">     * </span><span class="comment">@see</span> <span class="comment">#</span><span class="comment">remove</span><span class="comment">(</span><span class="comment">Object</span><span class="comment">)</span>
+<span class="comment">     * </span><span class="comment">@see</span> <span class="comment">#</span><span class="comment">contains</span><span class="comment">(</span><span class="comment">Object</span><span class="comment">)</span>
+     <span class="comment">*/</span>
+    @Override
+    <span class="literal">public</span> <span class="literal">boolean</span> <span class="ST4">removeAll</span>(Collection&lt;?&gt; c) {
+        <span class="literal">if</span> (c.contains(<span class="literal">n</span><span class="literal">ull</span>) || c == <span class="literal">null</span>) {
+            <span class="literal">throw</span> <span class="literal">new</span> NullPointerException(<span class="string">&quot;</span><span class="string">The collection you passed to removeAll() contains a null element. Cannot continue.</span><span class="string">&quot;</span>);
+        }
+        <span class="comment">// Unpack the collection so we can remove them</span>
+        Object[] compareArray = c.toArray();
+        Node&lt;E&gt; pointer = <span class="literal">null</span>;
+        <span class="literal">boolean</span> removeSuccessful = <span class="literal">false</span>;
+        <span class="literal">for</span> (Object compare : compareArray) {
+            pointer = <span class="ST1">head</span>;
+            <span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; size() - <span class="number">1</span>; ++i) {
+                <span class="literal">if</span> (pointer.<span class="ST1">e</span>.equals(compare)) {
+                    remove(pointer.<span class="ST1">e</span>);
+                    removeSuccessful = <span class="literal">true</span>;
+                }
+                pointer = pointer.<span class="ST1">r</span>;
+            }
+        }
+        <span class="literal">return</span> removeSuccessful;
+    }
+
+    @Override
+    <span class="literal">public</span> <span class="literal">boolean</span> <span class="ST4">retainAll</span>(Collection&lt;?&gt; c) {
+        <span class="literal">if</span> (c.contains(<span class="literal">n</span><span class="literal">ull</span>) || c == <span class="literal">null</span>) {
+            <span class="literal">throw</span> <span class="literal">new</span> NullPointerException(<span class="string">&quot;</span><span class="string">The collection you passed to retainAll() contains a null element. Cannot continue.</span><span class="string">&quot;</span>);
+        }
+        Node&lt;E&gt; pointer = <span class="literal">null</span>;
+        <span class="literal">boolean</span> removeSuccessful = <span class="literal">false</span>;
+        <span class="literal">for</span> (<span class="literal">int</span> j = <span class="number">0</span>; j &lt; c.size() - <span class="number">1</span>; ++j) {
+            pointer = <span class="ST1">head</span>;
+            <span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; size(); ++i) {
+                <span class="literal">if</span> (!c.contains(pointer.<span class="ST1">e</span>)) {
+                    remove(pointer.<span class="ST1">e</span>);
+                    removeSuccessful = <span class="literal">true</span>;
+                }
+                pointer = pointer.<span class="ST1">r</span>;
+            }
+        }
+        <span class="literal">return</span> removeSuccessful;
+    }
+
+    @Override
+    <span class="literal">public</span> <span class="literal">void</span> <span class="ST4">clear</span>() {
+        <span class="comment">// head = tail = null;</span>
+
+        <span class="comment">//extra, no necessary to set the link of every node</span>
+        Node&lt;E&gt; p = <span class="ST1">head</span>;
+        <span class="literal">while</span> (p != <span class="ST1">tail</span>) {
+            p = p.<span class="ST1">r</span>;
+            p.<span class="ST1">l</span> = <span class="literal">null</span>;
+        }
+        <span class="ST1">head</span> = <span class="ST1">tail</span> = <span class="literal">null</span>;
+    }
+
+    @Override
+    <span class="literal">public</span> <span class="literal">void</span> <span class="ST4">forEach</span>(Consumer&lt;? <span class="literal">super</span> E&gt; action) {
+        <span class="comment">//1. use a pointer that points to the head</span>
+        <span class="comment">//2. while the pointer has not reached the end of the queue </span>
+        <span class="comment">//consume it</span>
+        Node&lt;E&gt; p = <span class="ST1">head</span>;
+        <span class="literal">while</span> (p != <span class="literal">null</span>) {
+            action.accept(p.<span class="ST1">e</span>);
+            p = p.<span class="ST1">r</span>;
+        }
+
+    }
+
+    @Override
+    <span class="literal">public</span> String <span class="ST4">toString</span>() {
+        String s = <span class="string">&quot;</span><span class="string">PriorityQueueASDV {</span><span class="string">&quot;</span>;
+        Node&lt;E&gt; p = <span class="ST1">head</span>;
+        <span class="literal">while</span> (p != <span class="literal">null</span>) {
+            s += p.<span class="ST1">e</span>.toString();
+            <span class="literal">if</span> (p != <span class="ST1">tail</span>) {
+                s += <span class="string">&quot;</span><span class="string">, </span><span class="string">&quot;</span>;
+            }
+            p = p.<span class="ST1">r</span>;
+        }
+
+        s += <span class="string">&quot;</span><span class="string">}</span><span class="string">&quot;</span>;
+        <span class="literal">return</span> s;
+    }
+
+    @Override
+    <span class="literal">protected</span> Object <span class="ST4">clone</span>()
+            <span class="literal">throws</span> CloneNotSupportedException {
+        PriorityQueueASDV&lt;E&gt; c = (PriorityQueueASDV&lt;E&gt;) <span class="literal">super</span>.clone();
+        <span class="literal">return</span> c;
+    }
+
+    <span class="literal">public</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST7">main</span>(String[] args) {
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="string">--&gt; PriorityQueueASDV  testing add</span><span class="string">&quot;</span>);
+        PriorityQueueASDV&lt;String&gt; pq1 = <span class="literal">new</span> PriorityQueueASDV();
+        pq1.add(<span class="string">&quot;</span><span class="string">Paris</span><span class="string">&quot;</span>);
+        pq1.add(<span class="string">&quot;</span><span class="string">Athens</span><span class="string">&quot;</span>);
+        pq1.add(<span class="string">&quot;</span><span class="string">London</span><span class="string">&quot;</span>);
+        pq1.add(<span class="string">&quot;</span><span class="string">Lafayette</span><span class="string">&quot;</span>);
+        pq1.add(<span class="string">&quot;</span><span class="string">Berlin</span><span class="string">&quot;</span>);
+
+        System.<span class="ST6">out</span>.println(pq1);
+
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="string">--&gt; Colllections PriorityQueue testing add</span><span class="string">&quot;</span>);
+
+        PriorityQueue&lt;String&gt; pq2 = <span class="literal">new</span> PriorityQueue();
+        pq2.add(<span class="string">&quot;</span><span class="string">Paris</span><span class="string">&quot;</span>);
+        pq2.add(<span class="string">&quot;</span><span class="string">Athens</span><span class="string">&quot;</span>);
+        pq2.add(<span class="string">&quot;</span><span class="string">London</span><span class="string">&quot;</span>);
+        pq2.add(<span class="string">&quot;</span><span class="string">Lafayette</span><span class="string">&quot;</span>);
+        pq2.add(<span class="string">&quot;</span><span class="string">Berlin</span><span class="string">&quot;</span>);
+
+        System.<span class="ST6">out</span>.println(pq2);
+
+        <span class="comment">//TEST IT FULLY HERE. FOR ALL METHODS AND ALL CASES.</span>
+        <span class="comment">//Have the Jzva PriorityQueue below</span>
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="string">--&gt; PriorityQueueASDV  testing remove(object o)</span><span class="string">&quot;</span>);
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">remove from front Athens</span><span class="string">&quot;</span>);
+        pq1.remove(<span class="string">&quot;</span><span class="string">Athens</span><span class="string">&quot;</span>);
+        pq2.remove(<span class="string">&quot;</span><span class="string">Athens</span><span class="string">&quot;</span>);
+        System.<span class="ST6">out</span>.println(pq1);
+        System.<span class="ST6">out</span>.println(pq2);
+
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">remove from end Paris</span><span class="string">&quot;</span>);
+        pq1.remove(<span class="string">&quot;</span><span class="string">Paris</span><span class="string">&quot;</span>);
+        pq2.remove(<span class="string">&quot;</span><span class="string">Paris</span><span class="string">&quot;</span>);
+        System.<span class="ST6">out</span>.println(pq1);
+        System.<span class="ST6">out</span>.println(pq1);
+
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">remove from the middle Lafayette</span><span class="string">&quot;</span>);
+        pq1.remove(<span class="string">&quot;</span><span class="string">Lafayette</span><span class="string">&quot;</span>);
+        pq2.remove(<span class="string">&quot;</span><span class="string">Lafayette</span><span class="string">&quot;</span>);
+        System.<span class="ST6">out</span>.println(pq1);
+        System.<span class="ST6">out</span>.println(pq2);
+
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">add at the end Stocholm</span><span class="string">&quot;</span>);
+        pq1.add(<span class="string">&quot;</span><span class="string">Stocholm</span><span class="string">&quot;</span>);
+        pq2.add(<span class="string">&quot;</span><span class="string">Stocholm</span><span class="string">&quot;</span>);
+        System.<span class="ST6">out</span>.println(pq1);
+        System.<span class="ST6">out</span>.println(pq2);
+
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">remove from the middle London</span><span class="string">&quot;</span>);
+        pq1.remove(<span class="string">&quot;</span><span class="string">London</span><span class="string">&quot;</span>);
+        pq2.remove(<span class="string">&quot;</span><span class="string">London</span><span class="string">&quot;</span>);
+        System.<span class="ST6">out</span>.println(pq1);
+        System.<span class="ST6">out</span>.println(pq2);
+
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">remove from the front Berlin</span><span class="string">&quot;</span>);
+        pq1.remove(<span class="string">&quot;</span><span class="string">Berlin</span><span class="string">&quot;</span>);
+        pq2.remove(<span class="string">&quot;</span><span class="string">Berlin</span><span class="string">&quot;</span>);
+        System.<span class="ST6">out</span>.println(pq1);
+        System.<span class="ST6">out</span>.println(pq2);
+
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">remove from the front/end Stocholm</span><span class="string">&quot;</span>);
+        pq1.remove(<span class="string">&quot;</span><span class="string">Stocholm</span><span class="string">&quot;</span>);
+        pq2.remove(<span class="string">&quot;</span><span class="string">Stocholm</span><span class="string">&quot;</span>);
+        System.<span class="ST6">out</span>.println(pq1);
+        System.<span class="ST6">out</span>.println(pq2);
+
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">remove from empty queue</span><span class="string">&quot;</span>);
+        pq1.remove(<span class="string">&quot;</span><span class="string">Stocholm</span><span class="string">&quot;</span>);
+        pq2.remove(<span class="string">&quot;</span><span class="string">Stocholm</span><span class="string">&quot;</span>);
+        System.<span class="ST6">out</span>.println(pq1);
+        System.<span class="ST6">out</span>.println(pq2);
+
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="string">--&gt; PriorityQueueASDV  recreate priority queues from empty</span><span class="string">&quot;</span>);
+        pq1.add(<span class="string">&quot;</span><span class="string">Paris</span><span class="string">&quot;</span>);
+        pq1.add(<span class="string">&quot;</span><span class="string">Athens</span><span class="string">&quot;</span>);
+        pq1.add(<span class="string">&quot;</span><span class="string">London</span><span class="string">&quot;</span>);
+        pq1.add(<span class="string">&quot;</span><span class="string">Lafayette</span><span class="string">&quot;</span>);
+        pq1.add(<span class="string">&quot;</span><span class="string">Berlin</span><span class="string">&quot;</span>);
+        pq1.add(<span class="string">&quot;</span><span class="string">Zurich</span><span class="string">&quot;</span>);
+
+        pq2.add(<span class="string">&quot;</span><span class="string">Paris</span><span class="string">&quot;</span>);
+        pq2.add(<span class="string">&quot;</span><span class="string">Athens</span><span class="string">&quot;</span>);
+        pq2.add(<span class="string">&quot;</span><span class="string">London</span><span class="string">&quot;</span>);
+        pq2.add(<span class="string">&quot;</span><span class="string">Lafayette</span><span class="string">&quot;</span>);
+        pq2.add(<span class="string">&quot;</span><span class="string">Berlin</span><span class="string">&quot;</span>);
+        pq2.add(<span class="string">&quot;</span><span class="string">Zurich</span><span class="string">&quot;</span>);
+        System.<span class="ST6">out</span>.println(pq1);
+        System.<span class="ST6">out</span>.println(pq2);
+
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\n</span><span class="string">+++HERE YOU TEST ALL YOUR METHODS FULLY, and the methods of Colleciion PriorityQueue</span><span class="string">&quot;</span>);
+
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">  offer New York</span><span class="string">&quot;</span>);
+        pq1.offer(<span class="string">&quot;</span><span class="string">New York</span><span class="string">&quot;</span>);
+        pq2.offer(<span class="string">&quot;</span><span class="string">New York</span><span class="string">&quot;</span>);
+        System.<span class="ST6">out</span>.println(pq1);
+        System.<span class="ST6">out</span>.println(pq2);
+
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">  offer Miami</span><span class="string">&quot;</span>);
+        pq1.offer(<span class="string">&quot;</span><span class="string">Miami</span><span class="string">&quot;</span>);
+        pq2.offer(<span class="string">&quot;</span><span class="string">Miami</span><span class="string">&quot;</span>);
+        System.<span class="ST6">out</span>.println(pq1);
+        System.<span class="ST6">out</span>.println(pq2);
+
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">  offer null</span><span class="string">&quot;</span>);
+        <span class="literal">try</span> {
+            pq1.offer(<span class="literal">n</span><span class="literal">ull</span>);
+        } <span class="literal">catch</span> (Exception e) {
+            System.<span class="ST6">err</span>.println(e);
+        }
+
+        <span class="literal">try</span> {
+            pq2.offer(<span class="literal">n</span><span class="literal">ull</span>);
+        } <span class="literal">catch</span> (Exception e) {
+            System.<span class="ST6">err</span>.println(e);
+        }
+        System.<span class="ST6">out</span>.println(pq1);
+        System.<span class="ST6">out</span>.println(pq2);
+
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">  offer ClassCastException with Object</span><span class="string">&quot;</span>);
+        <span class="literal">try</span> {
+            pq1.offer((String) <span class="literal">new</span> Object());
+        } <span class="literal">catch</span> (Exception e) {
+            System.<span class="ST6">err</span>.println(e);
+        }
+
+        <span class="literal">try</span> {
+            pq2.offer((String) <span class="literal">new</span> Object());
+        } <span class="literal">catch</span> (Exception e) {
+            System.<span class="ST6">err</span>.println(e);
+        }
+        System.<span class="ST6">out</span>.println(pq1);
+        System.<span class="ST6">out</span>.println(pq2);
+
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">  poll suposed to be Athens</span><span class="string">&quot;</span>);
+        System.<span class="ST6">out</span>.println(pq1.poll());
+        System.<span class="ST6">out</span>.println(pq2.poll());
+        System.<span class="ST6">out</span>.println(pq1);
+        System.<span class="ST6">out</span>.println(pq2);
+
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">  Iterator</span><span class="string">&quot;</span>);
+        Iterator&lt;String&gt; it1 = pq1.iterator();
+        Iterator&lt;String&gt; it2 = pq2.iterator();
+
+        <span class="literal">while</span> (it1.hasNext()) {
+            System.<span class="ST6">out</span>.print(it1.next() + <span class="string">&quot;</span> <span class="string">&quot;</span>);
+        }
+
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">&quot;</span>);
+
+        <span class="literal">while</span> (it2.hasNext()) {
+            System.<span class="ST6">out</span>.print(it2.next() + <span class="string">&quot;</span> <span class="string">&quot;</span>);
+        }
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">&quot;</span>);
+
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">  Iterator NoSuchElementException </span><span class="string">&quot;</span>);
+
+        <span class="literal">try</span> {
+            System.<span class="ST6">out</span>.println(it1.next());
+        } <span class="literal">catch</span> (NoSuchElementException e) {
+            System.<span class="ST6">err</span>.println(e);
+        }
+        <span class="literal">try</span> {
+            System.<span class="ST6">out</span>.println(it2.next());
+        } <span class="literal">catch</span> (NoSuchElementException e) {
+            System.<span class="ST6">err</span>.println(e);
+        }
+
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">  Iterator foreach </span><span class="string">&quot;</span>);
+        it1 = pq1.iterator();
+        it2 = pq2.iterator();
+        it1.forEachRemaining(<span class="literal">new</span> Consumer() {
+            @Override
+            <span class="literal">public</span> <span class="literal">void</span> <span class="ST4">accept</span>(Object t) {
+                System.<span class="ST6">out</span>.print(t + <span class="string">&quot;</span><span class="string">***  </span><span class="string">&quot;</span>);
+            }
+        });
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">&quot;</span>);
+        it2.forEachRemaining(<span class="literal">new</span> Consumer() {
+            @Override
+            <span class="literal">public</span> <span class="literal">void</span> <span class="ST4">accept</span>(Object t) {
+                System.<span class="ST6">out</span>.print(t + <span class="string">&quot;</span><span class="string">+++  </span><span class="string">&quot;</span>);
+            }
+        });
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">&quot;</span>);
+
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">  addAll  Houston Chicago</span><span class="string">&quot;</span>);
+        List&lt;String&gt; ar1 = Arrays.<span class="ST5">asList</span>(<span class="string">&quot;</span><span class="string">Houston</span><span class="string">&quot;</span>, <span class="string">&quot;</span><span class="string">Chicago</span><span class="string">&quot;</span>);
+        pq1.addAll(ar1);
+        pq2.addAll(ar1);
+        System.<span class="ST6">out</span>.println(pq1);
+        System.<span class="ST6">out</span>.println(pq2);
+
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">  clear</span><span class="string">&quot;</span>);
+        pq1.clear();
+        pq2.clear();
+        System.<span class="ST6">out</span>.println(pq1);
+        System.<span class="ST6">out</span>.println(pq2);
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">&quot;</span>);
+
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="string">--&gt; PriorityQueueASDV  recreate priority queues from empty</span><span class="string">&quot;</span>);
+        pq1.add(<span class="string">&quot;</span><span class="string">Paris</span><span class="string">&quot;</span>);
+        pq1.add(<span class="string">&quot;</span><span class="string">Athens</span><span class="string">&quot;</span>);
+        pq1.add(<span class="string">&quot;</span><span class="string">London</span><span class="string">&quot;</span>);
+        pq1.add(<span class="string">&quot;</span><span class="string">Lafayette</span><span class="string">&quot;</span>);
+        pq1.add(<span class="string">&quot;</span><span class="string">Berlin</span><span class="string">&quot;</span>);
+        pq1.add(<span class="string">&quot;</span><span class="string">Zurich</span><span class="string">&quot;</span>);
+
+        pq2.add(<span class="string">&quot;</span><span class="string">Paris</span><span class="string">&quot;</span>);
+        pq2.add(<span class="string">&quot;</span><span class="string">Athens</span><span class="string">&quot;</span>);
+        pq2.add(<span class="string">&quot;</span><span class="string">London</span><span class="string">&quot;</span>);
+        pq2.add(<span class="string">&quot;</span><span class="string">Lafayette</span><span class="string">&quot;</span>);
+        pq2.add(<span class="string">&quot;</span><span class="string">Berlin</span><span class="string">&quot;</span>);
+        pq2.add(<span class="string">&quot;</span><span class="string">Zurich</span><span class="string">&quot;</span>);
+        System.<span class="ST6">out</span>.println(pq1);
+        System.<span class="ST6">out</span>.println(pq2);
+
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">  forEach</span><span class="string">&quot;</span>);
+        pq1.forEach(<span class="literal">new</span> Consumer() {
+            @Override
+            <span class="literal">public</span> <span class="literal">void</span> <span class="ST4">accept</span>(Object t) {
+                System.<span class="ST6">out</span>.print(t + <span class="string">&quot;</span><span class="string">*** </span><span class="string">&quot;</span>);
+            }
+        });
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">&quot;</span>);
+        pq2.forEach(<span class="literal">new</span> Consumer() {
+            @Override
+            <span class="literal">public</span> <span class="literal">void</span> <span class="ST4">accept</span>(Object t) {
+                System.<span class="ST6">out</span>.print(t + <span class="string">&quot;</span><span class="string">+++ </span><span class="string">&quot;</span>);
+            }
+        });
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">&quot;</span>);
+
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">  clone</span><span class="string">&quot;</span>);
+        <span class="literal">try</span> {
+            PriorityQueueASDV&lt;String&gt; pq1Cloned
+                    = (PriorityQueueASDV&lt;String&gt;) pq1.clone();
+            System.<span class="ST6">out</span>.println(pq1Cloned);
+            pq1Cloned.add(<span class="string">&quot;</span><span class="string">Las Vegas</span><span class="string">&quot;</span>);
+            System.<span class="ST6">out</span>.println(pq1Cloned);
+            System.<span class="ST6">out</span>.println(pq1);
+
+        } <span class="literal">catch</span> (CloneNotSupportedException e) {
+            System.<span class="ST6">err</span>.println(e);
+        }
+        pq1.clear();
+        pq2.clear();
+        pq1.add(<span class="string">&quot;</span><span class="string">Paris</span><span class="string">&quot;</span>);
+        pq1.add(<span class="string">&quot;</span><span class="string">Athens</span><span class="string">&quot;</span>);
+        pq1.add(<span class="string">&quot;</span><span class="string">London</span><span class="string">&quot;</span>);
+        pq1.add(<span class="string">&quot;</span><span class="string">Lafayette</span><span class="string">&quot;</span>);
+        pq1.add(<span class="string">&quot;</span><span class="string">Berlin</span><span class="string">&quot;</span>);
+        pq1.add(<span class="string">&quot;</span><span class="string">Zurich</span><span class="string">&quot;</span>);
+
+        pq2.add(<span class="string">&quot;</span><span class="string">Paris</span><span class="string">&quot;</span>);
+        pq2.add(<span class="string">&quot;</span><span class="string">Athens</span><span class="string">&quot;</span>);
+        pq2.add(<span class="string">&quot;</span><span class="string">London</span><span class="string">&quot;</span>);
+        pq2.add(<span class="string">&quot;</span><span class="string">Lafayette</span><span class="string">&quot;</span>);
+        pq2.add(<span class="string">&quot;</span><span class="string">Berlin</span><span class="string">&quot;</span>);
+        pq2.add(<span class="string">&quot;</span><span class="string">Zurich</span><span class="string">&quot;</span>);
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">----------------</span><span class="string">&quot;</span>);
+        System.<span class="ST6">out</span>.println(pq1);
+        System.<span class="ST6">out</span>.println(pq2);
+
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Attempt to remove an element.</span><span class="string">&quot;</span>);
+        pq1.remove();
+        pq2.remove();
+        System.<span class="ST6">out</span>.println(pq1);
+        System.<span class="ST6">out</span>.println(pq2);
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Get array of the priority queues.</span><span class="string">&quot;</span>);
+        Object pqArray1[] = pq1.toArray();
+        Object pqArray2[] = pq2.toArray();
+
+        <span class="ST5">printArrays</span>(pqArray1);
+        <span class="ST5">printArrays</span>(pqArray2);
+        System.<span class="ST6">out</span>.println();
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">----------------</span><span class="string">&quot;</span>);
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Test .toArray(T[])</span><span class="string">&quot;</span>);
+        String[] pqArray3 = pq1.toArray(<span class="literal">new</span> String[<span class="number">0</span>]);
+        <span class="ST5">printArrays</span>(pqArray3);
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">----------------</span><span class="string">&quot;</span>);
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Test containsAll()</span><span class="string">&quot;</span>);
+        ArrayList&lt;String&gt; testArray = <span class="literal">new</span> ArrayList&lt;&gt;();
+        testArray.add(<span class="string">&quot;</span><span class="string">Lafayette</span><span class="string">&quot;</span>);
+        testArray.add(<span class="string">&quot;</span><span class="string">Berlin</span><span class="string">&quot;</span>);
+        testArray.add(<span class="string">&quot;</span><span class="string">Zurich</span><span class="string">&quot;</span>);
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Does pq1 contain Lafayette, Berlin, and Zurich? </span><span class="string">&quot;</span> + (pq1.containsAll(testArray) ? <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>));
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Does pq1 contain the contents of pq2? </span><span class="string">&quot;</span> + (pq1.containsAll(pq2) ? <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>));
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Does pq2 contain the contents of pq1? </span><span class="string">&quot;</span> + (pq2.containsAll(pq1) ? <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>));
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Adding funkytown to testArray...</span><span class="string">&quot;</span>);
+        testArray.add(<span class="string">&quot;</span><span class="string">Funkytown</span><span class="string">&quot;</span>);
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Does pq1 contain Lafayette, Berlin, Zurich, and Funkytown? </span><span class="string">&quot;</span> + (pq1.containsAll(testArray) ? <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>));
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Test if containsAll() correctly throws a NullPointerException...</span><span class="string">&quot;</span>);
+        <span class="literal">try</span> {
+            testArray.add(<span class="literal">n</span><span class="literal">ull</span>);
+            System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Does pq1 contain Lafayette, Berlin, Zurich, Funkytown, and null? </span><span class="string">&quot;</span> + (pq1.containsAll(testArray) ? <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>));
+        } <span class="literal">catch</span> (NullPointerException ex) {
+            System.<span class="ST6">out</span>.println(ex);
+        }
+        testArray.remove(<span class="literal">n</span><span class="literal">ull</span>);
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">That worked! Continuing with tests...</span><span class="string">&quot;</span>);
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">----------------</span><span class="string">&quot;</span>);
+        System.<span class="ST6">out</span>.println(pq1);
+        System.<span class="ST6">out</span>.println(pq2);
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Testing removeAll(Collection&lt;?&gt;)...</span><span class="string">&quot;</span>);
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Removing the elements in the test array...</span><span class="string">&quot;</span>);
+        pq1.removeAll(testArray);
+        pq2.removeAll(testArray);
+        System.<span class="ST6">out</span>.println(pq1);
+        System.<span class="ST6">out</span>.println(pq2);
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">----------------</span><span class="string">&quot;</span>);
+        System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Testing retainAll()...</span><span class="string">&quot;</span>);
+        ArrayList&lt;String&gt; testArray2 = <span class="literal">new</span> ArrayList&lt;&gt;();
+        testArray2.add(<span class="string">&quot;</span><span class="string">London</span><span class="string">&quot;</span>);
+        testArray2.add(<span class="string">&quot;</span><span class="string">Paris</span><span class="string">&quot;</span>);
+        pq1.retainAll(testArray2);
+        pq2.retainAll(testArray2);
+        System.<span class="ST6">out</span>.println(pq1);
+        System.<span class="ST6">out</span>.println(pq2);
+    }
+
+    <span class="literal">static</span> <span class="literal">void</span> <span class="ST7">printArrays</span>(Object[] arr) {
+        <span class="literal">for</span> (Object element : arr) {
+            System.<span class="ST6">out</span>.print(element + <span class="string">&quot;</span><span class="string">, </span><span class="string">&quot;</span>);
+        }
+    }
+
+}
+
+</pre></body>
+</html>
--- a/3/Assignments/MP6_CalebFontenot/src/main/java/edu/slcc/asdv/caleb/mp6_calebfontenot/PriorityQueueASDV.java
+++ b/3/Assignments/MP6_CalebFontenot/src/main/java/edu/slcc/asdv/caleb/mp6_calebfontenot/PriorityQueueASDV.java
@ -8,6 +8,7 @@ package edu.slcc.asdv.caleb.mp6_calebfontenot;
 *
 * @author caleb
 */
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Iterator;
@ -201,10 +202,9 @@ public class PriorityQueueASDV<E extends Comparable<E>>
            return e;
        }
    }
+
    /**
-     * Retrieves, but does not remove, the head of this queue.  This method
-     * differs from {@link #peek peek} only in that it throws an exception
-     * if this queue is empty.
+     * Retrieves, but does not remove, the head of this queue. This method differs from {@link #peek 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
@ -217,9 +217,9 @@ public class PriorityQueueASDV<E extends Comparable<E>>
            throw new NoSuchElementException("Element does not exist.");
        }
    }
+
    /**
-     * Retrieves, but does not remove, the head of this queue,
-     * or returns {@code null} if this queue is empty.
+     * Retrieves, but does not remove, the head of this queue, or returns {@code null} if this queue is empty.
     *
     * @return the head of this queue, or {@code null} if this queue is empty
     */
@ -233,21 +233,14 @@ public class PriorityQueueASDV<E extends Comparable<E>>
        return head == null && tail == null ? true : false;

    }
+
    /**
-     * Returns {@code true} if this collection contains the specified element.
-     * More formally, returns {@code true} if and only if this collection
-     * contains at least one element {@code e} such that
-     * {@code Objects.equals(o, e)}.
+     * Returns {@code true} if this collection contains the specified element. More formally, returns {@code true} if and only if this collection contains at least one element {@code e} such that {@code Objects.equals(o, e)}.
     *
     * @param o element whose presence in this collection is to be tested
-     * @return {@code true} if this collection contains the specified
-     *         element
-     * @throws ClassCastException if the type of the specified element
-     *         is incompatible with this collection
-     *         ({@linkplain Collection##optional-restrictions optional})
-     * @throws NullPointerException if the specified element is null and this
-     *         collection does not permit null elements
-     *         ({@linkplain Collection##optional-restrictions optional})
+     * @return {@code true} if this collection contains the specified element
+     * @throws ClassCastException if the type of the specified element is incompatible with this collection ({@linkplain Collection##optional-restrictions optional})
+     * @throws NullPointerException if the specified element is null and this collection does not permit null elements ({@linkplain Collection##optional-restrictions optional})
     */
    @Override
    public boolean contains(Object o) {
@ -256,7 +249,7 @@ public class PriorityQueueASDV<E extends Comparable<E>>
            if (pointer.equals(o)) {
                return true;
            } else {
-                pointer =pointer.r;
+                pointer = pointer.r;
            }
        } while (pointer != null);
        return false;
@ -303,68 +296,56 @@ public class PriorityQueueASDV<E extends Comparable<E>>
        while (pointer.r != null) {
            returnArray[i++] = pointer.e;
            pointer = pointer.r;
-        } 
+        }
        returnArray[i++] = pointer.e;
        return returnArray;
    }
+
    /**
-     * Returns an array containing all of the elements in this collection;
-     * the runtime type of the returned array is that of the specified array.
-     * If the collection 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 collection.
+     * Returns an array containing all of the elements in this collection; the runtime type of the returned array is that of the specified array. If the collection 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 collection.
     *
-     * <p>If this collection fits in the specified array with room to spare
-     * (i.e., the array has more elements than this collection), the element
-     * in the array immediately following the end of the collection is set to
-     * {@code null}.  (This is useful in determining the length of this
-     * collection <i>only</i> if the caller knows that this collection does
-     * not contain any {@code null} elements.)
+     * <p>
+     * If this collection fits in the specified array with room to spare (i.e., the array has more elements than this collection), the element in the array immediately following the end of the collection is set to {@code null}. (This is useful in determining the length of this collection <i>only</i> if the caller knows that this collection does not contain any {@code null} elements.)
     *
-     * <p>If this collection makes any guarantees as to what order its elements
-     * are returned by its iterator, this method must return the elements in
-     * the same order.
+     * <p>
+     * If this collection makes any guarantees as to what order its elements are returned by its iterator, this method must return the elements in the same order.
     *
-     * @apiNote
-     * This method acts as a bridge between array-based and collection-based APIs.
-     * It allows an existing array to be reused under certain circumstances.
-     * Use {@link #toArray()} to create an array whose runtime type is {@code Object[]},
-     * or use {@link #toArray(IntFunction)} to control the runtime type of
-     * the array.
+     * @apiNote This method acts as a bridge between array-based and collection-based APIs. It allows an existing array to be reused under certain circumstances. Use {@link #toArray()} to create an array whose runtime type is {@code Object[]}, or use {@link #toArray(IntFunction)} to control the runtime type of the array.
     *
-     * <p>Suppose {@code x} is a collection known to contain only strings.
-     * The following code can be used to dump the collection into a previously
-     * allocated {@code String} array:
+     * <p>
+     * Suppose {@code x} is a collection known to contain only strings. The following code can be used to dump the collection into a previously allocated {@code String} array:
     *
     * <pre>
     *     String[] y = new String[SIZE];
     *     ...
     *     y = x.toArray(y);</pre>
     *
-     * <p>The return value is reassigned to the variable {@code y}, because a
-     * new array will be allocated and returned if the collection {@code x} has
-     * too many elements to fit into the existing array {@code y}.
+     * <p>
+     * The return value is reassigned to the variable {@code y}, because a new array will be allocated and returned if the collection {@code x} has too many elements to fit into the existing array {@code y}.
     *
-     * <p>Note that {@code toArray(new Object[0])} is identical in function to
-     * {@code toArray()}.
+     * <p>
+     * Note that {@code toArray(new Object[0])} is identical in function to {@code toArray()}.
     *
     * @param <T> the component type of the array to contain the collection
-     * @param a the array into which the elements of this collection are to be
-     *        stored, if it is big enough; otherwise, a new array of the same
-     *        runtime type is allocated for this purpose.
+     * @param a the array into which the elements of this collection 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 all of the elements in this collection
-     * @throws ArrayStoreException if the runtime type of any element in this
-     *         collection is not assignable to the {@linkplain Class#getComponentType
+     * @throws ArrayStoreException if the runtime type of any element in this collection is not assignable to the {@linkplain Class#getComponentType
     *         runtime component type} of the specified array
     * @throws NullPointerException if the specified array is null
     */
    @Override
    public <T> T[] toArray(T[] a) {
-        T[] genericArray = new T[this.size()];
+        a = Arrays.copyOf(a, this.size());
        Node<E> pointer = head;
+        System.out.println(a.getClass());
+        System.out.println(pointer.getClass());
+        System.out.println(pointer.e.getClass());
+
        for (int i = 0; i < this.size(); ++i) {
-            genericArray[i] = pointer;
+            a[i] = (T) pointer.e;
+            pointer = pointer.r;
        }
+        return a;
    }

    /**
@ -440,27 +421,39 @@ public class PriorityQueueASDV<E extends Comparable<E>>
        }
        return true;
    }
+
    /**
-     * Returns {@code true} if this collection contains all of the elements
-     * in the specified collection.
+     * Returns {@code 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 {@code 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
-     *         ({@linkplain Collection##optional-restrictions optional})
-     * @throws NullPointerException if the specified collection contains one
-     *         or more null elements and this collection does not permit null
-     *         elements
-     *         ({@linkplain Collection##optional-restrictions optional})
-     *         or if the specified collection is null.
-     * @see    #contains(Object)
+     * @param c collection to be checked for containment in this collection
+     * @return {@code 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 ({@linkplain Collection##optional-restrictions optional})
+     * @throws NullPointerException if the specified collection contains one or more null elements and this collection does not permit null elements ({@linkplain Collection##optional-restrictions optional}) or if the specified collection is null.
+     * @see #contains(Object)
     */
    @Override
    public boolean containsAll(Collection<?> c) {
-        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        // Java already throws a CastCastException if you give it the wrong type, so we don't have to throw that ourselves
+        if (c.contains(null) || c == null) {
+            throw new NullPointerException("The collection you passed to containsAll() contains a null element. Cannot continue.");
+        }
+        // Unpack the collection so we can compare them
+        Object[] compareArray = c.toArray();
+        Node<E> pointer = null;
+        int matchCount = 0;
+        for (Object compare : compareArray) {
+            pointer = head;
+            for (int i = 0; i < size() - 1; ++i) {
+                if (pointer.e.equals(compare)) {
+                    matchCount++;
+                }
+                pointer = pointer.r;
+            }
+        }
+        if (matchCount == compareArray.length - 1) {
+            return true;
+        }
+        return false;
    }

    /**
@ -483,14 +476,61 @@ public class PriorityQueueASDV<E extends Comparable<E>>
        return sizeAfter > sizeBefore;
    }

+    /**
+     * Removes all of this collection's elements that are also contained in the specified collection (optional operation). After this call returns, this collection will contain no elements in common with the specified collection.
+     *
+     * @implSpec This implementation iterates over this collection, checking each element returned by the iterator in turn to see if it's contained in the specified collection. If it's so contained, it's removed from this collection with the iterator's {@code remove} method.
+     *
+     * <p>
+     * Note that this implementation will throw an {@code UnsupportedOperationException} if the iterator returned by the {@code iterator} method does not implement the {@code remove} method and this collection contains one or more elements in common with the specified collection.
+     *
+     * @throws UnsupportedOperationException {@inheritDoc}
+     * @throws ClassCastException {@inheritDoc}
+     * @throws NullPointerException {@inheritDoc}
+     *
+     * @see #remove(Object)
+     * @see #contains(Object)
+     */
    @Override
    public boolean removeAll(Collection<?> c) {
-        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        if (c.contains(null) || c == null) {
+            throw new NullPointerException("The collection you passed to removeAll() contains a null element. Cannot continue.");
+        }
+        // Unpack the collection so we can remove them
+        Object[] compareArray = c.toArray();
+        Node<E> pointer = null;
+        boolean removeSuccessful = false;
+        for (Object compare : compareArray) {
+            pointer = head;
+            for (int i = 0; i < size() - 1; ++i) {
+                if (pointer.e.equals(compare)) {
+                    remove(pointer.e);
+                    removeSuccessful = true;
+                }
+                pointer = pointer.r;
+            }
+        }
+        return removeSuccessful;
    }

    @Override
    public boolean retainAll(Collection<?> c) {
-        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        if (c.contains(null) || c == null) {
+            throw new NullPointerException("The collection you passed to retainAll() contains a null element. Cannot continue.");
+        }
+        Node<E> pointer = null;
+        boolean removeSuccessful = false;
+        for (int j = 0; j < c.size() - 1; ++j) {
+            pointer = head;
+            for (int i = 0; i < size(); ++i) {
+                if (!c.contains(pointer.e)) {
+                    remove(pointer.e);
+                    removeSuccessful = true;
+                }
+                pointer = pointer.r;
+            }
+        }
+        return removeSuccessful;
    }

    @Override
@ -817,12 +857,56 @@ public class PriorityQueueASDV<E extends Comparable<E>>

        printArrays(pqArray1);
        printArrays(pqArray2);
+        System.out.println();
+        System.out.println("----------------");
+        System.out.println("Test .toArray(T[])");
+        String[] pqArray3 = pq1.toArray(new String[0]);
+        printArrays(pqArray3);
+        System.out.println("----------------");
+        System.out.println("Test containsAll()");
+        ArrayList<String> testArray = new ArrayList<>();
+        testArray.add("Lafayette");
+        testArray.add("Berlin");
+        testArray.add("Zurich");
+        System.out.println("Does pq1 contain Lafayette, Berlin, and Zurich? " + (pq1.containsAll(testArray) ? "yes" : "no"));
+        System.out.println("Does pq1 contain the contents of pq2? " + (pq1.containsAll(pq2) ? "yes" : "no"));
+        System.out.println("Does pq2 contain the contents of pq1? " + (pq2.containsAll(pq1) ? "yes" : "no"));
+        System.out.println("Adding funkytown to testArray...");
+        testArray.add("Funkytown");
+        System.out.println("Does pq1 contain Lafayette, Berlin, Zurich, and Funkytown? " + (pq1.containsAll(testArray) ? "yes" : "no"));
+        System.out.println("Test if containsAll() correctly throws a NullPointerException...");
+        try {
+            testArray.add(null);
+            System.out.println("Does pq1 contain Lafayette, Berlin, Zurich, Funkytown, and null? " + (pq1.containsAll(testArray) ? "yes" : "no"));
+        } catch (NullPointerException ex) {
+            System.out.println(ex);
+        }
+        testArray.remove(null);
+        System.out.println("That worked! Continuing with tests...");
+        System.out.println("----------------");
+        System.out.println(pq1);
+        System.out.println(pq2);
+        System.out.println("Testing removeAll(Collection<?>)...");
+        System.out.println("Removing the elements in the test array...");
+        pq1.removeAll(testArray);
+        pq2.removeAll(testArray);
+        System.out.println(pq1);
+        System.out.println(pq2);
+        System.out.println("----------------");
+        System.out.println("Testing retainAll()...");
+        ArrayList<String> testArray2 = new ArrayList<>();
+        testArray2.add("London");
+        testArray2.add("Paris");
+        pq1.retainAll(testArray2);
+        pq2.retainAll(testArray2);
+        System.out.println(pq1);
+        System.out.println(pq2);
    }

    static void printArrays(Object[] arr) {
        for (Object element : arr) {
            System.out.print(element + ", ");
        }
-        System.out.println();
    }
+
 }