// Path: src/main/java/io/github/marioluan/datastructures/Node.java
// public class Node<T extends Comparable<T>> implements Comparable<Node<T>> {
// 
//     /**
//      * The value of the node.
//      */
//     public T data;
// 
//     /**
//      * A link to the next node.
//      */
//     public Node<T> next;
// 
//     /**
//      * A link to the previous node.
//      */
//     public Node<T> prev;
// 
//     /**
//      * Construct a new node with the given data.
//      * 
//      * @param data
//      */
//     public Node(T data) {
//         this.data = data;
//     }
// 
//     /**
//      * {@inheritDoc}
//      */
//     @Override
//     public int compareTo(Node<T> that) {
//         return this.data.compareTo(that.data);
//     }
// 
//     /**
//      * Checks whether there is a link to next node.
//      * 
//      * @return whether the next field is not null
//      */
//     public boolean hasNext() {
//         return this.next != null;
//     }
// 
//     /**
//      * Checks whether there is a link to previous node.
//      * 
//      * @return whether the prev field is not null
//      */
//     public boolean hasPrev() {
//         return this.prev != null;
//     }
// 
// }
// 
// Path: src/main/java/io/github/marioluan/datastructures/Util.java
// public final class Util {
// 
//     private Util() {
//     }
// 
//     /**
//      * Check whether {@link Comparable a} is lesser than {@link Comparable b}.
//      *
//      * @param a
//      * @param b
//      * @return returns whether a is lesser than b
//      */
//     @SuppressWarnings({ "rawtypes", "unchecked" })
//     public static boolean less(Comparable a, Comparable b) {
//         return a.compareTo(b) < 0;
//     }
// 
//     /**
//      * Check whether {@link a} is lesser than {@link b}.
//      * 
//      * @param <T>
//      * @param a
//      * @param b
//      * @return returns whether a is lesser than b
//      */
//     @SuppressWarnings("unchecked")
//     public static <T> boolean less(T a, T b) {
//         return ((Comparable<T>) a).compareTo(b) < 0;
//     }
// 
//     /**
//      * Check whether {@link Comparable a} is lesser or equal to
//      * {@link Comparable b}.
//      *
//      * @param a
//      * @param b
//      * @return returns whether a is lesser or equal to b
//      */
//     @SuppressWarnings({ "rawtypes", "unchecked" })
//     public static boolean lessOrEqual(Comparable a, Comparable b) {
//         return a.compareTo(b) < 1;
//     }
// 
//     /**
//      * Swap item in position i by item in position j from array {@link a}.
//      *
//      * @param a
//      * @param i
//      * @param j
//      */
//     @SuppressWarnings("rawtypes")
//     public static void swap(Comparable[] a, int i, int j) {
//         Comparable copy = a[i];
//         a[i] = a[j];
//         a[j] = copy;
//     }
// 
//     /**
//      * Swap item in position i by item in position j from array {@link a}.
//      * 
//      * @param <T>
//      * @param a
//      * @param i
//      * @param j
//      */
//     public static <T> void swap(T[] a, int i, int j) {
//         T copy = a[i];
//         a[i] = a[j];
//         a[j] = copy;
//     }
// 
//     /**
//      * Find and return the index from the minimum item from array a within
//      * lowerBound and upperBound.
//      * 
//      * @param a
//      * @param lowerBound
//      * @param upperBound
//      * @return returns the index from the element with the minimum value
//      */
//     @SuppressWarnings("rawtypes")
//     public static int findMin(Comparable[] a, int lowerBound, int upperBound) {
//         int min = lowerBound;
//         for (int i = lowerBound + 1; i < upperBound; i++)
//             if (less(a[i], a[min]))
//                 min = i;
// 
//         return min;
//     }
// 
//     /**
//      * Make a copy of items from array a within lo and hi bounds into array aux.
//      *
//      * @param a
//      * @param aux
//      * @param lo
//      * @param hi
//      */
//     @SuppressWarnings("rawtypes")
//     public static void copy(Comparable[] a, Comparable[] aux, int lo, int hi) {
//         for (int i = lo; i <= hi; i++)
//             aux[i] = a[i];
//     }
// 
//     /**
//      * Make a copy of items from array a within lo and hi bounds into array aux.
//      * 
//      * @param <T>
//      * @param a
//      * @param aux
//      * @param lo
//      * @param hi
//      */
//     public static <T> void copy(T[] a, T[] aux, int lo, int hi) {
//         for (int i = lo; i <= hi; i++)
//             aux[i] = a[i];
//     }
// }


import java.util.Iterator;
import java.util.NoSuchElementException;
import io.github.marioluan.datastructures.Node;
import io.github.marioluan.datastructures.Util;
package io.github.marioluan.datastructures.priority.queue;



/**
 * Priority Queue implementation using an ordered linked list data type.
 * 
 * @author marioluan
 * @param <T>
 *            the class type of elements to be handled.
 */
public class MinOrderedLinkedListPriorityQueue<T extends Comparable<T>>
        implements Iterable<T> {

// Path: src/main/java/io/github/marioluan/datastructures/Node.java
// public class Node<T extends Comparable<T>> implements Comparable<Node<T>> {
// 
//     /**
//      * The value of the node.
//      */
//     public T data;
// 
//     /**
//      * A link to the next node.
//      */
//     public Node<T> next;
// 
//     /**
//      * A link to the previous node.
//      */
//     public Node<T> prev;
// 
//     /**
//      * Construct a new node with the given data.
//      * 
//      * @param data
//      */
//     public Node(T data) {
//         this.data = data;
//     }
// 
//     /**
//      * {@inheritDoc}
//      */
//     @Override
//     public int compareTo(Node<T> that) {
//         return this.data.compareTo(that.data);
//     }
// 
//     /**
//      * Checks whether there is a link to next node.
//      * 
//      * @return whether the next field is not null
//      */
//     public boolean hasNext() {
//         return this.next != null;
//     }
// 
//     /**
//      * Checks whether there is a link to previous node.
//      * 
//      * @return whether the prev field is not null
//      */
//     public boolean hasPrev() {
//         return this.prev != null;
//     }
// 
// }
// 
// Path: src/main/java/io/github/marioluan/datastructures/Util.java
// public final class Util {
// 
//     private Util() {
//     }
// 
//     /**
//      * Check whether {@link Comparable a} is lesser than {@link Comparable b}.
//      *
//      * @param a
//      * @param b
//      * @return returns whether a is lesser than b
//      */
//     @SuppressWarnings({ "rawtypes", "unchecked" })
//     public static boolean less(Comparable a, Comparable b) {
//         return a.compareTo(b) < 0;
//     }
// 
//     /**
//      * Check whether {@link a} is lesser than {@link b}.
//      * 
//      * @param <T>
//      * @param a
//      * @param b
//      * @return returns whether a is lesser than b
//      */
//     @SuppressWarnings("unchecked")
//     public static <T> boolean less(T a, T b) {
//         return ((Comparable<T>) a).compareTo(b) < 0;
//     }
// 
//     /**
//      * Check whether {@link Comparable a} is lesser or equal to
//      * {@link Comparable b}.
//      *
//      * @param a
//      * @param b
//      * @return returns whether a is lesser or equal to b
//      */
//     @SuppressWarnings({ "rawtypes", "unchecked" })
//     public static boolean lessOrEqual(Comparable a, Comparable b) {
//         return a.compareTo(b) < 1;
//     }
// 
//     /**
//      * Swap item in position i by item in position j from array {@link a}.
//      *
//      * @param a
//      * @param i
//      * @param j
//      */
//     @SuppressWarnings("rawtypes")
//     public static void swap(Comparable[] a, int i, int j) {
//         Comparable copy = a[i];
//         a[i] = a[j];
//         a[j] = copy;
//     }
// 
//     /**
//      * Swap item in position i by item in position j from array {@link a}.
//      * 
//      * @param <T>
//      * @param a
//      * @param i
//      * @param j
//      */
//     public static <T> void swap(T[] a, int i, int j) {
//         T copy = a[i];
//         a[i] = a[j];
//         a[j] = copy;
//     }
// 
//     /**
//      * Find and return the index from the minimum item from array a within
//      * lowerBound and upperBound.
//      * 
//      * @param a
//      * @param lowerBound
//      * @param upperBound
//      * @return returns the index from the element with the minimum value
//      */
//     @SuppressWarnings("rawtypes")
//     public static int findMin(Comparable[] a, int lowerBound, int upperBound) {
//         int min = lowerBound;
//         for (int i = lowerBound + 1; i < upperBound; i++)
//             if (less(a[i], a[min]))
//                 min = i;
// 
//         return min;
//     }
// 
//     /**
//      * Make a copy of items from array a within lo and hi bounds into array aux.
//      *
//      * @param a
//      * @param aux
//      * @param lo
//      * @param hi
//      */
//     @SuppressWarnings("rawtypes")
//     public static void copy(Comparable[] a, Comparable[] aux, int lo, int hi) {
//         for (int i = lo; i <= hi; i++)
//             aux[i] = a[i];
//     }
// 
//     /**
//      * Make a copy of items from array a within lo and hi bounds into array aux.
//      * 
//      * @param <T>
//      * @param a
//      * @param aux
//      * @param lo
//      * @param hi
//      */
//     public static <T> void copy(T[] a, T[] aux, int lo, int hi) {
//         for (int i = lo; i <= hi; i++)
//             aux[i] = a[i];
//     }
// }


// Path: src/main/java/io/github/marioluan/datastructures/priority/queue/MinOrderedLinkedListPriorityQueue.java
import java.util.Iterator;
import java.util.NoSuchElementException;
import io.github.marioluan.datastructures.Node;
import io.github.marioluan.datastructures.Util;

package io.github.marioluan.datastructures.priority.queue;



/**
 * Priority Queue implementation using an ordered linked list data type.
 * 
 * @author marioluan
 * @param <T>
 *            the class type of elements to be handled.
 */
public class MinOrderedLinkedListPriorityQueue<T extends Comparable<T>>
        implements Iterable<T> {

    private Node<T> head;