Insert at Specific Position in Doubly Linked List in DSA Typescript - Build from Scratch

Insert at Specific Position in Doubly Linked List

📖 Scenario: Imagine you are managing a playlist of songs. Each song is linked to the previous and next song, so you can move forward or backward easily. You want to add a new song at a specific position in the playlist.

🎯 Goal: You will build a doubly linked list of songs and write code to insert a new song at a given position.

📋 What You'll Learn

Create a doubly linked list with three songs: 'Song1', 'Song2', 'Song3'.

Create a variable called newSong with the value 'NewSong'.

Write a function called insertAtPosition that inserts a new song at a given position in the doubly linked list.

Insert newSong at position 2 (between 'Song1' and 'Song2').

Print the doubly linked list from head to tail showing song names separated by ' <-> '.

💡 Why This Matters

🌍 Real World

Doubly linked lists are used in music players, browsers (back and forward history), and many applications where you need to move both forward and backward efficiently.

💼 Career

Understanding linked lists and insertion operations is fundamental for software developers working with data structures, memory management, and building efficient algorithms.

1

Create the initial doubly linked list

Create a class called Node with properties data, prev, and next. Then create three nodes with data 'Song1', 'Song2', and 'Song3'. Link them to form a doubly linked list with head pointing to the first node.

DSA Typescript

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

// Your code here

Hint

Define the Node class first. Then create three nodes and link them using next and prev.

2

Create the new song to insert

Create a variable called newSong and assign it the string value 'NewSong'.

DSA Typescript

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

const head = new Node('Song1');
const second = new Node('Song2');
const third = new Node('Song3');

head.next = second;
second.prev = head;
second.next = third;
third.prev = second;

// Your code here

Hint

Just create a variable newSong and assign the string 'NewSong' to it.

3

Write the insertAtPosition function

Write a function called insertAtPosition that takes head of the doubly linked list, a string data, and a number position. It inserts a new node with data at the given position (1-based). Update the links correctly to maintain the doubly linked list structure.

DSA Typescript

