I&#39;ve always been one to simply use:

    List&lt;String&gt; names = new ArrayList&lt;&gt;();

I use the interface as the type name for _portability_, so that when I ask questions such as this, I can rework my code.  
  
When should [`LinkedList`][1] be used over [`ArrayList`][2] and vice-versa?


  [1]: https://docs.oracle.com/javase/9/docs/api/java/util/LinkedList.html
  [2]: https://docs.oracle.com/javase/9/docs/api/java/util/ArrayList.html

When to use LinkedList over ArrayList in Java?

Say you have a linked list structure in Java.  It&#39;s made up of Nodes:

    class Node {
        Node next;
        // some user data
    }

and each Node points to the next node, except for the last Node, which has null for next.  Say there is a possibility that the list can contain a loop - i.e. the final Node, instead of having a null, has a reference to one of the nodes in the list which came before it.

What&#39;s the best way of writing

    boolean hasLoop(Node first)

which would return `true` if the given Node is the first of a list with a loop, and `false` otherwise?  How could you write so that it takes a constant amount of space and a reasonable amount of time?

Here&#39;s a picture of what a list with a loop looks like:


![alt text][1]

  [1]: http://i.stack.imgur.com/irw1S.jpg


How to detect a loop in a linked list?

When is it better to use a [List](https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.list-1) vs a [LinkedList](https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.linkedlist-1)?


When should I use a List vs a LinkedList

Is it a linked list, an array?  I searched around and only found people guessing.  My C knowledge isn&#39;t good enough to look at the source code.

How is Python&#39;s List Implemented?

I use a lot of lists and arrays but I have yet to come across a scenario in which the array list couldn&#39;t be used just as easily as, if not easier than, the linked list.  I was hoping someone could give me some examples of when the linked list is notably better.

When to use a linked list over an array/array list?

I am trying to to understand **why Java&#39;s ArrayDeque is better than Java&#39;s LinkedList** as they both implement Deque interface. 

I hardly see someone using ArrayDeque in their code. If someone sheds more light into how ArrayDeque is implemented, it would be helpful. 

If I understand it, I will be more confident using it. I could not clearly understand the JDK implementation as to the way it manages head and tail references.

Why is ArrayDeque better than LinkedList

Why would someone want to use a linked-list over an array?

Coding a linked-list is, no doubt, a bit more work than using an array and one may wonder what would justify the additional effort.

I think insertion of new elements is trivial in a linked-list but it&#39;s a major chore in an array. Are there other advantages to using a linked list to store a set of data versus storing it in an array?

This question is not a duplicate of [this question][1] because the other question is asking specifically about a particular Java class while this question is concerned with the general data structures. 


  [1]: https://stackoverflow.com/questions/322715/when-to-use-linkedlist-over-arraylist

Array versus linked-list

I understand that Tortoise and Hare&#39;s meeting concludes the existence of a loop, but how does moving tortoise to the beginning of linked list while keeping the hare at the meeting place, followed by moving both one step at a time make them meet at the starting point of the cycle?

How does finding a cycle start node in a cycle linked list work?

Why does the reverse function for the `std::list` class in the C++ standard library have linear runtime? I would think that for doubly-linked lists the reverse function should have been O(1).  

Reversing a doubly-linked list should just involve switching the head and the tail pointers.


Why does std::list::reverse have O(n) complexity?

What&#39;s the easiest way to use a linked list in python? In scheme, a linked list is defined simply by `&#39;(1 2 3 4 5)`. Python&#39;s lists, `[1, 2, 3, 4, 5]`, and tuples, `(1, 2, 3, 4, 5)`, are not, in fact, linked lists, and linked lists have some nice properties such as constant-time concatenation, and being able to reference separate parts of them. Make them immutable and they are really easy to work with!

Python Linked List

According to the [Wikipedia article on linked lists][1], inserting in the middle of a linked list is considered O(1).  I would think it would be O(n).  Wouldn&#39;t you need to locate the node which could be near the end of the list?  

Does this analysis not account for the finding of the node operation (though it is required) and just the insertion itself?

**EDIT**: 

&gt; Linked lists have several advantages over arrays. Insertion of an element at a specific point of a list is a constant-time operation, whereas insertion in an array may require moving half of the elements, or more.

The above statement is a little misleading to me.  Correct me if I&#39;m wrong, but I think the conclusion should be:

