Concatenate two java.util.LinkedList in constant time

Question

I\'m working on some piece of code, which is quite hot, and I need to add elements of one LinkedList (l1) to another LinkedList (

Answer 1

It seems like required feature is not supported by the standard library. However, you can use reflection to achieve constant time when merging linked lists. I haven't tested the following code properly, just to show how it could be achieved:

public class ListConcatenation {

public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, ClassNotFoundException {
    LinkedList<String> list1 = new LinkedList<>();
    list1.add("a");
    list1.add("b");
    list1.add("c");

    LinkedList<String> list2 = new LinkedList<>();
    list2.add("d");
    list2.add("e");
    list2.add("f");

    System.out.println(merge(list1, list2));
}

public static List<String> merge(List<String> list1, List<String> list2) throws NoSuchFieldException, IllegalAccessException, ClassNotFoundException {
    Field first = getDeclaredField(LinkedList.class, "first");
    Field last = getDeclaredField(LinkedList.class, "last");
    Field size = getDeclaredField(LinkedList.class, "size");

    Class<?> nodeClass = Class.forName("java.util.LinkedList$Node");
    Field next = nodeClass.getDeclaredField("next");
    next.setAccessible(true);

    Object list1Last = last.get(list1);
    Object list2First = first.get(list2);
    Object list2Last = last.get(list2);

    // link the last element of list1 with the first element of list2
    next.set(list1Last, list2First);
    // set last element of list1 equal to the last element of list2
    last.set(list1, list2Last);
    // update list1 size
    size.set(list1, list1.size() + list2.size());

    return list1;
}

private static Field getDeclaredField(Class<?> clazz, String name) throws NoSuchFieldException {
    Field field = clazz.getDeclaredField(name);
    field.setAccessible(true);
    return field;
}

}

Answer 2

According to the comments, the goal is to create something like a "view" on the concatenated list - meaning that the data should not be copied. Instead, the given lists should "appear" like a single list.

One way of how this could be implemented is to extend AbstractList. The implementation of get(int) and size() are fairly trivial. The crucial point is to create an Iterator for the concatenated list. The following is a very simple sketch of how this could be accomplished (but see the notes below)

import java.util.AbstractList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class MergedListTest
{
    public static void main(String[] args)
    {
        testBasic();
        testEmptyA();
        testEmptyB();
    }

    private static void testBasic()
    {
        List<Integer> list0 = Arrays.asList(0,1,2);
        List<Integer> list1 = Arrays.asList(3,4,5);
        List<Integer> expected = Arrays.asList(0,1,2,3,4,5);
        List<Integer> actual = new MergedList<Integer>(list0, list1);
        System.out.println(actual.equals(expected));
    }

    private static void testEmptyA()
    {
        List<Integer> list0 = Collections.emptyList();
        List<Integer> list1 = Arrays.asList(3,4,5);
        List<Integer> expected = Arrays.asList(3,4,5);
        List<Integer> actual = new MergedList<Integer>(list0, list1);
        System.out.println(actual.equals(expected));
    }

    private static void testEmptyB()
    {
        List<Integer> list0 = Arrays.asList(0,1,2);
        List<Integer> list1 = Collections.emptyList();
        List<Integer> expected = Arrays.asList(0,1,2);
        List<Integer> actual = new MergedList<Integer>(list0, list1);
        System.out.println(actual.equals(expected));
    }

}


class MergedList<T> extends AbstractList<T>
{
    private final List<T> list0;
    private final List<T> list1;

    MergedList(List<T> list0, List<T> list1)
    {
        this.list0 = list0;
        this.list1 = list1;
    }

    @Override
    public T get(int index)
    {
        if (index < list0.size())
        {
            return list0.get(index);
        }
        return list1.get(index - list0.size());
    }

    @Override
    public Iterator<T> iterator()
    {
        return new Iterator<T>() 
        {
            private Iterator<T> current = list0.iterator();
            private boolean first = true;

            @Override
            public boolean hasNext() 
            {
                return current != null && current.hasNext();
            }

            @Override
            public T next() 
            {
                T result = current.next();
                if (!current.hasNext())
                {
                    if (first)
                    {
                        current = list1.iterator();
                    }
                    else
                    {
                        current = null;
                    }
                }
                return result;
            }
        };
    }

    @Override
    public int size()
    {
        return list0.size() + list1.size();
    }
}

Conceptually, it would make more sense to inherit from AbstractSequentialList: The AbstractList offers stub implementations, e.g. of iterator(), that eventually delegate to get(int), whereas AbstractSequentialList offers the "opposite" stub implementations, e.g. of get(int) that eventually delegate to iterator(). However, this requires a ListIterator<T> implementation, which is a bit more fiddly than the trivial sketch above.

Also note that I assumed that the resulting view should be unmodifiable - but this should be in line with the given description.

And finally, note that there are (of course) already implementations for this and similar tasks, and these implementations may be far more sophisticated than the one sketched above. For example, Google Guava offers different Iterators#concat methods that allow you to concatenate multiple iterators. So if you are already using Guava, the implementation of the iterator() method above could boil down to

@Override
public Iterator<T> iterator()
{
    return Iterators.concat(list0.iterator(), list1.iterator());
}

Answer 3

No. You cannot add two java.util.LinkedLists to output another one in constant time O(1).

Conceptually, you can indeed add two Linked List data structures together in constant time O(1) but they'll need to be implemented in the right way. As you mention, the implementation should combine the two lists by joining the node of the last to the node of the first and does not iterate over either list.