Java链表优先级队列

有序链表的实现

以下是我出于某种原因编写的代码，它不会编译并要求一个主函数。我用了一个主函数来测试这个，但是我需要一个没有它的程序

package data_structures;

import java.util.Iterator;
import java.util.NoSuchElementException;

public class ListPriorityQueue<E> implements PriorityQueue<E> {

private Node head;
private int size;

private class Node {
    private E value;
    private Node next;
    public Node(E value, Node next) {
        this.value = value;
        this.next = next;
        }
    }

private class NodeIter implements Iterator<E> {
    private E[] arr;
    private int n;

    public NodeIter() {
        n = size;
        arr = (E[]) new Object[n];
        Node p = head;
        for (int i = 0; i < n; ++i) {
            arr[i] = p.value;
            p = p.next;
            }
        }
    public boolean hasNext() { 
        return n > 0; 
        }
    public E next() {
        if (n == 0) 
            throw new NoSuchElementException();
        return arr[--n];
        }
    public void remove() { 
        throw new UnsupportedOperationException(); 
        }
    }

public ListPriorityQueue() {
    this.head = null;
    this.size = 0;
    }

public boolean insert(E object) {
    if (isFull()) 
        return false;
    if (head == null) {
        head = new Node(object, null);
        } 
    else if (((Comparable<E>)object).compareTo(head.value) < 0) {
        head = new Node(object, head);
        } 
    else {
        Node p = head;
        while (p.next != null && ((Comparable<E>)object).compareTo(p.next.value) >= 0) {
            p = p.next; //or equal to preserve FIFO on equal items
            }
        p.next = new Node(object, p.next);
        }
    ++size;
    return true;
    }

public E remove() {
    if (isEmpty()) 
        return null;
    E value = head.value;
    head = head.next;
    --size;
    return value;
    }

public E peek() {
    if (isEmpty()) 
        return null;
    return head.value;
    }

public int size() {
    return size;
    }

public boolean contains(E object) {
    Node p = head;
    while (p != null) {
        if (((Comparable<E>)object).compareTo(p.value) == 0)
            return true;
        p = p.next;
        }
    return false;
    }

public Iterator<E> iterator() {
    if (isEmpty()) 
        return null;
    return new NodeIter();
    }

public void clear() {
    head = null;
    size = 0;
    }

public boolean isEmpty() {
    return size == 0;
    }

public boolean isFull() {
    return size == DEFAULT_MAX_CAPACITY;
    }
}

包数据结构；
导入java.util.Iterator；
导入java.util.NoSuchElementException；
公共类ListPriorityQueue实现PriorityQueue{
专用节点头；
私有整数大小；
私有类节点{
私人股本价值；
私有节点下一步；
公共节点（E值，节点下一个）{
这个值=值；
this.next=next；
}
}
私有类NodeIter实现迭代器{
私人E[]arr；
私人int n；
公共节点器（）{
n=尺寸；
arr=（E[]）新对象[n]；
节点p=头部；
对于（int i=0；i0；
}
公共教育{
如果（n==0）
抛出新的NoTouchElementException（）；
返回arr[--n]；
}
public void remove（）{
抛出新的UnsupportedOperationException（）；
}
}
公共列表优先级队列（）{
this.head=null；
此值为0.size=0；
}
公共布尔插入（E对象）{
如果（isFull（））
返回false；
if（head==null）{
head=新节点（对象，空）；
} 
如果（（可比较）对象）。比较到（头值）<0{
头部=新节点（对象，头部）；
} 
否则{
节点p=头部；
while（p.next！=null&（（可比）对象）。compareTo（p.next.value）>=0）{
p=p.next；//或等于，在相同项目上保留FIFO
}
p、 下一步=新节点（对象，p.next）；
}
++大小；
返回true；
}
公共E删除（）{
if（isEmpty（））
返回null；
E值=水头值；
head=head.next；
--大小；
返回值；
}
公共E peek（）{
if（isEmpty（））
返回null；
返回head.value；
}
公共整数大小（）{
返回大小；
}
公共布尔包含（E对象）{
节点p=头部；
while（p！=null）{
如果（（可比较）对象）。比较到（p.value）==0）
返回true；
p=p.next；
}
返回false；
}
公共迭代器迭代器（）{
if（isEmpty（））
返回null；
返回新的NodeIter（）；
}
公共空间清除（）{
head=null；
尺寸=0；
}
公共布尔值为空（）{
返回大小==0；
}
公共布尔值isFull（）{
返回大小==默认的最大容量；
}
}

它使用javac编译得非常好。我假设您无法将其作为控制台应用程序运行。这无法完成，因为Java控制台应用程序需要方法

publicstaticvoidmain（String[]args）

---

哦，还有一些关于未经检查的类型转换的警告

您可以将

main

放在TestListPriorityQueue.java中。谢谢您，我试图使用控制台，但最终需要使用javac运行它。