**Arrays:** 

 - Finding the point of insertion/deletion O(1)
 - Performing the insertion/deletion O(n)

**Linked Lists:**

 - Finding the point of insertion/deletion O(n)
 - Performing the insertion/deletion O(1)

I think the only time you wouldn&#39;t have to find the position is if you kept some sort of pointer to it (as with the head and the tail in some cases).  So we can&#39;t flatly say that linked lists always beat arrays for insert/delete options.

  [1]: http://en.wikipedia.org/wiki/Linked_list#Linked_lists_vs._arrays

Why is inserting in the middle of a linked list O(1)?

What&#39;s the best way to make a linked list in Java?

How do I create a Linked List Data Structure in Java?

Most times I see people try to use linked lists, it seems to me like a poor (or very poor) choice. Perhaps it would be useful to explore the circumstances under which a linked list is or is not a good choice of data structure.

Ideally, answers would expound on the criteria to use in selecting a data structure, and which data structures are likely to work best under specified circumstances.

Edit: I must say, I&#39;m quite impressed by not only the number, but the quality of answers. I can only accept one, but there are two or three more I&#39;d have to say would have been worth accepting if something a bit better hadn&#39;t been there. Only a couple (especially the one I ended up accepting) pointed to situations where a linked list provided a real advantage. I do think Steve Jessop deserves some sort of honorable mention for coming up with not just one, but three different answers, all of which I found quite impressive. Of course, even though it was posted only as a comment, not an answer, I think Neil&#39;s blog entry is well worth reading as well -- not only informative, but quite entertaining as well.

Under what circumstances are linked lists useful?

I&#39;ve worked with linked lists before extensively in Java, but I&#39;m very new to C++. I was using this node class that was given to me in a project just fine

    class Node
    {
      public:
       Node(int data);
    
       int m_data;
       Node *m_next;
    };

but I had one question that wasn&#39;t answered very well. Why is it necessary to use

    Node *m_next;

to point to the next node in the list instead of
    
    Node m_next;

I understand that it is better to use the pointer version; I&#39;m not going to argue facts, but I don&#39;t know why it&#39;s better. I got a not so clear answer about how the pointer is better for memory allocation, and I was wondering if anyone here could help me understand that better.

Why do linked lists use pointers instead of storing nodes inside of nodes

I wonder if there exists some logic to reverse a singly-linked list using only two pointers.

The following is used to reverse the single linked list using three pointers namely `p`, `q`, `r`:

    struct node {
        int data;
        struct node *link;
    };

    void reverse() {
        struct node *p = first,
                    *q = NULL,
                    *r;

        while (p != NULL) {
            r = q;
            q = p;
            p = p-&gt;link;
            q-&gt;link = r;
        }
        first = q;
    }

Is there any other alternate to reverse the linked list?  What would be the best logic to reverse a singly linked list, in terms of time complexity?


How to reverse a singly linked list using only two pointers?

This question may be old, but I couldn&#39;t think of an answer.

Say, there are two lists of different lengths, **merging at a point**; how do we know where the merging point is?

Conditions:

1. We don&#39;t know the length 
2. We should parse each list only once.

![Example of two merged linked lists.][1]


  [1]: http://i.stack.imgur.com/xjn0S.png

Check if two linked lists merge. If so, where?

I have been working on a Java project for a class for a while now. It is an implementation of a linked list (here called `AddressList`, containing simple nodes called `ListNode`). The catch is that everything would have to be done with recursive algorithms. I was able to do everything fine sans one method: `public AddressList reverse()`    

ListNode:  

    public class ListNode{
      public String data;
      public ListNode next;
    }

Right now my `reverse` function just calls a helper function that takes an argument to allow recursion.

    public AddressList reverse(){
      return new AddressList(this.reverse(this.head));
    }

With my helper function having the signature of `private ListNode reverse(ListNode current)`.

At the moment, I have it working iteratively using a stack, but this is not what the specification requires. I had found an algorithm in C that recursively reversed and converted it to Java code by hand, and it worked, but I had no understanding of it.

Edit: Nevermind, I figured it out in the meantime.
    
    private AddressList reverse(ListNode current, AddressList reversedList){
      if(current == null) 
          return reversedList;
      reversedList.addToFront(current.getData());
      return this.reverse(current.getNext(), reversedList);
    }

While I&#39;m here, does anyone see any problems with this route?


