thank u, next: an introduction to linked lists

Ali Spittel on December 05, 2018

In this post, we are going to be talking about the linked list data structure in the language of "thank u, next" by Ariana Grande. If you haven't... [Read Full]
markdown guide
 
 
 

Everybody's getting into the spirit

 

That's a good introduction to linked lists.

Still I believe that linked lists are one of the most overrated data structures and that in practice there are very few use cases where they really perform better than dynamic arrays.

The main reason is that modern hardware has very efficient caches and that caching doesn't really work for linked lists.

While it's super efficient (O(1)) to get an item at an index, it's less efficient to insert or delete items from the array -- we would need to move everything to a different block in memory. It's not guaranteed that there's space before or after that array to insert the new item.

True, but caches are extremely good at moving blocks of memory around.

For a long time I believed myself that linked lists have huge advantages when inserting or deleting items and that this makes up for their difficult handling. But after doing some performance testing I did not find any practical case where they actually make sense.

At least I found that to be the case for C++ and Java. It might be different for certain interpreted languages where caching behaves differently.

 

Agreed, especially since dynamic languages pre-allocate space so insertion and deletion is more efficient. They come in most handy for implementing stacks and queues IMO.

 

The main reason I use linked lists are for queue structures where you frequently need to add to the end or pop the beginning, it's very bad if either of these operations are O(n). Instead you can use a simple singly-linked list.

When using a language like Java though, the LinkedList class isn't that good. The entire point of using a LinkedList over an ArrayList is that you can control certain things to make sure that the list operates as efficiently as possible, but Java's implementation doesn't allow for this.

 

One thing that people forget so often is that "linked list" as data structure doesn't have to mean the exact in-memory representation. When you use a LinkedList class, you don't care for its implementation details: it could actually be storing elements sequentially like a traditional array, but exposing only the methods so you see it like a linked list.

When talking about data structures, it's all about the public interface.

 

When you use a LinkedList class, you don't care for its implementation details

But linked list is the name of a specific implementation of a list. When a class is named LinkedList, I expect it to be implemented this way.

If you don't care about the implementation, it would be better to declare and use an interface named List that is implemented by classes named LinkedList or ArrayList.

Indeed, I should've used the term Abstract Data Type (ADT), not data structure.

Still, I don't think that LinkedList refers to the way it's implemented. For example, it's not uncommon for a tree to be implemented as two arrays: one to hold the index of the parent and the other to store the actual data. Such data structure could still expose all public methods as a tree, and you wouldn't have to know how it's implemented.

 

One case where they do make sense, is sharing the same (potentially very long) tail among various heads. This is useful when you want to trace something that splits up a lot.

In certain edge-cases a combination of both may also be useful; that is, a linked list of arrays. I haven't come across any use case where this really makes sense though.

 
 
 

This is awesome - learnt a lot and enjoyed the references along the way 😀

One question I have - in the remove_value() function because it changes the this.head value does that mean iterating it would start from the removal point?

How would you get it back to the start after removing a value of that is the case?

 

Thanks!! It only changes this.head if we are trying to remove the first value. Otherwise, only the node variables will change!

 
 

Funny because I just started a thread on help.gnu.emacs because I was not aware that when you assign a list to a variable, you are really only assigning the fist cell (what you call the pointer) and so when you change a cell in one list you change it in the other list too... I was really confused by that behavior in some piece of code and that gave me the opportunity to brush up my "cons" skills... :)

lists.gnu.org/archive/html/help-gn...

 

I dont work as a programmer so forgive me if I might sounds dumb. Automating excel stuff with vba I only used arrays and few times dictionaries(which from what I Got to know is a synonymous for hashmap/hashtable). I tought that linked lists,stacks and queues where totally different data strutture with no correlation beside strong vakues in some way. I Got myself misleaded when you said you can implement stacks and queues on top od linked list. What do you mean by that? Maybe Next article i ll get it. But then what its seems to me that linked list are not that usefull at all.

 

I Got myself misleaded when you said you can implement stacks and queues on top od linked list. What do you mean by that?

Super quick, a stack is a stack of books. You can only put books on top and remove them from the top. So the first book you put is always the last to come in, because after a few books are added it will be at the bottom. To get to that you need to get each and every book sitting on top.

A linked list is a collection of nodes with data in which every node points to something, except the first one that points to nothing.

If you see the example Ali made:

