Singly linked list to doubly linked list

A friend of mine wants me to convert his code into a doubly linked list, though I'm not familiar with it at all. I've looked up doubly linked lists but I can't tell by his code what to do with it. I'm not a master programmer. Do you have any suggestions?

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;

        }

       开发者_JAVA技巧 s += last.data;

    }

    return s + "))";

}

---

I don't understand the problem. If this is homework, you should say so -- community rules! A quick explanation, regardless:

A linked list is a structure with the following,... well, structure:

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

Each "link" in the "chain" contains some data, and a way to locate the next item in the chain. That's a singly linked list, as you said.

A doubly linked list is a very similar structure, only each link in the chain contains both a way of locating the next item, and a way of locating the previous item. If you need to be able to walk the list both ways, you'll need this kind of structure.

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

Ooookay the "drawings" are hideous. You can look up what a doubly linked list is with a Google query and get better information, on second thought, but oh well.

---

Each node needs a next as well as a previous placeholder for it to be a doubly linked list.

---

LinkedList in Java is a doubly-linked list. Why would you want to create one by yourself?

---

sounds like homework. This will get you started.

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

basically, in a singly linked list each node has a pointer to the next node. In a doubly linked list there are pointers to both next and previous. Beware how the pointers work at the beginning and the end of the list.