通过链表中的索引删除元素

Question

A method for removing an element from a linked list has been implemented:

public void remove(T e) {
 
    Node<T> node = first;
    Node<T> prevNode = null;
    while(node != null){
        if(e.equals(node)){
            if(prevNode  == null) {
                first = node.next;
            }
            else {
                prevNode.next = node.next;
            }
            size--;
        }
        else {
            prevNode = node;
        }
        node = node.next;
    }
}

How to correctly implement deleting an element by index? Using the capabilities of the remove method.

public void removeByIndex(int i) {
    remove(i);
}

Answer 1

remove(get(i));

This is not the most efficient solution, but a simple one which uses the remove(T) method. You call it with get(i) as the object to be removed - which is the element at the specified index.

Note: This solution has some issues if the list has duplicate values, but in that case you shouldn't use the remove(T) method anyway. If you want it to be safe, iterate to the specified index:

    Node<T> node = first;       
    for(int i=0;i<index;i++){
        prevNode=node;
        node=node.next;
    }

and do this:

node.prev.next=node.next;
node.next.prev=node.prev;
size--;

Of course, this is just a rough implementation. To ensure full compability, you should check if the index is valid and use the unlink(Node) method of LinkedList.

The LinkedList also has an implementation for the remove(int) method:

checkElementIndex(index);
return unlink(node(index));

Answer 2

Something like this should work:

public void remove(int i) {
    if (i >= size || i < 0) {
        throw new ArrayIndexOutOfBoundsException();
    }
    Node<T> remove;
    if (i == 0) {
        remove = first;
        first = first.next;
        first.prev = null; // <- For double linked list
    } else {
        Node<T> node = first;
        for (int j = 0; j < i - 1; ++j) {
            node = node.next;
        }
        remove = node.next;
        if (i == size - 1) {
            node.next = null;
        } else {
            node.next.next.prev = node; // <- For double linked list
            node.next = node.next.next;
        }
    }
    // Clear links from removed Node
    remove.next = null;
    remove.prev = null; // <- For double linked list
    size--;
}

Find the node before position i. Point that node to the "over next" node.

Edit The original code example was a rough sketch at best. Updated with a more complete version.

Edit #2

Slight improvements:

• Clears links from the removed node
• Also handles double linked lists