Question

我的一个朋友希望我将他的代码转换为双重链接列表，尽管我根本不熟悉它。我已经查找了双重链接列表，但我不知道他的代码如何处理它。我不是大师级程序员。你有什么建议吗？

import java.util.Collection;

import java.util.List;


class SinglyLinkedList<E> implements List<E> {



private class SinglyLinkedListNode<T> {



    T data;

    SinglyLinkedListNode<T> next;



    public SinglyLinkedListNode() {

        this(null, null);

    }



    public SinglyLinkedListNode(T data) {

        this(data, null);

    }



    public SinglyLinkedListNode(T d, SinglyLinkedListNode<T> n) {

        data = d;

        next = n;

    }



    public boolean equals(Object o) {

        if (data != null && o != null) {

            return data.equals(((SinglyLinkedListNode) o).data);

        } else {

            return (data == null && o == null);

        }

    }

}

private SinglyLinkedListNode<E> list, last;

private int size;



public SinglyLinkedList() {

    clear();

}



public void clear() {

    list = last = null;

    size = 0;

}



public boolean contains(Object o) {

    SinglyLinkedListNode<E> t = list;

    while (t != null) {

        if (t.data == null) {

            if (o == null) {

                return true;

            }

        } else if (t.data.equals(o)) {

            return true;

        }

        t = t.next;

    }

    return false;

}



public boolean add(E e) {

    SinglyLinkedListNode<E> n = new SinglyLinkedListNode<E>(e);

    if (isEmpty()) {

        list = last = n;

    } else {

        last = last.next = n;

    }

    size++;

    return true;

}



public void add(int index, E e) {

    int currSize = size();

    if (index < 0 || index > currSize) {

        throw new IndexOutOfBoundsException(

                "Index: " + index + ", Size: " + size());

    }

    if (isEmpty()) // index must == 0

    {

        list = last = new SinglyLinkedListNode<E>(e);

    } else {

        if (index == 0) {

            list = new SinglyLinkedListNode<E>(e, list);

        } else {

            SinglyLinkedListNode<E> n = list;

            for (int i = 0; i < index - 1; i++) {

                n = n.next;

            }

            n.next = new SinglyLinkedListNode<E>(e, n.next);

            if (index == currSize) {

                last = n.next;

            }

        }

    }

    size++;

}



public boolean equals(SinglyLinkedList<E> e) {


   SinglyLinkedListNode<E> e1 = list, e2 = e.list;

    try {

        for (int i = 1; i <= size(); i++) {

            if (!e1.equals(e2)) {

                return false;

            }

            e1 = e1.next;

            e2 = e2.next;

        }

    } catch (NullPointerException ex) {

        return false;

    }

    return true;

}



public E get(int index) {

    if (index < 0 || index >= size()) {

        throw new IndexOutOfBoundsException(

                "Index: " + index + ", Size: " + size());

    }

    SinglyLinkedListNode<E> n = list;

    int i = 0;

    for (; i < index; i++) {

        n = n.next;

    }

    return n.data;

}



@SuppressWarnings("unchecked")

public int indexOf(Object o) {

    SinglyLinkedListNode<E> n = list;

    int i = 0;

    while (n != null) {

        if ((o == null

                ? (n.data == null)

                : (((E) o).equals(n.data)))) {

            return i;

        }

        n = n.next;

        i++;

    }

    return -1;

}



public boolean isEmpty() {

    return list == null;

}



public E remove(int index) {

    if (index < 0 || index >= size()) {

        throw new IndexOutOfBoundsException(

                "Index: " + index + ", Size: " + size());

    }

    SinglyLinkedListNode<E> n = list, prevNode = null;

    int i = 0;

    while (true) {

        if (index == i) {

            if (n == list) // removing first node

            {

                list = list.next;

            } else {

                prevNode.next = n.next;

            }

            if (n == last) {

                last = prevNode;

            }

            size--;

            return n.data;

        }

        prevNode = n;

        n = n.next;

        i++;

    }

}



@SuppressWarnings("unchecked")

public boolean remove(Object o) {

    SinglyLinkedListNode<E> n = list, prevNode = null;

    while (n != null) {

        if ((o == null

                ? (n.data == null)

                : (((E) o).equals(n.data)))) {

            if (n == list) //removing first node

            {

                list = list.next;

            } else {

                prevNode.next = n.next;

            }

            if (n == last) {

                last = prevNode;

            }

            size--;

            return true;

        }

        prevNode = n;

        n = n.next;

    }

    return false;

}



public int size() {

    return size;

}



public String toString() {

    String s = "((";

    SinglyLinkedListNode<E> t = list;

    if (t != null) {

        while (t.next != null) {

            s += t.data + ", ";

            t = t.next;

        }

        s += last.data;

    }

    return s + "))";

}

Answer 1

我不明白这个问题。如果这是家庭作业，你应该这样说 - 社区规则！无论如何快速解释：

链表是具有以下内容的结构，......好吧，结构：

DATA                      |--> DATA
REFERENCE TO NEXT ITEM ---|    REFERENCE TO NEXT ITEM ---...

“链”中的每个“链接”都包含一些数据，以及一种定位链中下一个项目的方法。正如你所说，这是一个单独链接的列表。

双向链表是一种非常相似的结构，只有链中的每个链接都包含一种定位下一项的方法，以及一种定位前一项的方法。如果您需要能够以两种方式遍历列表，那么您将需要这种结构。

|-> DATA                      |--> DATA
|   REFERENCE TO NEXT ITEM ---|    REFERENCE TO NEXT ITEM ---...
---------------------------------- REFERENCE TO PREV ITEM

Ooookay的“图纸”很可怕。您可以通过Google查询查找双重链接列表的内容，并在第二次考虑时获得更好的信息，但很好。

Answer 2

在SO上查看at this other question。它应该可以帮助您更好地理解双向链表。

Answer 3

每个节点都需要next和previous占位符才能成为双向链接列表。

Answer 4

Java中的

LinkedList是一个双向链表。你为什么要自己创造一个？

Answer 5

听起来像是家庭作业。这将帮助您入门。

http://en.wikipedia.org/wiki/Doubly_linked_list

基本上，在单个链表中，每个节点都有一个指向下一个节点的指针。在双向链表中，有指向下一个和前一个的指针。请注意指针在列表的开头和结尾处的工作方式。

单链表到双向链表

5 个答案: