Mastering LinkedList in C#

Key Characteristics of LinkedList<T>

• Doubly Linked Structure : Each node keeps track of its previous and next nodes, enabling traversal in both directions , forward and backward.
• Fast Insertions and Removals (O(1)) : When you already have a reference to a node, inserting before or after it or removing it takes constant time because only the pointers are updated.
• Sequential Access (No Indexing) : You cannot directly access elements by index (like myList[3]). Traversal is linear (O(n)), meaning you must iterate through nodes to reach a specific element.
• Allows Duplicates and Nulls : LinkedList<T> allows duplicate values and for reference types, null values are also valid.
• Dynamic Memory Allocation : Unlike List<T>, LinkedList<T> doesn’t rely on a continuous internal array. Each node exists independently in memory, making it flexible but with slightly more overhead.
• Heap Allocation : All LinkedList<T> objects and their nodes are allocated on the managed heap.
• Supports Duplicate Elements : Unlike HashSet<T> or SortedSet<T>, a LinkedList<T> allows duplicate values. If you add the same element multiple times, each entry is stored as a separate node in the list.
• Empty List Behavior : When the list is empty, the First and Last properties return null. This helps developers easily check whether a linked list currently holds any nodes.
• Not Thread-Safe : LinkedList<T> is not synchronized by default. If multiple threads need to access or modify the same list concurrently, you must handle synchronization manually (e.g. using locks or concurrent collections).

1. Count

public int Count { get; }

Gets the number of elements that are currently contained in the LinkedList<T>.

var list = new LinkedList<int>();
list.AddLast(10);
list.AddLast(20);
Console.WriteLine(list.Count); // Output: 2

Usage : This is use to check how many nodes are present in the linked list.

2. First

public LinkedListNode<T>? First { get; }

Gets the first node (LinkedListNode<T>) of the LinkedList<T>. Returns null if the list is empty.

var list = new LinkedList<string>();
list.AddLast("C#");
list.AddLast("Java");
Console.WriteLine(list.First.Value); // Output: C#

Usage : Use when you need direct access to the first node of the linked list to perform operations such as adding before or after it.

3. Last

public LinkedListNode<T>? Last { get; }

Gets the last node (LinkedListNode<T>) of the LinkedList<T>. Returns null if the list is empty.

var list = new LinkedList<string>();
list.AddLast("C#");
list.AddLast("Python");
Console.WriteLine(list.Last.Value); // Output: Python

Usage : Use when you want to access or modify the last node or when appending new elements efficiently using AddAfter() or AddLast().

1. Creating an Empty LinkedList

Creates an empty LinkedList<string> with no nodes. At this point, both First and Last are null.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var linkedlist = new LinkedList<string>();
        linkedlist.AddLast("Python");
        linkedlist.AddLast("Java");
        linkedlist.AddLast("C#");
        linkedlist.AddFirst("React");
        linkedlist.AddFirst("C++");
        linkedlist.AddLast("Go");
        foreach (var lst in linkedlist) {
            Console.WriteLine(lst);
        }
    }
}

C++
React
Python
Java
C#
Go

2. Creating and Initializing with a Collection

Initializes a new LinkedList<int> with the elements from an existing collection (List<int> in this case). The elements are added in the same order as they appear in the source collection.

Usage : This is mostly used when you already have data in another collection and want to convert it into a LinkedList<T>.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Source collection
        var languages = new List<string> { "C++", "React", "Python", "Java", "C#", "Go" };
        // Initialize LinkedList from existing collection
        var linkedLanguages = new LinkedList<string>(languages);
        foreach (var lang in linkedLanguages)
        {
            Console.WriteLine(lang);
        }
    }
}

C++
React
Python
Java
C#
Go

1. Music Playlist or Media Queue

When building a music player, video playlist or slideshow viewer, songs or items often need to move forward/backward dynamically. LinkedList<T> allows easy insertion, deletion and navigation between previous and next tracks.

var playlist = new LinkedList<string>();
playlist.AddLast("Song A");
playlist.AddLast("Song B");
playlist.AddLast("Song C");

var current = playlist.First;
Console.WriteLine("Now Playing: " + current.Value);  // Song A
current = current.Next;
Console.WriteLine("Next: " + current.Value);          // Song B

Why LinkedList? : No need to reindex or shift elements. you can directly move to Next or Previous songs efficiently.

2. LRU (Least Recently Used) Cache

An LRU cache keeps frequently used data easily accessible and removes the least recently used ones. LinkedList<T> is perfect because it allows O(1) insertion and removal from both ends.

class LRUCache
{
    private readonly int capacity;
    private readonly LinkedList<int> list = new();
    private readonly HashSet<int> set = new();
    public LRUCache(int capacity) => this.capacity = capacity;
    public void Access(int item)
    {
        if (set.Contains(item))
            list.Remove(item);
        else if (list.Count == capacity)
            set.Remove(list.Last.Value), list.RemoveLast();
        list.AddFirst(item);
        set.Add(item);
    }
}

Why LinkedList? : Quickly move frequently used items to the front and remove old ones from the end , both in constant time.

3. Navigation Systems (Browser History / Back-Forward Stack)

Web browsers or apps that maintain history navigation (e.g. back and forward) can use LinkedList<T> to maintain order and allow bidirectional traversal.

var history = new LinkedList<string>();
history.AddLast("Home");
history.AddLast("About");
history.AddLast("Contact");

var current = history.Last;
Console.WriteLine("Current Page: " + current.Value); // Contact
Console.WriteLine("Back to: " + current.Previous.Value); // About

Why LinkedList? : You can easily navigate both directions and remove or add new pages dynamically.