Insertion is clearly less work in a singly-linked list, as long as you are content to always insert at the head or after some known element. (That is, you cannot insert before a known element, but see below.) Deletion, on the other hand, is trickier because you need to know the element before the element … Read more
You can do that this way: List<Double> temp1 = new LinkedList<Double>(Arrays.asList(1.0, 2.0));
A simple example is keeping track of whose turn it is in a multi-player board game. Put all the players in a circular linked list. After a player takes his turn, advance to the next player in the list. This will cause the program to cycle indefinitely among the players. To traverse a circular linked … Read more
Wonder why it should be big challenge as it is stated here, here is a straightforward implementation in Java with out any “clever tricks”. //The main function public static Node merge_sort(Node head) { if(head == null || head.next == null) return head; Node middle = getMiddle(head); //get the middle of the list Node left_head = … Read more
It’s O(1). You can google for the source code and you will come to such: From http://www.docjar.com/html/api/java/util/LinkedList.java.html All of the Collection classes I have looked at store a the size as a variable and don’t iterate through everything to get it.
As usual the best answer to performance questions is to profile both implementations for your use case and see which is faster. In general if you have insertions into the data-structure (other than at the end) then vector may be slower, otherwise in most cases vector is expected to perform better than list if only … Read more
There are two parts to this problem: Detect if there is a loop in the list Identify the start of the loop Once you know where the loop starts, it’s easy to identify the last element in the list since it’s the element in the list following the start of the loop that ends up … Read more
At the beginning, you do pp = &list_head; and, as you traverse the list, you advance this “cursor” with pp = &(*pp)->next; This way, you always keep track of the point where “you come from” and can modify the pointer living there. So when you find the entry to be deleted, you can just do … Read more
You can return an anonymous implementation of Iterable. The effects are pretty pretty similar, just that this is a lot more verbose. public Iterable<String> getStuff() { return new Iterable<String>() { @Override public Iterator<String> iterator() { return new Iterator<String>() { @Override public boolean hasNext() { // TODO code to check next } @Override public String next() … Read more
There are multiple different ways to implement queues and stacks with linked lists and arrays, and I’m not sure which ones you’re looking for. Before analyzing any of these structures, though, let’s review some important runtime considerations for the above data structures. In a singly-linked list with just a head pointer, the cost to prepend … Read more