单链表实现

Question

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

现在，我遇到的问题是我无法正确测试它，例如，如果我将通过我的insertFirst方法插入一个节点，那么我仍将如何能够检索它以将其用于类似swapElements？

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

这是我的代码；

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);
    }

}

和

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();
            }
        }
    }

}

请注意，SinglyLinkedListImp类尚未完全完成（如果列表为空，则某些方法将给出错误）。 我认为不需要为这两个接口提供代码，但是请告诉我是否需要。

Answer 1

在实现中，您设置了一些方法（例如getNext等），可以使用这些方法来迭代集合。 我能想到的一种情况是，在一次操作中检索了列表的任何元素，然后根据该元素（例如swapElements ）对集合进行编辑。

我建议您做的事情（可能会使事情更清楚）是按索引添加元素的检索方法：方法get(int index)将返回放置在作为参数给出的索引上的元素。 实际上，Java中的LinkedList集合标准API就有这种方法。 其背后的逻辑很简单：获取下一个节点，直到迭代周期号达到索引号为止。

更新：为了进行元素交换，显然涉及的Node MUST是列表的一部分，否则就没有意义了。 还建议，swapElements可能基本上用于类内目的，因此，除非有充分的理由，否则请将其声明为private。