Removing a node from a doubly linked list?

Question

Here's the linked list code

public class LList
{
protected int size;
protected DNode tail, header; 

public LList()
{
    size = 0;
    tail = null;
    header = tail;
}

public void addDNode(DNode v) 
{
    // means list is empty, so add first element
    if (header == null) 
    {    
        header = v;
        tail = header;  // first element so (head == tail)
    } 
    else 
    {
        tail.setNext(v);
        v.setPrev(tail);
        v.setNext(null);
        tail = v;
    }
    size++;
}

and the remove node method that's the problem

public DNode removeDnode(DNode current)
{
    if(current.nextNode() ==  null)
    {
        DNode previous = current.prevNode();
        previous.setNext(null);
        current.setPrev(null);
    }
    else if (current.prevNode() == null)
    {
        DNode next = current.nextNode();
        next.setPrev(null);
        current.setNext(null);
    }
    else
    {
        DNode next = current.nextNode();
        DNode previous = current.prevNode();
        previous.setNext(next);
        next.setPrev(previous);
        current.setPrev(null);
        current.setNext(null);
    }
    size = size - 1;
    return current;
}

The problem is that when I use previous.setNext(null); it won't let me add a node again which I think it has something to do with the header and tail.

however when i use previous.setNext(tail); it doesn't seem to remove it from the list??

Answer 1

Aren't you forgetting to point the tail of the list to the previous element when you remove the last?

if(current.nextNode() ==  null) {
    DNode previous = current.prevNode();
    previous.setNext(null);
    current.setPrev(null);
    tail = previous; //isn't this missing?!
}

Answer 2

Problem is, if you remove tail , you must move it. So try

    DNode previous = current.prevNode();
    previous.setNext(null);
    current.setPrev(null);
    tail = previous;

You have the same problem with the next —but I believe once you're done with tail , you'll fix it easily.

Answer 3

Handling remove from a doubly-linked list is VERY tricky. When you see a bug while testing, don't just make a "quick fix" -- go back and understand precisely why it didn't work, and understand how your intended fix will modify all behaviors, not simply the one that's currently misbehaving.

If you think about it carefully you can make it work with a minimum of problems. If you don't think carefully you'll be chasing your tail for hours.