使用嵌套在另一个类中的类重写CompareTo方法，该类扩展了可比较

Question

我的任务是在Java中编写我自己的PriorityQueue类。它基于LinkedList。引用说明：

存储在节点中的数据类型应该是可比较的通用类型。这是为类声明编写的：public class PriorityQueue（E）-

我将使用PriorityQueue来编写另外两个类，一个是患者类型的，另一个是waitingRoom类型的。这就是比较方法发挥作用的地方，因为我将这两个类排序为它们各自的PriorityQueue。

我一直在PriorityQueue类内部定义ListNode类，所以我在一个类中有一个类。现在问题来了：

我将在哪里实现/重写从Comparable继承的compareTo方法？

它无法在PriorityQueue类中实现，因为compareTo只能接受一个参数。然而，这似乎是它应该去的地方，因为这是实际的类。

如果我在ListNode类中实现它，我不知道该如何实现。我要把ListNode变成一个接口吗？抽象课堂？

下面是我写的相当新手的代码谢谢帮助

    package hostpitalQueue;

import java.util.AbstractList;

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

    private ListNode front;

    public PriorityQueue() {
        front = null;
    }
    public PriorityQueue(ListNode n1) {
        front = n1;
    }



    //method for addingNode to beginning, 
    //perhaps overload method for next nodes?
    public void addNode(ListNode n1) {

        if(front == null) {
            front = n1;
        }else {
                //need to find last node and add n1 to it
                ListNode lastNode = findLastNode(n1);
                lastNode.addNode(n1);
            }
    }



    //need to compare, remember, this is a priorityqueue
    public ListNode findLastNode(ListNode n) {
        //compare the data of both
        //compare to front

        ListNode n1 = front;
        int i = n1.compareTo(n);
        //only do something here if n is higher priority
        if(i > 0) {
            E frontData = n1.data;
            E nodesData = n.data;
            ListNode holder = n1;
            front = n;
            n.next = holder;
            holder.previous = n;
        }else if(n1.next == null) {
            n1.next = n;
            n.previous = n1;
        }
        else {

            while(front.next != null) {
                n1 = front.next;
                //is n1 a higher priority?
                Integer ii = n1.compareTo(n);
                if(ii > 0) {
                    //this means that we should return the previous node, to insert
                    //before this one
                    return n1.previous;
                }
            }
        }
        return n1;
    }


    public class ListNode  {
        //contains a left and a right, as well as a data field
        public E data;
        public ListNode previous,next;


        //construct
        public ListNode() {
            data = null;
            previous = null;
            next = null;
        }

        //previous to next
        public ListNode(E data) {
            this.data = data;
            previous = null;
            next = null;
        }

        public ListNode(E data,ListNode n1) {
            this.data = data;
            previous = n1;
            next = null;
        }

        public ListNode(E data,ListNode n1,ListNode n2) {
            this.data = data;
            previous = n1;
            next = n2;
        }

        public void addNode(ListNode n1) {
            //gotta check if my next is null
            ListNode holder = null;
            if(this.next != null) {
                holder = this.next;
            }
            this.next = n1;
            n1.previous = this;
            n1.next = holder;
        }
        public int compareTo(ListNode n1) {
            return 0;
        }

        public void printMe() {
            System.out.println(this.data);
        }

    }







}

Answer 1

如果要比较两个ListNodes，如第行所示：

n1.compareTo(n)

您需要使其实现可比性：

public class ListNode implements Comparable<ListNode> {

并实现compareTo方法，如下所示：

return this.data.compareTo(that.data);

（因为您知道数据是可比的）。但您必须处理空数据的情况。

请注意，您还应该将顶级类上的类型变量声明为：

<E extends Comparable<? super E>>

Answer 2

将用作PriorityQueue元素类型的每个类都必须实现Comparable接口和compareTo方法。

请注意，由于您的ListNode类实现了compareTo方法，您可以让它实现Comparable

public class ListNode implements Comparable<ListNode>  {

...

    @Override
    public int compareTo(ListNode n1) {
        return data.compareTo(n1.data);
    }

请注意，由于ListNodeclasse不依赖于PriorityQueue的实例，因此可以将其设置为static；在这种情况下，您必须声明一个通用参数：

public static class ListNode<T extends Comparable<T>>
        implements Comparable<ListNode<T>>  {
    //contains a left and a right, as well as a data field
    public T data;
    public ListNode<T> previous,next;


    //construct
    public ListNode() {
        data = null;
        previous = null;
        next = null;
    }

    //previous to next
    public ListNode(T data) {
        this.data = data;
        previous = null;
        next = null;
    }

    public ListNode(T data,ListNode<T> n1) {
        this.data = data;
        previous = n1;
        next = null;
    }

    public ListNode(T data,ListNode<T> n1,ListNode<T> n2) {
        this.data = data;
        previous = n1;
        next = n2;
    }

    public void addNode(ListNode<T> n1) {
        //gotta check if my next is null
        ListNode<T> holder = null;
        if(this.next != null) {
            holder = this.next;
        }
        this.next = n1;
        n1.previous = this;
        n1.next = holder;
    }

    @Override
    public int compareTo(ListNode<T> n1) {
        return data.compareTo(n1.data);
    }

    public void printMe() {
        System.out.println(this.data);
    }
}

类ListNode有字段，所以不能将其更改为接口（为什么要这么做？）

你或许应该问问自己，你是否真的需要一个双链接列表，而单链接列表是不够的。

您的问题中不清楚您是否需要实现一个链表，或者您是否可以使用类LinkedList，在这种情况下，您不需要ListNode类：PriorityQueue只会封装一个LinkedList