如何在Java中编写基本的双链接列表函数？

Question

我在编程类中的第一个任务是编写双链接列表的代码，其中包括编写一个add，remove，size，iterator first，iterator last和iterator find函数。我已经花了3个小时而没有理解这一点。我明白如果我能在照片中看到它会发生什么。但我的问题是将其转换为代码。这就是我到目前为止所做的：

public class DoublyLinkedList< G > {

    public class node {
        G data;
        node next;
        node prev;
        public node(G data, node next, node prev) {
            this.data = data;
            this.next = next;
            this.prev = prev;
        }
    }
    node header;
    node footer;


    public DoublyLinkedList() {
        header = new node(null, null, null);
        footer = new node(null, header, null);
        header.next = footer;
    }

    public void add(G data) {
        header.next = new node(data, footer.prev, footer);  
    }

    public int size() {
        node current = header.next;
        int quanity = 0;
        if (current == null) {
            return 0;
        }
        while (current != null) {
            current = current.next;
            quanity++;
        }
        return quanity;
    }

    public static void main(String args[]) {

        DoublyLinkedList<Integer> test = new DoublyLinkedList<Integer>();
        //test.add(new Integer(2));
        //test.add(new Integer(22));
        //test.add(new Integer(222));

            System.out.println(test.size());

    }
}

正如您所看到的，我一直在使用main（）来测试所有内容。从我老师的讲述，我的构造函数和节点类看起来很好。但是我知道我的添加和大小都不对，因为当我测试它时，当列表中没有节点时，它什么也没显示，但它应该显示0对吗？我的意思是，假设我的尺码是正确的，我不确定。

每当我添加一个节点时，无论我添加多少节点，它总是显示1.因此，无论是添加还是大小都被破坏，或者两者都是。我没有写过其他功能，因为在我把这些功能弄清楚之前它没有任何意义。请有人帮我理解这个！谢谢。

Answer 1

在size中声明DoublyLinkedList字段以存储列表的当前大小。 add成功后，请size++。 remove成功后，请size--。而size()方法只是简单地返回size。

的值

示例代码在此处：

    private int size = 0;

    public void add(G data) {
        header.next = new node(data, footer.prev, footer);
        size++;
    }
    public int size() {
        return size;
    }

Answer 2

注意到几件事：

首先，页脚构造不正确。它应该是：

public DoublyLinkedList() {
  ..
  footer = new node(null, null, header);
  // your code is incorrectly creating a circular list
  ..
  }

其次add（）方法看起来不正确。它应该是这样的：

public void add(G data) {
    Node newNode = new Node(data, header, null);  
    header.prev = newNode
    header = newNode;
}

//用于在前面添加（LIFO）

OR

public void add(G data) {
    Node newNode = new Node(data, null, footer);  
    footer.next = newNode
    footer = newNode;
}

//用于在尾部添加（FIFO）

Answer 3

查看wikipedia entry for doubly linked lists。它有一些很好的伪代码。

使用您自己的代码我将提出一些建议

public class DoublyLinkedList< G > {

    public class node {
    G data;
    node next;
    node prev;
    public node(G data) {
        this.data = data;
        this.next = null;
        this.prev = null;
    }
    }
    node header;
    node footer;


    public DoublyLinkedList() {
    header = new node(null);
    footer = new node(null);
    header.next = footer;//link the header to the footer
    footer.prev = header;//link the footer to the header
    }

    public void add(G data) { //assuming you are adding the node to the head of the list
    node newNode = new node(data); //creating new node to add with the data
    newNode.next = header.next; // setting new node to head of the list or the footer
    newNode.prev = header; //setting the new node's previous node to the header
    header.next = newNode; //setting the newNode as the next node.
    }

    public int size() {
    node current = header.next;
    int quantity = 0;
    if (current.data == null/*Empty list*/) { //you needed to specify what you were trying to test
        return 0;
    }
    while (current.data != null/*traversing the list*/) { 
        current = current.next;
        quantity++;
    }
    return quantity;
    }

    public static void main(String args[]) {

    DoublyLinkedList<Integer> test = new DoublyLinkedList<Integer>();
    //test.add(new Integer(2));
    //test.add(new Integer(22));
    //test.add(new Integer(222));

        System.out.println(test.size());

    }
}

Answer 4

你走了：

public class DoublyLinkedList {
private class Node {
    String value;
    Node next,prev;

    public Node(String val, Node n, Node p) {
        value = val;
        next = n;
        prev=p;
    }

    Node(String val) {
        this(val, null, null);
    }
}
private Node first;
private Node last;

public DoublyLinkedList() {
    first = null;
    last = null;
}
public boolean isEmpty(){
    return first==null;
}
public int size(){
    int count=0;
    Node p=first;
    while(p!=null){
        count++;
        p=p.next;
    }
    return count;
}
public void add(String e) {

    if(isEmpty()){
        last=new Node(e);
        first=last;
    }
    else{
        last.next=new Node(e, null, last);
        last=last.next;
    }
}
public void add(int index, String e){
    if(index<0||index>size()){
        String message=String.valueOf(index);
        throw new IndexOutOfBoundsException(message);
    }
    if(index==0){
        Node p=first;
        first=new Node(e,p,null);
        if(p!=null)
            p.prev=first;
        if(last==null)
            last=first;
        return;
    }
    Node pred=first;
    for(int k=1; k<=index-1;k++){
        pred=pred.next;
    }
    Node succ=pred.next;
    Node middle=new Node(e,succ,pred);
    pred.next=middle;
    if(succ==null)
        last=middle;
    else
        succ.prev=middle;
}
public String toString(){
    StringBuilder strBuilder=new StringBuilder();
    Node p=first;
    while(p!=null){
        strBuilder.append(p.value+"\n");
        p=p.next;
    }
    return strBuilder.toString();
}
public String remove(int index){
    if(index<0||index>=size()){
        String message=String.valueOf(index);
        throw new IndexOutOfBoundsException(message);
    }
    Node target=first;
    for(int k=1; k<=index;k++){
        target=target.next;
    }
    String element=target.value;
    Node pred=target.prev;
    Node succ=target.next;
    if(pred==null)
        first=succ;
    else
        pred.next=succ;
    if(succ==null)
        last=pred;
    else
        succ.prev=pred;
    return element;
}
public boolean remove(String element){
    if(isEmpty())
        return false;
    Node target=first;
    while(target!=null&&!element.equals(target.value))
        target=target.next;
    if(target==null)
        return false;
    Node pred=target.prev;
    Node succ=target.next;
    if(pred==null)
        first=succ;
    else
        pred.next=succ;
    if(succ==null)
        last=pred;
    else
        succ.prev=pred;
    return true;
}
public static void main(String[] args){
    DoublyLinkedList list1=new DoublyLinkedList();
    String[] array={"a","c","e","f"};
    for(int i=0; i<array.length; i++){
        list1.add(array[i]);
    }
    list1.add(1,"b");
    list1.add(3,"d");
    System.out.println(list1);

}


}