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

Insert at Specific Position in Doubly Linked List

📖 Scenario: You are managing a playlist of songs using a doubly linked list. Each song is a node with a title. You want to insert a new song at a specific position in the playlist.

🎯 Goal: Build a doubly linked list of songs and insert a new song at a given position.

📋 What You'll Learn

Create a doubly linked list with three songs: "SongA", "SongB", "SongC"

Add a variable to hold the new song title "SongX" and the position 2

Write code to insert the new song at position 2 in the doubly linked list

Print the playlist from head to tail showing song titles separated by " -> " and ending with "null"

💡 Why This Matters

🌍 Real World

Doubly linked lists are used in music players, browsers, and other apps where you need to move forward and backward through items efficiently.

💼 Career

Understanding linked list insertion is fundamental for software developers working with data structures, memory management, and building efficient applications.

1

Create the initial doubly linked list

Create a doubly linked list with nodes containing the song titles "SongA", "SongB", and "SongC" in that order. Use a class Node with string data, Node next, and Node prev. Create a variable head pointing to the first node.

DSA C#

// Define Node class and create doubly linked list with SongA, SongB, SongC
// Your code here

Hint

Define a Node class with data, next, and prev. Then link the nodes in order.

2

Add new song title and position variables

Add two variables inside Main: a string variable called newSong with value "SongX", and an int variable called position with value 2.

DSA C#

using System;

class Node
{
    public string data;
    public Node next;
    public Node prev;

    public Node(string data)
    {
        this.data = data;
        this.next = null;
        this.prev = null;
    }
}

class Program
{
    static void Main()
    {
        Node head = new Node("SongA");
        Node second = new Node("SongB");
        Node third = new Node("SongC");

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

        // Add newSong and position variables here
        // Your code here
    }
}

Hint

Declare newSong as a string with value "SongX" and position as an int with value 2.

3

Insert the new song at the specific position

Write code inside Main to insert a new node with data newSong at the position in the doubly linked list starting at head. Position 1 means insert at the head. Update the links next and prev correctly.

DSA C#

        Node newNode = new Node(newSong);
        if (position == 1)
        {
            newNode.next = head;
            head.prev = newNode;
            head = newNode;
        }
        else
        {
            Node current = head;
            int count = 1;
            while (count < position - 1 && current.next != null)
            {
                current = current.next;
                count++;
            }
            newNode.next = current.next;
            if (current.next != null)
            {
                current.next.prev = newNode;
            }
            current.next = newNode;
            newNode.prev = current;
        }
        // Print the doubly linked list

Hint

Traverse to the node before the insertion position, then adjust next and prev pointers to insert the new node.

4

Print the doubly linked list from head to tail

Write code to print the doubly linked list starting from head. Print each song's data followed by " -> ". After the last node, print null.

DSA C#

Hint

Use a while loop to traverse from head to the end, printing each node's data followed by " -> ". After the loop, print "null".

Practice

1. What happens when you insert a new node at position 1 in a doubly linked list?

easy

A. The new node is ignored because position 1 is invalid.

B. The new node is added at the end of the list.

C. The new node becomes the new head of the list.

D. The list is reversed before insertion.

Solution

1. Step 1: Understand position 1 in doubly linked list

   Position 1 means the start of the list, so the new node should be the first element.

2. Step 2: Insert new node at head

   The new node's next pointer points to the old head, and the old head's previous pointer points back to the new node.

3. Final Answer:

   The new node becomes the new head of the list. -> Option C

4. Quick Check:

   Insert at position 1 = new head [OK]

Hint: Position 1 means new head insertion [OK]

Common Mistakes:

• Thinking position 1 means end of list
• Ignoring previous pointer update
• Assuming position 1 is invalid

2. Which of the following is the correct syntax to insert a new node at position 3 in a doubly linked list in C#?

easy

A. InsertAtPosition(newNode, 3);

B. InsertAtPosition(3, newNode);

C. InsertNodeAt(3, newNode);

