Insert at Beginning of Doubly Linked List in DSA Typescript - Build from Scratch

Insert at Beginning of Doubly Linked List

📖 Scenario: You are building a simple contact list app. Each contact is stored in a doubly linked list node with a name. You want to add new contacts at the beginning of the list so the newest contact appears first.

🎯 Goal: Create a doubly linked list and write code to insert a new contact node at the beginning of the list.

📋 What You'll Learn

Create a Node class with name, prev, and next properties

Create a DoublyLinkedList class with a head property

Write a method insertAtBeginning(name: string) to add a new node at the start

Print the list from head to tail showing all contact names

💡 Why This Matters

🌍 Real World

Doubly linked lists are used in music players to move forward and backward between songs, or in browsers to navigate back and forth between pages.

💼 Career

Understanding linked lists helps in jobs involving system design, memory management, and building efficient data structures for software applications.

1

Create Node and DoublyLinkedList classes

Create a Node class with a constructor that takes a name string and sets prev and next to null. Then create a DoublyLinkedList class with a head property initialized to null.

DSA Typescript

// Your code here to create Node and DoublyLinkedList classes

Hint

Define the Node class with name, prev, and next. Then define DoublyLinkedList with head set to null.

2

Add insertAtBeginning method

Inside the DoublyLinkedList class, add a method called insertAtBeginning(name: string) that creates a new Node with the given name.

DSA Typescript

class Node {
    name: string;
    prev: Node | null;
    next: Node | null;

    constructor(name: string) {
        this.name = name;
        this.prev = null;
        this.next = null;
    }
}

class DoublyLinkedList {
    head: Node | null;

    constructor() {
        this.head = null;
    }

    // Add insertAtBeginning method here
    // Your code here
}

Hint

Define insertAtBeginning method that creates a new Node with the given name.

3

Complete insertAtBeginning logic

Complete the insertAtBeginning method to insert the new node at the start of the list. If head is null, set head to the new node. Otherwise, set the new node's next to the current head, set the current head's prev to the new node, then update head to the new node.

DSA Typescript

class Node {
    name: string;
    prev: Node | null;
    next: Node | null;

    constructor(name: string) {
        this.name = name;
        this.prev = null;
        this.next = null;
    }
}

class DoublyLinkedList {
    head: Node | null;

    constructor() {
        this.head = null;
    }

    insertAtBeginning(name: string) {
        const newNode = new Node(name);
        // Your code here to insert newNode at beginning
    }
}

Hint

Check if head is null. If yes, set head to newNode. Otherwise, link newNode before current head and update head.

4

Print the list from head to tail

Add a method printList() in DoublyLinkedList that prints all node names from head to the end separated by -> . Then create a list, insert "Alice", "Bob", and "Charlie" at the beginning in that order, and print the list.

DSA Typescript

class Node {
    name: string;
    prev: Node | null;
    next: Node | null;

    constructor(name: string) {
        this.name = name;
        this.prev = null;
        this.next = null;
    }
}

class DoublyLinkedList {
    head: Node | null;

    constructor() {
        this.head = null;
    }

    insertAtBeginning(name: string) {
        const newNode = new Node(name);
        if (this.head === null) {
            this.head = newNode;
        } else {
            newNode.next = this.head;
            this.head.prev = newNode;
            this.head = newNode;
        }
    }

    // Add printList method here
    // Your code here
}

// Create list, insert "Alice", "Bob", "Charlie" at beginning, then print
// Your code here

Hint

Traverse from head to end, collect names separated by -> , then print. Insert contacts in order and print.

Practice

1. What is the main purpose of inserting a node at the beginning of a doubly linked list?

easy

A. To reverse the entire list

B. To add a new node after the tail node

C. To delete the first node in the list

D. To add a new node before the current head node

Solution

1. Step 1: Understand the head node position

   The head node is the first node in the doubly linked list.

2. Step 2: Insert new node before head

   Inserting at the beginning means placing the new node before the current head, making it the new head.

3. Final Answer:

   To add a new node before the current head node -> Option D

4. Quick Check:

   Insert at beginning = add before head [OK]

Hint: Beginning means before the head node [OK]

Common Mistakes:

• Confusing insertion at beginning with insertion at end
• Thinking insertion deletes nodes
• Mixing up head and tail nodes

2. Which of the following TypeScript code snippets correctly creates a new node and inserts it at the beginning of a doubly linked list?

easy

A. newNode.next = head; if(head) head.prev = newNode; head = newNode;