Reversing a linked list in Java, recursively

I&#39;m curious if O(n log n) is the best a linked list can do.

What&#39;s the fastest algorithm for sorting a linked list?

What is the reason why we cannot always use a HashMap, even though it is much more efficient than ArrayList or LinkedList in add,remove operations, also irrespective of the number of the elements.

I googled it and found some reasons, but there was always a workaround for using HashMap, with advantages still alive.


When to use HashMap over LinkedList or ArrayList and vice-versa

In the following [blog][1] there is a statement about the advantage of arrays over linked lists:

&gt;Arrays have better cache locality that can make a pretty big difference in performance.

What does that mean? I don&#39;t understand how cache locality can provide a huge performance benefit.

  [1]: http://www.geeksforgeeks.org/archives/10245

Why does cache locality matter for array performance?

I&#39;m building a symbol table for a project I&#39;m working on. I was wondering what peoples opinions are on the advantages and disadvantages of the various methods available for storing and creating a symbol table.

I&#39;ve done a fair bit of searching and the most commonly recommended are binary trees or linked lists or hash tables. What are the advantages and or disadvantages of all of the above? (working in c++)

Binary Trees vs. Linked Lists vs. Hash Tables

I am trying to create a linked list just to see if I can, and I am having trouble getting my head around it.  Does anyone have an example of a very simple implementation of Linked list using C#?  All the examples I have found so far are quite overdone. 

Creating a very simple linked list