D. AddNodeAtPosition(newNode, 3);

Solution

1. Step 1: Check method parameter order

   The common pattern is to pass the node first, then the position.

2. Step 2: Match method name and parameters

   InsertAtPosition(newNode, 3) matches the expected syntax for inserting at position 3.

3. Final Answer:

   InsertAtPosition(newNode, 3); -> Option A

4. Quick Check:

   Node first, position second = InsertAtPosition(newNode, 3); [OK]

Hint: Node comes before position in method call [OK]

Common Mistakes:

• Swapping parameter order
• Using incorrect method names
• Passing position before node

3. Given the doubly linked list: 10 <-> 20 <-> 30 <-> null, what is the list after inserting 15 at position 2?

medium

A. 10 <-> 15 <-> 20 <-> 30 <-> null

B. 15 <-> 10 <-> 20 <-> 30 <-> null

C. 10 <-> 20 <-> 15 <-> 30 <-> null

D. 10 <-> 20 <-> 30 <-> 15 <-> null

Solution

1. Step 1: Identify position 2 in the list

   Position 2 means after the first node (10), so new node goes between 10 and 20.

2. Step 2: Insert 15 between 10 and 20

   Update pointers: 10's next to 15, 15's previous to 10, 15's next to 20, 20's previous to 15.

3. Final Answer:

   10 <-> 15 <-> 20 <-> 30 <-> null -> Option A

4. Quick Check:

   Insert at position 2 = between first and second nodes [OK]

Hint: Position 2 means insert after first node [OK]

Common Mistakes:

• Inserting before first node
• Inserting at wrong position
• Not updating previous pointers

4. What is the error in the following code snippet for inserting at position 3 in a doubly linked list?

Node newNode = new Node(25);
Node temp = head;
for (int i = 1; i < 2; i++) {
    temp = temp.next;
}
newNode.next = temp.next;
newNode.prev = temp;
temp.next.prev = newNode;
temp.next = newNode;

medium

A. The loop should run until i < 2, not i < 3.

B. temp.next.prev = newNode; causes null reference if temp.next is null.

C. newNode.prev should be set to temp.prev instead of temp.

D. The newNode.next assignment is missing.

Solution

1. Step 1: Analyze loop and temp position

   The loop moves temp to the node at position 2, so temp.next might be null if list ends there.

2. Step 2: Check pointer updates for null safety

   Accessing temp.next.prev without checking if temp.next is null can cause a runtime error.

3. Final Answer:

   temp.next.prev = newNode; causes null reference if temp.next is null. -> Option B

4. Quick Check:

   Check for null before accessing temp.next.prev [OK]

Hint: Always check temp.next for null before accessing prev [OK]

Common Mistakes:

• Ignoring null pointer checks
• Wrong loop range causing off-by-one
• Incorrect pointer assignments

5. You have a doubly linked list: 5 <-> 10 <-> 15 <-> 20 <-> null. You want to insert a node with value 12 at position 3. After insertion, what will be the correct order of nodes?

medium

A. 5 <-> 10 <-> 15 <-> 20 <-> 12 <-> null

B. 5 <-> 12 <-> 10 <-> 15 <-> 20 <-> null

C. 12 <-> 5 <-> 10 <-> 15 <-> 20 <-> null

D. 5 <-> 10 <-> 12 <-> 15 <-> 20 <-> null

Solution

1. Step 1: Identify position 3 in the list

   Position 3 means the new node should be placed after the second node (10) and before the third node (15).

2. Step 2: Insert node with value 12 between 10 and 15

   Update pointers: 10's next to 12, 12's previous to 10, 12's next to 15, 15's previous to 12.

3. Final Answer:

   5 <-> 10 <-> 12 <-> 15 <-> 20 <-> null -> Option D

4. Quick Check:

   Insert at position 3 places node between second and third nodes [OK]

Hint: Insert at position n means between nodes n-1 and n [OK]

Common Mistakes:

• Inserting at wrong position
• Not updating both next and prev pointers
• Confusing position numbering