to get to Ariana Grande (the book at the bottom in our stack example) you need to go through all the ex boyfriends. You would have to implement the two operations push and pop instead of remove_value which removes an arbitrary node (forbidden in a stack) but I hope you can see how you can map a stack on top of a linked list.

A queue is a similar concept. The difference between a stack and a queue is that a stack is last-in-first-out (the last boyfriend you add to the structure is the first one to go), a queue is first-in-first-out (the last boyfriend you add to the structure is the last one to go, in this case it's more similar to real-life).

I hope it's a bit clearer

 

omg i love this so much... i hope everyone who reads this can now make linked "lists and laugh" ;)

 

It is a good article, but it seems to me that it is not relevant to JS Arrays. In JS array is a simple object, but specific a little bit. So no performance profit from the creation of linked list as a data structure in JavaScript.

data can be stored at non-contiguous locations in the array (c) MDN

Please fix me if I am wrong.

Links:

 

There are definite advantages in certain situations to create a linked list over an array in JavaScript (whether they are common I can't say).

If your array is very large, deleting or adding elements near the beginning of the array can be expensive as all elements after the deleted or added element must be re-indexed. In a linked list, removing a node only affects one other node.

The trade off is the expense of traversing the linked list.

An example of the expense of adding or removing elements at the beginning of an array is comparing the performance of push vs unshift in javascript. I wrote a small function that pushes the value true to the end of an array some number of times and reports the time it took to perform that action, then it takes a new array and unshifts the value true to the beginning of the array the same number of times and reports the time taken for that action. Push with 100,000 elements took 1.8ms, unshift took 4.4 seconds, and I've written this entire paragraph while waiting for the 1,000,000 element unshift to finish. The 1,000,000 element push took 22ms. Now that it finished, the unshift took 12 MINUTES.

If you don't have to traverse very far on the list, the performance gain for adding and removing items near the beginning of the structure can be very significant, finishing in milliseconds instead of minutes.

 

That is awesome example! And thanks for perf tests you did!! I really forgot about that stuff, shame on me :)

 

Whooa! This is an excellent article with a lot of "aris". I loved it.

I want to ask you if it is okay to translate your article in Korean and share it with my Korean dev community? I often translate awesome English articles into Korean. I really like to share yours too.

Thanks for the article anyways 🎉

 

Hi Ali. Thanks for share your knowledge about this topic.😊😊
I have a doubt, When your insert data, you put Ari first, then Malcom and then more exes and the last is Sean. But I think, the first element should be insert is Sean because He was the first ex.
When I implemented Linked List, the idea is I don't know what's next element, any element could be insert, so I think the implementation should allow the first data to be inserted should be Sean and not Ari.
That's is no clear for me. Can you explain this situation, please?

 

This intersection of pop culture with tech it is so refreshing! This is a great post!

 
 

Shouldn't there be a method to remove a given index?

 

It’s incredibly similar to the remove value!

 
remove_value(value) {
    while (this.head && this.head === value) { // Special-casing the head
        this.head = this.head.next
    }

    for (let node = this.head; node.next; node = node.next) {
        while (node.next === value) {
            node.next = node.next.next
        }
    }
}

remove(i) {
    if (i === 0) { // Still special-casing the head. If only JS had pointers...
        this.head = null
        return
    }

    let node = this.head

    for (var j = 0; j++; j < i - 1) { // Go just *before* the node we need
        node = node.next
    }

    node.next = null
    this.length--
}
 

THIS IS PERFECT Now I expect all ways of learning to do so with pop culture. I'm a new learner, and this is one of the few things that just makes sense. Thank you!

 

aw, that's so good to hear! I'm gonna do more like this!

 

hahaha I loved it! Saying it's a unique way to talk about data structures is an understatement :D

 

Awesome! I'm going to have to check this pattern out, and see how Generators can be extended/written to create linked lists 🤔

 

Great way of explaining linked lists!

I wish this could give birth to a new series on dev.to:

Analogies to specific programming paradigms/concepts using songs

 

I think I might actually do that with pop culture references! Think it's super fun!

Thank you!

 
 
 

Ali, thanks for the article. I found it very helpful and well explained. How would you approach sorting of the linked lists?

 

Awesome! You could use any normal sorting algorithm that you would use for an array -- I think merge sort is usually preferred for them though. The implementation is uglier than for an array though!

 

Tank you very much. Always love when I find an article talking precisely about something I have to do in a project.

 
code of conduct - report abuse