给定指针，从LinkedList集合中删除一个元素

Question

I have a LinkedList of objects, and a pointer to an object of the LinkedList which I want to delete.

There is a method remove(object o) , which can be used to do delete an object, but as the documentation describes, it checks for all the elements one by one, and chooses the one object, which is the same semantically.

But this method doesn't fit my requirements.

Since I have a pointer to the object I want to delete, I should be able to delete it in O(1) time, since the LinkedList is a doubly linked list. Is there any other way to do so without implementing my own LinkedList class?

Answer 1

You cannot delete an object from a LinkedList in O(1) if all you have is a reference to the object itself.

You can delete an object if you keep a ListIterator<E> object positioned at the item that you would like to remove by calling remove() on the iterator, but it does not help much, because your iterator would get invalidated the moment the list is modified.

Here is an example of how to keep the removal O(1). Search remains O(n), though:

List<String> list = new LinkedList<>();
list.add("hello");
list.add("world");
list.add("one");
list.add("two");
list.add("three");
System.out.println(Arrays.toString(list.toArray()));
ListIterator<String> iter = list.listIterator();
String s;
while ((s = iter.next()) != null && !s.equals("world"))
    ;
// When it is time to delete
iter.remove();
System.out.println(Arrays.toString(list.toArray()));

Because of the ConcurrentModificationException , writing your own implementation of LinkedList<E> and keeping a reference to the node for future deletion remains your best option with pure linked lists.

Your other option is using LinkedHashSet<E> , which offers predictable enumeration order and O(1) deletions in exchange for using more memory.

Answer 2

How about:

public void remove(Car searchedFor) {
  for (Iterator<Car> it = list.iterator(); it.hasNext(); ) {
    Car c = it.next;
      if (c == searchedFor) {
        it.remove();
      }
    }
  }

Answer 3

A good solution to my problem was using both List and HashSet together. Since we're using a HashSet we can't work with duplicates.

Insertion: Insert in both List and HashSet . O(1) time.
Deletion: Delete from HashSet , if exists. O(1) time.
Traversal: Traverse the List . Access only if the HashSet contains that object.

Note that I'm not trying to replicate the working of a LinkedList here. I'm just sharing what worked for me.