function insertAtPosition(head: Node, data: string, position: number): Node {
  const newNode = new Node(data);
  if (position === 1) {
    newNode.next = head;
    head.prev = newNode;
    return newNode;
  let current = head;
  let count = 1;
  while (current !== null && count < position - 1) {
    current = current.next!;
    count++;
  if (current === null) {
    return head; // position is out of bounds, no insertion
  newNode.next = current.next;
  if (current.next !== null) {
    current.next.prev = newNode;
  current.next = newNode;
  newNode.prev = current;
  return head;

Hint

Remember to handle inserting at the start (position 1) and updating prev and next pointers carefully.

4

Insert the new song and print the list

Call insertAtPosition with head, newSong, and position 2. Then print the doubly linked list from head to tail, showing song names separated by ' <-> ' .

DSA Typescript

Hint

Call the function with position 2 and then loop from head to tail to collect song names. Join them with ' <-> ' and print.

Practice

1. What does inserting a node at a specific position in a doubly linked list involve?

easy

A. Adjusting the previous and next pointers of neighboring nodes to include the new node

B. Only changing the head pointer of the list

C. Replacing the node at that position without changing pointers

D. Adding the node at the end regardless of position

Solution

1. Step 1: Understand doubly linked list structure

   Each node has pointers to both previous and next nodes, so insertion requires updating these pointers.

2. Step 2: Insert node at specific position

   We must update the previous node's next pointer and the next node's previous pointer to point to the new node.

3. Final Answer:

   Adjusting the previous and next pointers of neighboring nodes to include the new node -> Option A

4. Quick Check:

   Pointer updates = Adjust neighbors [OK]

Hint: Remember to update both previous and next pointers [OK]

Common Mistakes:

• Only updating one pointer leads to broken links
• Ignoring the previous pointer in insertion
• Replacing nodes instead of inserting

2. Which of the following TypeScript code snippets correctly declares a node class for a doubly linked list?

easy

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

B. class Node { value: number; next: Node; prev: Node; constructor(value: number) { this.value = value; } }

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

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

Solution

1. Step 1: Check for previous and next pointers

   A doubly linked list node must have both next and prev pointers, which can be null.

2. Step 2: Verify constructor initializes all properties

   class Node { value: number; next: Node | null; prev: Node | null; constructor(value: number) { this.value = value; this.next = null; this.prev = null; } } initializes value, next, and prev correctly with proper types.

3. Final Answer:

   class Node { value: number; next: Node | null; prev: Node | null; constructor(value: number) { this.value = value; this.next = null; this.prev = null; } } -> Option D

4. Quick Check:

   Both pointers initialized = class Node { value: number; next: Node | null; prev: Node | null; constructor(value: number) { this.value = value; this.next = null; this.prev = null; } } [OK]

Hint: Doubly linked nodes need both next and prev pointers [OK]

Common Mistakes:

• Forgetting to initialize prev pointer
• Using wrong property names
• Not allowing null for next or prev

3. Given the doubly linked list 1 <-> 2 <-> 4 and the code below inserting 3 at position 3, what is the list after insertion?

insertAtPosition(head, 3, 3);

Positions start at 1.

medium

A. 1 <-> 2 <-> 3 <-> 4

B. 1 <-> 3 <-> 2 <-> 4

C. 3 <-> 1 <-> 2 <-> 4

D. 1 <-> 2 <-> 4 <-> 3

Solution

1. Step 1: Identify position 3 in the list

   Positions: 1=1, 2=2, 3=4. We want to insert before node with value 4.

2. Step 2: Insert node with value 3 at position 3

   Update pointers so 2 points next to 3, 3 points prev to 2 and next to 4, 4 points prev to 3.

3. Final Answer:

   1 <-> 2 <-> 3 <-> 4 -> Option A

4. Quick Check:

   Insert at position 3 = 1-2-3-4 [OK]

Hint: Count nodes, insert before node at that position [OK]

Common Mistakes:

• Inserting after instead of before position
• Mixing up prev and next pointers
• Off-by-one errors in position counting

4. What is wrong with this TypeScript code snippet for inserting a node at position 2 in a doubly linked list?

function insertAtPosition(head: Node | null, value: number, position: number): Node | null {
  let newNode = new Node(value);
  if (position === 1) {
    newNode.next = head;
    if (head) head.prev = newNode;
    return newNode;
  }
  let current = head;
  for (let i = 1; i < position - 1; i++) {
    if (!current) return head;
    current = current.next;
  }
  newNode.next = current.next;
  current.next = newNode;
  newNode.prev = current;
  return head;
}

medium

A. Not handling insertion at head

B. Incorrect loop range in for loop

C. Missing update of newNode.next.prev to newNode

D. Not creating new node correctly

Solution

1. Step 1: Analyze pointer updates after insertion

   After inserting newNode, newNode.next.prev should point back to newNode to maintain doubly links.

2. Step 2: Identify missing pointer update

   The code misses updating newNode.next.prev = newNode, which breaks backward link from next node.

3. Final Answer:

   Missing update of newNode.next.prev to newNode -> Option C

4. Quick Check:

   Update both next and prev pointers [OK]

Hint: Always update newNode.next.prev after insertion [OK]

Common Mistakes:

• Forgetting to update newNode.next.prev
• Loop off-by-one errors
• Not handling empty list insertion

5. You have a doubly linked list representing train cars: Engine <-> Car1 <-> Car2 <-> Caboose. You want to insert a new CarX at position 2. After insertion, what is the correct order of cars?

hard

A. CarX <-> Engine <-> Car1 <-> Car2 <-> Caboose

B. Engine <-> CarX <-> Car1 <-> Car2 <-> Caboose

C. Engine <-> Car1 <-> CarX <-> Car2 <-> Caboose

D. Engine <-> Car1 <-> Car2 <-> Caboose <-> CarX

Solution

1. Step 1: Identify position 2 in the list

   Positions: 1=Engine, 2=Car1. Insert CarX before Car1 to become new position 2.

2. Step 2: Insert CarX at position 2

   Update pointers so Engine next points to CarX, CarX prev to Engine, CarX next to Car1, Car1 prev to CarX.

3. Final Answer:

   Engine <-> CarX <-> Car1 <-> Car2 <-> Caboose -> Option B

4. Quick Check:

   Insert at position 2 = Engine-CarX-Car1... [OK]

Hint: Insert before node at position to shift others right [OK]

Common Mistakes:

• Inserting after instead of before position
• Not updating prev pointers correctly
• Confusing position indexing starting at 0