I had a look at [question][1] already which talk about algorithm to find loop in a linked list. I have read [Floyd&#39;s cycle-finding algorithm][2] solution, mentioned at lot of places that we have to take two pointers. One pointer( slower/tortoise ) is increased by one and other pointer( faster/hare ) is increased by 2. When they are equal we find the loop and if faster pointer reaches null there is no loop in the linked list.

Now my question is why we increase faster pointer by 2. Why not something else? Increasing by 2 is necessary or we can increase it by X to get the result. Is it necessary that we will find a loop if we increment faster pointer by 2 or there can be the case where we need to increment by 3 or 5 or x.


  [1]: https://stackoverflow.com/questions/2663115/interview-question-how-to-detect-a-loop-in-a-linked-list
  [2]: http://en.wikipedia.org/wiki/Cycle_detection#Tortoise_and_hare

Why increase pointer by two while finding loop in linked list, why not 3,4,5?

The two code examples below both add a node at the top of a linked list.
But whereas the first code example uses a double pointer the second code example uses a single pointer

**code example 1:**
  

    struct node* push(struct node **head, int data)
    {
            struct node* newnode = malloc(sizeof(struct node));
            newnode-&gt;data = data;
            newnode-&gt;next = *head;
            return newnode;
    }

    push(&amp;head,1);


**code example 2:**


    struct node* push(struct node *head, int data)
    {
            struct node* newnode = malloc(sizeof(struct node));
            newnode-&gt;data = data;
            newnode-&gt;next = head;
            return newnode;
    }

    push(head,1)


Both strategies work. However, a lot of programs that use a linked list use a double pointer to add a new node. I know what a double pointer is. But if a single pointer would be sufficient to add a new node why do a lot of implementations rely on double pointers?

Is there any case in which a single pointer does not work so we need to go for a double pointer?

What is the reason for using a double pointer when adding a node in a linked list?

I want to have a look at how Java implements LinkedList. Where should I go to look at the source code?

Where can I see the source code of the Sun JDK?

How can I detect that whether a singly linked-list has loop or not??
 If it has loop then how to find the point of origination of the loop i.e. the node from which the loop has started. 

Finding loop in a singly linked-list

I&#39;ve created a linked list in java using generics, and now I want to be able to iterate over all the elements in the list. In C# I would use `yield return` inside the linked list while going over the list of elements contained in the list.

How would I go about creating a java version of the above where I can iterate over all the items contained in the linked list?

I&#39;m looking to be able to write code ala

    LinkedList&lt;something&gt; authors = new LinkedList&lt;something&gt;();
    for (Iterator&lt;something&gt; i = authors.Values ; i.HasNext())
          doSomethingWith(i.Value);

And was thinking that the Value &#39;property&#39;/method would consist of code resembling

    LinkedListObject&lt;something&gt; current = first;
    While (current != null){
     yield return current.getValue();
     current = current.getNext()
    }

Edit: Notice that I&#39;m not interested in using any 3rd party APIs. Built-in java functionality only.

Yield Return In Java

The following function is trying to find the `nth` to **last** element of a singly linked list.

For example: 

If the elements are `8-&gt;10-&gt;5-&gt;7-&gt;2-&gt;1-&gt;5-&gt;4-&gt;10-&gt;10` then the result is 
`7th` to last node is `7`.

Can anybody help me on how this code is working or is there a better and simpler approach?

    LinkedListNode nthToLast(LinkedListNode head, int n) {
      if (head == null || n &lt; 1) {
        return null;
      }
      
      LinkedListNode p1 = head;
      LinkedListNode p2 = head;
      
      for (int j = 0; j &lt; n - 1; ++j) { // skip n-1 steps ahead
        if (p2 == null) {
          return null; // not found since list size &lt; n
        }
        p2 = p2.next;
      }
      
      while (p2.next != null) {
        p1 = p1.next;
        p2 = p2.next;
      }

      return p1;
    }

How to find nth element from the end of a singly linked list?

I was following a [previous post][1] on this that says:

&gt; For LinkedList
&gt; 
&gt;    * get is O(n)
&gt;    * add is O(1)
&gt;    * remove is O(n)
&gt;    * Iterator.remove is O(1)
&gt; 
&gt; For ArrayList
&gt; 
&gt;    * get is O(1)
&gt;    * add is O(1) amortized, but O(n) worst-case since the array must be resized and copied
&gt;    * remove is O(n)

So by looking at this, I concluded that if I&#39;ve to do just sequential insert in my collection for say 5000000 elements, `LinkedList` will outclass `ArrayList`.

And if I&#39;ve to just fetch the elements from collection by iterating i.e. not grabbing the element in middle, still `LinkedList` will outclass `ArrayList. 

Now to verify my above two statements, I wrote below sample program… But I&#39;m surprised that my above statements were proven wrong.

`ArrayList` outclassed `Linkedlist` in both the cases. It took less time than `LinkedList` for adding as well as fetching them from Collection. Is there anything I&#39;m doing wrong, or the initial statements about `LinkedList` and `ArrayList` does not hold true for collections of size 5000000?

I mentioned size, because if I reduce the number of elements to 50000, `LinkedList` performs better and initial statements hold true.

    long nano1 = System.nanoTime();

    List&lt;Integer&gt; arr = new ArrayList();
    for(int i = 0; i &lt; 5000000; ++i) {
        arr.add(i);
    }
    System.out.println( (System.nanoTime() - nano1) );

    for(int j : arr) {
        ;
    }
    System.out.println( (System.nanoTime() - nano1) );

    long nano2 = System.nanoTime();

    List&lt;Integer&gt; arrL = new LinkedList();
    for(int i = 0; i &lt; 5000000; ++i) {
        arrL.add(i);
    }
    System.out.println( (System.nanoTime() - nano2) );

    for(int j : arrL) {
        ;
    }
    System.out.println( (System.nanoTime() - nano2) );


  [1]: https://stackoverflow.com/questions/322715/when-to-use-linkedlist-over-arraylist/322742#322742

ArrayList Vs LinkedList

I was asked this question in interview: &quot;How to detect the loop in linked list?&quot;, I solved this but immediately the interviewer asked me how do I remove the loop in a linked list.  I fumbled.

So any pointers on how to solve this, may be pseudo code, or method definition?

I&#39;m comfortable with Java so I have tagged this question under java.

For Instance this linked list has a loop

     0---&gt;1----&gt;2----&gt;3----&gt;4----&gt;5----&gt;6
                      ▲                 |
                      |                 ▼
                     11&lt;—-22&lt;—-12&lt;—-9&lt;—-8



Interview: Remove Loop in linked list - Java

In a recent [Slashdot Interview][1] Linus Torvalds gave an example of how some people use pointers in a way that indicates they don&#39;t really understand how to use them correctly. 

Unfortunately, since I&#39;m one of the people he&#39;s talking about, I also failed to understand his example:

&gt; *I&#39;ve seen too many people who delete a singly-linked list entry by keeping track of the &quot;prev&quot; entry, and then to delete the entry, doing
&gt; something like*
&gt; 
&gt;     if (prev)
&gt;         prev-&gt;next = entry-&gt;next;
&gt;     else
&gt;         list_head = entry-&gt;next;
&gt; 
&gt; 
&gt; &lt;em&gt;and whenever I see code like that, I just go &quot;This person doesn&#39;t
&gt; understand pointers&quot;. And it&#39;s sadly quite common. People who
&gt; understand pointers just use a &quot;pointer to the entry pointer&quot;, and
&gt; initialize that with the address of the list_head. And then as they
&gt; traverse the list, they can remove the entry without using any
&gt; conditionals, by just doing&lt;/em&gt;
&gt; 
&gt;     *pp = entry-&gt;next

Can someone provide a bit more explanation about why this approach is better, and how it can work without a conditional statement?

  [1]: http://meta.slashdot.org/story/12/10/11/0030249/linus-torvalds-answers-your-questions

Using pointers to remove item from singly-linked list

I understand the definition of a Linked List, but how can it be represented and related to a common concept or item?  

For example, composition (EDIT: originally said &#39;inheritance&#39;) in OOP can be related to automobiles.  All (most) automobiles in real life are the essentially same thing; an automobile has an Engine, you can start() it, you can make the car go(), stop() and so on.  An automobile would typically have a maximum passenger capacity but it would differ between a Bus and a SportsCar, which are both automobiles.  

Is there some real life, intuitive example of the plain ole&#39; singly Linked List like we have with inheritance?  The typical textbook Linked List example shows a node with an integer and a pointer to the next, and it just doesn&#39;t seem very useful.  

Your input is appreciated. 

What is a practical, real world example of the Linked List?

I&#39;m trying to compare the growth rates (both run-time and space) for stack and queue operations when implemented as both arrays and as linked lists. So far I&#39;ve only been able to find average case run-times for queue `pop()`s, but nothing that comprehensively explores these two data structures and compares their run-times/space behaviors.

Specifically, I&#39;m looking to compare `push()` and `pop()` for both queues and stacks, implemented as **both** arrays and linked lists (thus 2 operations x 2 structures x 2 implementations, or 8 values).

Additionally, I&#39;d appreciate best, average and worst case values for both of these, and anything relating to the amount of space they consume.

The closest thing I&#39;ve been able to find is this &quot;mother of all cs cheat sheets&quot; pdf that  is clearly a masters- or doctoral-level cheat sheet of advanced algorithms and discrete functions.

**I&#39;m just looking for a way to determine when and where I should use an array-based implementation vs. a list-based implementation for both stacks and queues.**

Array-Based vs List-Based Stacks and Queues

As the title asks, I wonder if the size() method in the LinkedList class takes amortized O(1) time or O(n) time. 


What is the time complexity of a size() call on a LinkedList in Java?

Why exactly do we need a &quot;Circular Linked List&quot; (singly or doubly) data structure?

What problem does it solve that is evident with simple Linked Lists (singly or doubly)? 

Why exactly do we need a &quot;Circular Linked List&quot; (singly or doubly) data structure?

I was recently brushing up on some fundamentals and found merge sorting a linked list to be a pretty good challenge. If you have a good implementation then show it off here.

Merge Sort a Linked List

For a simple linked list in which random access to list elements is not a requirement, are there any significant advantages (performance or otherwise) to using &lt;code&gt;std::list&lt;/code&gt; instead of &lt;code&gt;std::vector&lt;/code&gt;?  If backwards traversal is required, would it be more efficient to use &lt;code&gt;std::slist&lt;/code&gt; and &lt;code&gt;reverse()&lt;/code&gt; the list prior to iterating over its elements?

Relative performance of std::vector vs. std::list vs. std::slist?

In an interview today I got asked the question. 

Apart from answering reversing the list and both forward and backward traversal there was something &quot;fundamental&quot; in it that the interviewer kept stressing. I gave up and of course after interview did a bit of research. It seems that insertion and deletion are more efficient in doubly linked list than singly linked list. I am not quite sure how it can be more efficient for a doubly linked list since it is obvious that more references are required to change.
Can anybody explain the secret behind? I honestly did a quite a bit of research and failed to understand with my main trouble being the fact that a O(n) searching is still needed for the double linked list.


When is doubly linked list more efficient than singly linked list?

How does one go about doing doubly linked lists in a pure functional language? That is, something like Haskell where you&#39;re not in a Monad so you don&#39;t have mutation. Is it possible? (Singly linked list is obviously pretty easy).

All Linked List Solutions on Gang of Coders

Total of 39 Linked List Solutions