Java 单链表的实现

好的，我正试图通过我的教科书（Goodrich&Tamassia，Algorithm Design，2001）实现一个（单独的）链表，到目前为止还不错

现在，我遇到的问题是，我无法正确地测试它，例如，如果我要通过insertFirst方法插入一个节点，我如何仍然能够检索它，以便能够将其用于Swaplements之类的方法

我曾考虑过通过元素工作，但是当我有具有相同元素的节点时，我会遇到问题。那么，一般来说，这应该如何工作？如果我的问题相对简单或模糊，我很抱歉，在这种情况下，请让我知道如何改进它，因为我对数据结构相当陌生

这是我的密码

public class Node<E> implements Position<E> {

    private Node<E> next;
    private E element;

    public Node(Node<E> next, E element) {
        this.next = next;
        this.element = element;
    }

    public Node(E element) {
        this.element = element;
    }

    public void setNext(Node<E> next) {
        this.next = next;
    }

    public Node<E> getNext() {
        return next;
    }

    public void setElement(E element) {
        this.element = element;
    }

    public E element() {
        return element;
    }

    public String toString() {
        return ("Element: " + element);
    }

}

公共类节点实现位置{
私有节点下一步；
私人电子元件；
公共节点（下一个节点，E元素）{
this.next=next；
this.element=元素；
}
公共节点（E元素）{
this.element=元素；
}
公共void setNext（节点next）{
this.next=next；
}
公共节点getNext（）{
下一步返回；
}
公共无效集合元素（E元素）{
this.element=元素；
}
公共E元素（）{
返回元素；
}
公共字符串toString（）{
返回（“元素：”+元素）；
}
}

及

公共类SingleLinkedListImplements列表{
专用节点头；
私有整数大小；
公共单链接列表（）{
this.head=null；
此值为0.size=0；
}
公共节点优先（）{
回流头；
}
公共节点last（）{
节点电流=头；
while（current.getNext（）！=null）{
current=current.getNext（）；
}
回流；
}
公共布尔值isFirst（节点n）{
返回（头==n）；
}
公共布尔isLast（节点n）{
返回（n.getNext（）==null）；
}
之前的公共节点（节点n）{
节点电流=头；
while（current.getNext（）！=n）{
current=current.getNext（）；
}
回流；
}
之后的公共节点（节点n）{
返回n.getNext（）；
}
公共节点替换元素（节点n、E元素）{
节点电流=头；
Node-previous=null；
while（当前！=n）{
先前=当前；
current=current.getNext（）；
}
Node newLink=新节点（current.getNext（），元素）；
previous.setNext（newLink）；
回流；
}
公共空隙交换（节点n、节点k）{
E tmp=n.元素（）；
n、 setElement（k.element（））；
k、 setElement（tmp）；
}
公共void insertFirst（E元素）{
head=新节点（head，元素）；
大小++；
}
公共void insertLast（E元素）{
if（head==null）{
head=新节点（head，元素）；
}否则{
节点电流=头；
while（current.getNext（）！=null）{
current=current.getNext（）；
}
current.setNext（新节点（null，元素））；
}
大小++；
}
公共void insertBefore（节点n，E元素）{
节点电流=头；
Node-previous=null；
while（current.getNext（）！=n）{
先前=当前；
current=current.getNext（）；
}
上一个。设置下一个（n）；
}
公共void insertAfter（节点n，E元素）{
节点电流=头；
while（当前！=n）{
current=current.getNext（）；
}
当前设置下一个（n）；
}
公共无效删除（节点n）{
节点电流=头；
Node-previous=null；
while（当前！=n）{
先前=当前；
current=current.getNext（）；
}
previous.setNext（current.getNext（））；
大小--；
}
公共整数大小（）{
返回大小；
}
公共布尔值为空（）{
返回（大小==0）；
}
公共空间显示（）{
if（head==null）{
System.out.println（“空列表”）；
}否则{
节点电流=头；
while（当前！=null）{
System.out.println（current.toString（））；
current=current.getNext（）；
}
}
}
}

请注意，SinglyLinkedListImp类尚未完全完成（如果列表为空，则某些方法将给出错误）。

---

我认为不需要为这两个接口提供代码，但如果需要，请告诉我。

在您的实现中，您已经设置了一些方法（如

getNext

等），可以用于迭代集合。我能想到的一个场景是，在一次操作中检索列表的任何元素，然后根据元素（如

swaplements

）对集合应用编辑

不过，我建议您（并且可能会澄清）添加一个按索引检索元素的方法： 方法

get（int-index）

将返回作为参数放置在索引上的元素。事实上，Java中的集合标准API有这样一种方法。这背后的逻辑很简单：获取下一个节点，直到迭代周期数达到索引数

---

更新：为了应用元素交换，显然所涉及的

节点必须是列表的一部分，否则没有意义。正如所建议的，Swaplements可能基本上用于类内目的，因此除非您有充分的理由，否则将其声明为私有。
节点
不应暴露在列表类之外，类似于
Swaplements
的方法应为
私有
。用于
insertOrdered
或诸如此类的内部。如果我理解你的意思，你是说我应该基于元素而不是节点？我的问题是，当我的列表中有两个节点具有相同的元素时。但是也许
public class SinglyLinkedListImp<E> implements List<E> {

    private Node<E> head;
    private int size;

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

    public Node<E> first() {
        return head;
    }

    public Node<E> last() {
        Node<E> current = head;
        while (current.getNext() != null) {
            current = current.getNext();
        }
        return current;
    }

    public boolean isFirst(Node<E> n) {
        return (head == n);
    }

    public boolean isLast(Node<E> n) {
        return (n.getNext() == null);
    }

    public Node<E> before(Node<E> n) {
        Node<E> current = head;
        while (current.getNext() != n) {
            current = current.getNext();
        }
        return current;
    }

    public Node<E> after(Node<E> n) {
        return n.getNext();
    }

    public Node<E> replaceElements(Node<E> n, E element) {
        Node<E> current = head;
        Node<E> previous = null;
        while (current != n) {
            previous = current;
            current = current.getNext();
        }
        Node<E> newLink = new Node<E>(current.getNext(), element);
        previous.setNext(newLink);
        return current;
    }

    public void swapElements(Node<E> n, Node<E> k) {
        E tmp = n.element();
        n.setElement(k.element());
        k.setElement(tmp);
    }

    public void insertFirst(E element) {
        head = new Node<E>(head, element);
        size++;
    }

    public void insertLast(E element) {
        if (head == null) {
            head = new Node<E>(head, element);
        } else {
            Node<E> current = head;
            while (current.getNext() != null) {
                current = current.getNext();
            }
            current.setNext(new Node<E>(null, element));
        }
        size++;
    }

    public void insertBefore(Node<E> n, E element) {
        Node<E> current = head;
        Node<E> previous = null;
        while (current.getNext() != n) {
            previous = current;
            current = current.getNext();
        }
        previous.setNext(n);
    }

    public void insertAfter(Node<E> n, E element) {
        Node<E> current = head;
        while (current != n) {
            current = current.getNext();
        }
        current.setNext(n);
    }

    public void remove(Node<E> n) {
        Node<E> current = head;
        Node<E> previous = null;
        while (current != n) {
            previous = current;
            current = current.getNext();
        }
        previous.setNext(current.getNext());
        size--;
    }

    public int size() {
        return size;
    }

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

    public void display() {
        if (head == null) {
            System.out.println("Empty list.");
        } else {
            Node<E> current = head;
            while (current != null) {
                System.out.println(current.toString());
                current = current.getNext();
            }
        }
    }

}