Question

我的问题在于我的主要方法，如何将多个节点添加到链接列表....我现在拥有的第一个节点，node2，node3 ..我以为是添加了这些节点，但我意识到我没有＆＃39;我认为我实际上正在对这些节点及其值进行任何操作，对吗？如何使用setData（）和setNext（）添加所有这些节点。那有意义吗？

ListNode<String> node4 = new ListNode<String>("Fourth", null);
ListNode<String> node3 = new ListNode<String>("Third", node4);
ListNode<String> node2 = new ListNode<String>("Second", node3);
ListNode<String> first = new ListNode<String>("First", node2);

如果以上设置值，我该如何添加它们？

那么我是否需要为每一个设置数据和下一个？（这似乎是多余的，因为我似乎在设置每个节点数据的值，然后在上面的构造函数中设置？）

first.setData("first");
first.setNext(node2); 
node2.setData("Second");
node2.setNext(node2);
//.....

我尝试添加上述所有节点，以便通过添加新节点来测试我的addLast（）方法。但是，当我在main中调用我的addLast（）方法时，你可以看到下面打印的唯一的东西就是我添加的addLast（）值（如果我调用addFirst（）则首先）。

测试类

public class LinkedListDriver
{

    public static void main(String[] args) {
        //List<String> list = new LinkedList<String>();                   //comment out this line to test your code
        SinglyLinkedList<String> list = new SinglyLinkedList<String>(); //remove comment to test your code

        ListNode<String> node4 = new ListNode<String>("Fourth", null);
        ListNode<String> node3 = new ListNode<String>("Third", node4);
        ListNode<String> node2 = new ListNode<String>("Second", node3);
        ListNode<String> first = new ListNode<String>("First", node2);

        ListNode value = new ListNode("First", new ListNode("Second", new ListNode("Third", null)));

        //I've been messing around with this but 
        list.addFirst(first.getData());
        list.addFirst("Second");

        list.addLast("Fifth");
        list.printList();
    }
}

我没有添加其他两个课程，因为我认为它不相关，但如果你想看到它让我知道。我很新，这只是我的第二堂课，而且是在网上而且构造很差的课程，请好好的大声笑

SinglyLinkedList类

//This class implements a very simple singly-linked list of Objects
public class SinglyLinkedList<E>
{
    ListNode<E> first; // first element

    public SinglyLinkedList() {
        first = null;
    }

    public E getFirst() {
        if (first == null) {
            throw new NoSuchElementException();
        } else
            return first.getData();
    }

    public void addFirst(E value) {
        first = new ListNode<E>(value, first);
    }

    // Methods below implemented by you. Note: while writing methods, keep in mind
    // that you might be able to call other methods in this class to help you - you
    // don't always need to start from scratch(but you'll have to recognize when)

    public void addLast(E value) {
        ListNode<E> temp = first;
        //If list is empty make new node the first node.
        if (temp == null) {
            first = new ListNode <E>(value, null);
            first.setNext(null);
        }//Otherwise loop to end of list and add new node.
        else {
            while (temp.getNext() != null) {
                temp = temp.getNext();
            }
            temp.setNext(new ListNode<E>(value, null));
        }
    }//end addLast

    // throws an exception - you decide when and which one

    public E getLast() {
        ListNode<E> temp = first;
        if (temp == null) {
            throw new NullPointerException("There are no elements in this list to get.");
        } else {
            while (temp.getNext() != null) {
                temp = temp.getNext();
            }
            return temp.getData();
        }
    }

    // throws an exception - you decide when and which one

    public E removeFirst() {
        if (first == null) {
            throw new NullPointerException("There are no elements in this list to remove.");
        }
        ListNode<E> tempRemove = first;
        return null; //just so it'll compile
    }

    // throws an exception - you decide when and which one

    public E removeLast() {
        return null; //just so it'll compile
    }

    // return the number of elements in the list

    public int size() {
        return 0; //just so it'll compile
    }

    // return true if o is in this list, otherwise false

    public boolean contains(E obj) {
        return true; //just so it'll compile
    }

    public void printList(java.io.PrintStream out) {
        if (first == null) {
            System.out.println("The list is empty");
        }
        ListNode<E> current = first;
        while (current != null) {
            System.out.println(current.toString());
            current = current.getNext();
        }
    }

    public String toString() {
        String s = "[";
        ListNode<E> current = first;
        //write code to traverse the list, adding each object on its own line
        while (current.getNext() != null) {
            current = current.getNext();
        }

        s += "]";
        return s;
    }

    // OPTIONAL: just for fun...and a challenge

    public void reverse() {
    }
}

ListNode类是你的基本getNext setNext，getData setData ....

Answer 1

有几点，主要是总结评论：

您根本不应该使用ListNode中的main()个对象 - 这应该是SinglyLinkedList类的工作。 ListNode甚至不需要对其余代码可见，它可以是SinglyLinkedList中的嵌套类。您应该只使用SinglyLinkedList交换数据对象（在本例中为字符串）。

如果你想测试addLast()方法，你可以从一个空列表开始，然后反复调用list.addLast()，正如Shane在他的回答中提到的那样。这样，当列表为空以及非空时，您将确保它有效。

SinglyLinkedList<String> list = new SinglyLinkedList<String>();
list.addLast("first");
list.addLast("second");
list.addLast("third");
list.printList(System.out);

至于在单个调用中添加多个节点 - 此链接列表没有相应的方法。例如，您可以添加一个方法来添加数组的所有元素，但您可以按顺序调用addLast()，效果相同。如果要从一些基础数据开始测试其他方法，可以在主类中创建一些辅助方法以这种方式填充列表。

作为旁注：如果printList()以java.io.PrintStream out作为参数，则应使用它而不是System.out。那是

out.println(...)

而不是

System.out.println(...)

此外，最好抛出NoSuchElementException而不是NullPointerException作为所请求元素不存在的指示。

如果您想要一种方便的方法来填充列表，您可以在主类中使用这样的内容：

static <E> void addToList(SinglyLinkedList<E> list, E... values) {
    for (E value : values) {
        list.addLast(value);
    }
}

并像这样使用它：

SinglyLinkedList<String> list = new SinglyLinkedList<String>();
addToList(list, "first", "second", "third");

Answer 2

你想做什么？如果您正在尝试填充链接列表，那么您需要做的就是不断调用list.addLast，它将获取一个参数（您要添加的新节点中的数据），并处理创建新节点和将它放在列表的后面。

我假设您不需要在main中创建任何节点，因为它们通常完全由linkedlist类处理。

Java LinkedList添加多个节点

2 个答案: