Abhishek Gupta

Posted on Apr 27 • Edited on Apr 29

Linked List Operations in JavaScript: A Complete Step-by-Step Guide

#computerscience #dsa #javascript #tutorial

🧱 1. What is a Linked List?

A Linked List is a linear data structure where elements are stored in nodes, and each node points to the next.

[value | next] → [value | next] → [value | null]

👉 Last node always points to null

🔧 2. Node Structure

function Node(value) {
  this.data = value;
  this.next = null;
}

🏗️ 3. Linked List Class

var MyLinkedList = function () {
    this.head = null;
    this.len = 0; // MUST be 0
};

⚠️ IMPORTANT RULES (DO NOT IGNORE)

Always use 0-based indexing
Always update len
Never break pointer chain
Always check invalid index

📌 4. Add At Head

🖼️ Visualization

💡 Idea

New node becomes the first node.

🪜 Steps

Create new node
Point it to current head
Move head to new node

✅ Code

MyLinkedList.prototype.addAtHead = function (val) {
    const node = new Node(val);

    node.next = this.head;
    this.head = node;

    this.len++;
};

⏱ Complexity

O(1)

📌 5. Add At Tail

🖼️ Visualization

💡 Idea

Go to last node → attach new node

🪜 Steps

If empty → head = node
Else → traverse to last
Connect last.next = node

✅ Code

MyLinkedList.prototype.addAtTail = function (val) {
    const node = new Node(val);

    if (!this.head) {
        this.head = node;
        this.len++;
        return;
    }

    let current = this.head;

    while (current.next) {
        current = current.next;
    }

    current.next = node;
    this.len++;
};

⏱ Complexity

O(n)

📌 6. Get Value at Index

🖼️ Visualization

💡 Idea

Traverse from head to index

🪜 Steps

Check bounds
Move step-by-step
Return value

✅ Code

MyLinkedList.prototype.get = function (index) {
    if (index < 0 || index >= this.len) return -1;

    let current = this.head;

    for (let i = 0; i < index; i++) {
        current = current.next;
    }

    return current.data;
};

⏱ Complexity

O(n)

📌 7. Add At Index

🖼️ Visualization

💡 Idea

Reach index - 1, then insert

🪜 Steps

If index invalid → return
If index = 0 → head
If index = len → tail
Else:

go to index - 1
insert node

✅ Code

MyLinkedList.prototype.addAtIndex = function (index, val) {
    if (index < 0 || index > this.len) return;

    if (index === 0) {
        this.addAtHead(val);
        return;
    }

    if (index === this.len) {
        this.addAtTail(val);
        return;
    }

    let prev = this.head;

    for (let i = 0; i < index - 1; i++) {
        prev = prev.next;
    }

    const node = new Node(val);
    node.next = prev.next;
    prev.next = node;

    this.len++;
};

⏱ Complexity

O(n)

📌 Delete Node at Index in Linked List (Detailed)

🧠 Core Idea

A linked list is a chain of nodes:

10 → 20 → 30 → 40

Each node stores:

value
next (pointer to next node)

👉 To delete a node, you don’t remove it directly
👉 You change links (pointers) so it gets skipped

🎯 Goal

Delete node at a given index

Example:

Index: 2

Before:
10 → 20 → 30 → 40

After:
10 → 20 → 40

💡 Key Insight

👉 You must stop at the previous node

Because:

prev.next = prev.next.next

This skips the node you want to delete.

🪜 Step-by-Step Explanation

✅ Step 1: Validate Index

if (index < 0 || index >= this.len) return;

Why?

Negative index ❌
Index beyond list size ❌

✅ Step 2: Special Case (index = 0)

Deleting head:

Before:
[10] → 20 → 30

After:
20 → 30

Code:

this.head = this.head.next;

👉 We simply move the head forward

✅ Step 3: Traverse to (index - 1)

Why?
Because we need the previous node

let prev = this.head;

for (let i = 0; i < index - 1; i++) {
    prev = prev.next;
}

✅ Step 4: Bypass the Node

prev → toDelete → nextNode

becomes

prev → nextNode

Code:

let toDelete = prev.next;
prev.next = toDelete.next;

✅ Step 5: Cleanup (Optional but Good Practice)

toDelete.next = null;

👉 Helps garbage collection
👉 Avoids accidental memory reference

✅ Step 6: Update Length

this.len--;

🔥 Full Code (Clean Version)

MyLinkedList.prototype.deleteAtIndex = function (index) {
    if (index < 0 || index >= this.len) return;

    if (index === 0) {
        this.head = this.head.next;
        this.len--;
        return;
    }

    let prev = this.head;

    for (let i = 0; i < index - 1; i++) {
        prev = prev.next;
    }

    let toDelete = prev.next;
    prev.next = toDelete.next;

    toDelete.next = null;

    this.len--;
};

🧪 Dry Run Example

Initial list:

20 → 99 → 10 → 30

Delete index = 1

Step 1:

Go to index - 1 = 0
prev = 20

Step 2:

toDelete = 99

Step 3:

20.next = 10

Final list:

20 → 10 → 30

⏱ Time & Space Complexity

⏱ Time:

Traversal → O(n)

📦 Space:

No extra memory → O(1)

🧠 Ultimate Pattern to Remember

Delete = Skip node

prev.next = prev.next.next

🔥 FULL WORKING EXAMPLE

var obj = new MyLinkedList();

obj.addAtHead(10);
obj.addAtHead(20);
obj.addAtTail(30);
obj.addAtIndex(1, 99);

console.log(obj.get(1)); // 99

obj.deleteAtIndex(1);

console.log(obj.get(1)); // 10