B. newNode.prev = head; if(head) head.next = newNode; head = newNode;

C. newNode.next = null; head = newNode; newNode.prev = null;

D. head = newNode; newNode.next = head; newNode.prev = head;

Solution

1. Step 1: Set newNode.next to current head

   The new node's next pointer should point to the current head node.

2. Step 2: Update current head's prev to newNode if head exists

   If the list is not empty, the current head's prev pointer must point back to the new node.

3. Step 3: Update head to newNode

   Finally, the head pointer is updated to the new node.

4. Final Answer:

   newNode.next = head; if(head) head.prev = newNode; head = newNode; -> Option A

5. Quick Check:

   Set newNode.next=head, head.prev=newNode, head=newNode [OK]

Hint: newNode.next = head; head.prev = newNode; head = newNode [OK]

Common Mistakes:

• Swapping next and prev pointers
• Not updating head pointer
• Setting newNode.prev incorrectly

3. Given the following TypeScript code for a doubly linked list insertion at beginning, what will be the printed list after insertion?

class Node {
  data: number;
  next: Node | null = null;
  prev: Node | null = null;
  constructor(data: number) { this.data = data; }
}

let head: Node | null = new Node(10);
head.next = new Node(20);
head.next.prev = head;

const newNode = new Node(5);
newNode.next = head;
head.prev = newNode;
head = newNode;

// Print list
let temp = head;
const result: number[] = [];
while(temp) {
  result.push(temp.data);
  temp = temp.next;
}
console.log(result);

medium

A. [5, 10, 20]

B. [10, 20, 5]

C. [20, 10, 5]

D. [5, 20, 10]

Solution

1. Step 1: Initial list before insertion

   List is 10 <-> 20, head points to 10.

2. Step 2: Insert newNode with data 5 at beginning

   newNode.next = head (10), head.prev = newNode, head = newNode (5).

3. Step 3: Traverse list from new head

   Traverse from 5: 5 -> 10 -> 20.

4. Final Answer:

   [5, 10, 20] -> Option A

5. Quick Check:

   New head 5 followed by 10 and 20 [OK]

Hint: New node becomes head, list order starts with new node [OK]

Common Mistakes:

• Not updating head to newNode
• Incorrectly linking prev pointers
• Printing list from old head

4. Identify the error in the following TypeScript code that attempts to insert a node at the beginning of a doubly linked list:

const newNode = new Node(15);
newNode.prev = null;
newNode.next = head;
head.prev = newNode;
head = newNode;

medium

A. newNode.prev should point to head

B. Missing check if head is null before accessing head.prev

C. head should be assigned before setting newNode.next

D. newNode.next should be null

Solution

1. Step 1: Check if head is null before accessing head.prev

   If the list is empty (head is null), accessing head.prev causes an error.

2. Step 2: Add condition to update head.prev only if head exists

   Use if(head) head.prev = newNode; to avoid runtime error.

3. Final Answer:

   Missing check if head is null before accessing head.prev -> Option B

4. Quick Check:

   Always check head before head.prev [OK]

Hint: Check if head exists before accessing its properties [OK]

Common Mistakes:

• Ignoring null head and causing runtime error
• Swapping next and prev pointers
• Assigning head too early

5. You have a doubly linked list with nodes containing values [30, 40, 50]. You want to insert a new node with value 20 at the beginning. After insertion, which of the following correctly represents the list and the pointers of the new head node?

hard

A. List: 20 <-> 30 <-> 40 <-> 50; new head prev points to 30, next = null

B. List: 30 <-> 40 <-> 50 <-> 20; new head prev = 50, next = null

C. List: 20 <-> 30 <-> 40 <-> 50; new head prev = null, next points to 30

D. List: 50 <-> 40 <-> 30 <-> 20; new head prev = null, next points to 40

Solution

1. Step 1: Insert new node with value 20 before current head 30

   New node becomes head, its prev is null, next points to old head (30).

2. Step 2: Update old head's prev to new node

   Old head (30) prev pointer updated to new node (20).

3. Step 3: Confirm list order and pointers

   List order is 20 <-> 30 <-> 40 <-> 50 with new head prev=null, next=30.

4. Final Answer:

   List: 20 <-> 30 <-> 40 <-> 50; new head prev = null, next points to 30 -> Option C

5. Quick Check:

   New head prev=null, next=old head [OK]

Hint: New head prev always null, next points to old head [OK]

Common Mistakes:

• Setting new head prev to old tail
• Reversing list order accidentally
• Not updating old head prev pointer