Java优先级队列扩展可比吗？

Question

我正在进行课堂作业，我不太明白如何在作业要求的方式中使用比较器。

作业如下：

“完成Priority Queue类

1. 您的优先级队列必须使用匿名函数来确定优先级
2. 它必须将Function接口作为构造函数的参数
3. 你仍然应该有默认的构造函数 - 如果没有提供函数，请使用类的compareTo函数“

这是我正在上课的班级......

public class PriorityQueue <Item extends Comparable<Item>> {

    public PriorityQueue()
    {

    }
    public PriorityQueue(Comparator<Item> compare )
    {

    }  

    private int size = 0;
    private Node<Item> head = null;
    private Comparator<Item> compare ;

    private static class Node<Item>
    {
       private Item data;
       private Node<Item> next;


    public Node(Item data, Node<Item> next)
       {
          this.data = data;
          this.next = next;
       }       
       public Node(Item data)
       {
          this.data = data;
          this.next = null;
       }       
       public Node()
       {
          this.data = null;
          this.next = null;
       }
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public Item dequeue() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public void enqueue(Item item) {
        Node<Item> curr = head;
        Node<Item> prev = curr;

        if (isEmpty())
        {
            head = new Node<Item>(item,null);
        }
        else
        {
            while (curr != null)
            {
                prev = curr;
                curr = curr.next;
            }

            prev.next = new Node<Item>(item, curr);
        }
        size++;
    }

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

    @Override
    public void printQueue() {
        Node<Item> curr = head;

        while (curr != null)
        {
            System.out.println(curr.data);
            curr = curr.next;
        }

    }
}

这是队列将包含的进程类...

public class Process implements Comparable<Process> {

    private ProcessPriorty priority;
        private String name;

    public Process(ProcessPriorty priority, String name) {
        super();
        this.priority = priority;
        this.name = name;
    }

    public void setPriority(ProcessPriorty priority) {
        this.priority = priority;
    }

    @Override
    public String toString() {
        return name + "... Priority = " + priority + ".";
    }

    public String getName() {
        return name;
    }

    public ProcessPriorty getPriority() {
        return priority;
    }

    @Override
    public int compareTo(Process other) {

        if(other == null)
        {
            return  1;
        }
        return this.priority.compareTo(other.priority) ;
    }
}

我理解队列的概念，甚至将enqueue方法编码为一个简单的队列，在项目进入时插入这些项目。我遇到的问题是比较该方法中的节点，以便在插入时按优先级对列表进行排序。我认为这与转让的这三个方向有关。那么，我想用构造函数，Comparator变量做什么，以及如何使它默认为compareTo？

Answer 1

好吧，因为你有一个队列头部的引用，从那里很简单。你有2个案例 -

1. compare != null
2. compare == null 在第一种情况下，您对Comparator::compareTo感兴趣。根据优先级队列的定义，您所要做的就是从头部开始遍历队列，并且一旦item中的enqueue(Item item)大于遍历中的当前element，就会在item之前插入element。你将使用compare.compareTo(item, element)来确定他们的订单。 在第二种情况下，您只需使用item.compareTo(element)进行上述比较，遍历和插入将是相同的。