如何实现DoublyLinkedList的findNode与toString方法？

需求说明 #

需要完善DoublyLinkedList类中的两个方法：

• findNode(E e)：返回包含元素e的Node实例，若链表为空则返回null
• toString()：重写父类方法，实现链表内容的打印

原代码 #

public class DoublyLinkedList<E> {

    public static class Node<E> {
        private E element; // reference to the element stored at

        private Node<E> prev; // reference to the previous node in the

        private Node<E> next; // reference to the subsequent node in

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

        public E getElement() {
            return element;
        }

        public Node<E> getPrev() {
            return prev;
        }

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

        public void setPrev(Node<E> p) {
            prev = p;
        }

        public void setNext(Node<E> n) {
            next = n;
        }
    } //----------- end of nested Node class -----------

    // instance variables of the DoublyLinkedList
    private Node<E> header; // header sentinel
    private Node<E> trailer; // trailer sentinel
    private int size = 0; // number of elements in the list

    public DoublyLinkedList() {
        header = new Node<>(null, null, null); // create header
        trailer = new Node<>(null, header, null); // trailer is preceded by

        header.setNext(trailer); // header is followed by

    }
    // public accessor methods

    public int size() {
        return size;
    }

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

    public void addLast(E e) {
        addBetween(e, trailer.getPrev(), trailer); // place just before the

    }
    // public update methods

    public void addBetween(E e, Node<E> predecessor, Node<E> successor) {
        // create and link a new node
        Node<E> newest = new Node<>(e, predecessor, successor);
        predecessor.setNext(newest);
        successor.setPrev(newest);
        size++;

    }

    public Node<E> findNode(E e) {
        E element = e;
        if (isEmpty()) {
            return null;
        }
        int node = 0;
        Node<E> temp = header;
        while (temp != null) {
            if (temp.getNext() == element) {
                return node;
            }
            node++;
            temp = temp.getNext();
        }
    }

    public String toString() {
        ArrayList<E> ref = new ArrayList<>();
        int counter = 1;

        return ref.toString();
    }
}

修正后的代码 #

import java.util.ArrayList;

public class DoublyLinkedList<E> {

    public static class Node<E> {
        private E element;
        private Node<E> prev;
        private Node<E> next;

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

        public E getElement() {
            return element;
        }

        public Node<E> getPrev() {
            return prev;
        }

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

        public void setPrev(Node<E> p) {
            prev = p;
        }

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

    private Node<E> header;
    private Node<E> trailer;
    private int size = 0;

    public DoublyLinkedList() {
        header = new Node<>(null, null, null);
        trailer = new Node<>(null, header, null);
        header.setNext(trailer);
    }

    public int size() {
        return size;
    }

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

    public void addLast(E e) {
        addBetween(e, trailer.getPrev(), trailer);
    }

    public void addBetween(E e, Node<E> predecessor, Node<E> successor) {
        Node<E> newest = new Node<>(e, predecessor, successor);
        predecessor.setNext(newest);
        successor.setPrev(newest);
        size++;
    }

    public Node<E> findNode(E e) {
        if (isEmpty()) {
            return null;
        }
        // 跳过header哨兵，从第一个实际元素开始遍历
        Node<E> current = header.getNext();
        // 遍历到trailer哨兵前结束
        while (current != trailer) {
            // 用equals比较元素，处理null避免空指针
            if (e == null ? current.getElement() == null : e.equals(current.getElement())) {
                return current;
            }
            current = current.getNext();
        }
        // 遍历完未找到匹配元素
        return null;
    }

    @Override
    public String toString() {
        ArrayList<E> elements = new ArrayList<>();
        Node<E> current = header.getNext();
        while (current != trailer) {
            elements.add(current.getElement());
            current = current.getNext();
        }
        return elements.toString();
    }
}

方法修改说明 #

1. findNode(E e) 修正点

• 修复原代码返回类型不匹配问题：原代码试图返回int，但方法声明返回Node<E>
• 调整遍历逻辑：跳过header和trailer哨兵节点，只遍历实际存储的元素
• 修正元素比较逻辑：使用equals方法比较元素内容（处理null场景），而非直接比较引用

2. toString() 修正点

• 添加@Override注解明确重写父类方法
• 补充元素遍历逻辑：将链表中所有实际元素添加到ArrayList中
• 返回ArrayList的字符串表示，实现链表内容的直观打印

内容的提问来源于stack exchange，提问作者bolokbee