Insert at Beginning of Doubly Linked List in DSA C# - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after inserting nodes at the beginning

What is the printed state of the doubly linked list after inserting 10, then 20, then 30 at the beginning?

DSA C#

public class Node {
    public int data;
    public Node prev, next;
    public Node(int d) { data = d; prev = next = null; }
}

public class DoublyLinkedList {
    public Node head;

    public void InsertAtBeginning(int newData) {
        Node newNode = new Node(newData);
        newNode.next = head;
        if (head != null) {
            head.prev = newNode;
        }
        head = newNode;
    }

    public void PrintList() {
        Node temp = head;
        while (temp != null) {
            System.Console.Write(temp.data + " <-> ");
            temp = temp.next;
        }
        System.Console.WriteLine("null");
    }
}

class Program {
    static void Main() {
        DoublyLinkedList dll = new DoublyLinkedList();
        dll.InsertAtBeginning(10);
        dll.InsertAtBeginning(20);
        dll.InsertAtBeginning(30);
        dll.PrintList();
    }
}

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

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

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

D 30 -> 20 -> 10 -> null

💡 Hint

Remember, inserting at the beginning means the newest node becomes the head.

Each insertion adds a new node at the start. So the last inserted node (30) is the head, followed by 20, then 10.

🧠 Conceptual

intermediate

Understanding pointer updates in insertion

When inserting a new node at the beginning of a doubly linked list, which pointers must be updated?

A New node's next and prev both point to old head; head updated to new node

B New node's prev points to old head; old head's next points to new node; head updated to new node

C Only head pointer is updated to new node; no other pointers change

D New node's next points to old head; old head's prev points to new node; head updated to new node

💡 Hint

Think about how the new node connects forward and backward.

The new node's next must point to the old head. The old head's prev must point back to the new node. Finally, the head pointer is updated to the new node.

🔧 Debug

advanced

Identify the bug in insertion code

What error will this code cause when inserting at the beginning of a doubly linked list? public void InsertAtBeginning(int newData) { Node newNode = new Node(newData); newNode.prev = head; head.next = newNode; head = newNode; }

A NullReferenceException when head is null

B No error, code works correctly

C Infinite loop during traversal

D Compilation error due to missing semicolon

💡 Hint

Consider what happens if the list is empty (head is null).

If head is null, then head.next causes a NullReferenceException because you cannot access next on null.

❓ Predict Output

advanced

Output after multiple insertions and one removal

Given this sequence of operations, what is the final printed list? InsertAtBeginning(5) InsertAtBeginning(15) InsertAtBeginning(25) RemoveFirst() PrintList()

DSA C#

public class Node {
    public int data;
    public Node prev, next;
    public Node(int d) { data = d; prev = next = null; }
}

public class DoublyLinkedList {
    public Node head;

    public void InsertAtBeginning(int newData) {
        Node newNode = new Node(newData);
        newNode.next = head;
        if (head != null) {
            head.prev = newNode;
        }
        head = newNode;
    }

    public void RemoveFirst() {
        if (head == null) return;
        head = head.next;
        if (head != null) {
            head.prev = null;
        }
    }

    public void PrintList() {
        Node temp = head;
        while (temp != null) {
            System.Console.Write(temp.data + " <-> ");
            temp = temp.next;
        }
        System.Console.WriteLine("null");
    }
}

class Program {
    static void Main() {
        DoublyLinkedList dll = new DoublyLinkedList();
        dll.InsertAtBeginning(5);
        dll.InsertAtBeginning(15);
        dll.InsertAtBeginning(25);
        dll.RemoveFirst();
        dll.PrintList();
    }
}

A null

B 15 <-> 5 <-> null

C 25 <-> 15 <-> 5 <-> null

D 5 <-> 15 <-> null

💡 Hint

Removing first removes the head node.

After inserting 25, 15, 5 at beginning, list is 25 <-> 15 <-> 5. Removing first removes 25, so list becomes 15 <-> 5.

🧠 Conceptual

expert

Time complexity of insertion at beginning

What is the time complexity of inserting a node at the beginning of a doubly linked list and why?

A O(log n) because of binary search to find insertion point

B O(n) because you must traverse the list to find the head

C O(1) because insertion only changes a few pointers at the head

D O(n^2) because each insertion shifts all nodes

💡 Hint

Think about how many nodes you need to visit to insert at the start.

Insertion at the beginning only updates the head pointer and adjacent nodes, so it takes constant time.

Practice

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

easy

A. To add a new node as the first element of the list

B. To remove the last node from the list

C. To search for a node in the list

D. To reverse the entire list

Solution

1. Step 1: Understand the operation

   Inserting at the beginning means adding a new node before the current first node.

2. Step 2: Identify the effect on the list

   The new node becomes the head (first node), shifting others to the right.

3. Final Answer:

   To add a new node as the first element of the list -> Option A

4. Quick Check:

   Insert at beginning = Add first node [OK]

Hint: Insert at beginning means new node becomes the first [OK]

Common Mistakes:

• Confusing insertion with deletion
• Thinking insertion adds at the end
• Mixing up search with insertion

2. Which of the following is the correct syntax to create a new node in C# for a doubly linked list?

easy

A. Node newNode = new Node(data);

B. newNode = Node(data);

C. Node newNode = Node(data);

D. Node newNode = new Node[];

Solution

1. Step 1: Recall C# object creation syntax

   In C#, objects are created using the 'new' keyword followed by the constructor call.

2. Step 2: Match syntax with node creation

   Correct syntax is 'Node newNode = new Node(data);' to create a new node with data.

3. Final Answer:

   Node newNode = new Node(data); -> Option A

4. Quick Check:

   C# new object = new ClassName() [OK]

Hint: Use 'new' keyword to create objects in C# [OK]

Common Mistakes:

• Omitting 'new' keyword
• Using array syntax for single node
• Missing type declaration

3. Consider this code snippet inserting a node with value 10 at the beginning of a doubly linked list:

Node newNode = new Node(10);
newNode.next = head;
if (head != null) {
    head.prev = newNode;
}
head = newNode;

What will be the printed list after insertion if the original list was: 20 <-> 30 <-> null?

medium

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

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

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

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

Solution

1. Step 1: Insert new node at beginning

   New node with 10 points next to old head (20). Old head's prev points back to new node.

2. Step 2: Update head pointer

   Head now points to new node (10), so list starts with 10.

3. Final Answer:

   10 <-> 20 <-> 30 <-> null -> Option D

4. Quick Check:

   New node at front = 10 first [OK]

Hint: New node points to old head; update old head's prev [OK]

Common Mistakes:

• Not updating old head's prev pointer
• Appending new node at end instead of beginning
• Not updating head to new node

4. Identify the error in this code snippet for inserting at the beginning of a doubly linked list:

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

medium

A. Incorrect assignment of newNode.next

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

C. head should be assigned before setting newNode.next

D. newNode.prev should be set to head

Solution

1. Step 1: Analyze head.prev assignment

   Code sets head.prev = newNode without checking if head is null, causing error if list is empty.

2. Step 2: Identify missing null check

   Must check if head != null before setting head.prev to avoid null reference error.

3. Final Answer:

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

4. Quick Check:

   Check head != null before head.prev [OK]

Hint: Always check head != null before accessing head.prev [OK]

Common Mistakes:

• Ignoring null check on head
• Setting pointers in wrong order
• Confusing prev and next pointers

5. You have a doubly linked list with nodes: 5 <-> 15 <-> 25 <-> null. You want to insert a new node with value 1 at the beginning. After insertion, which of the following correctly represents the list and the pointers of the new node?

hard

A. 5 <-> 15 <-> 25 <-> 1 <-> null, newNode.prev = 25, newNode.next = null

B. 1 <-> 5 <-> 15 <-> 25 <-> null, newNode.prev = 5, newNode.next = null

C. 1 <-> 5 <-> 15 <-> 25 <-> null, newNode.prev = null, newNode.next = 5

D. 5 <-> 15 <-> 25 <-> 1 <-> null, newNode.prev = null, newNode.next = 5

Solution

1. Step 1: Insert new node at beginning

   New node with value 1 becomes head, points next to old head (5), prev is null.

2. Step 2: Confirm pointers and list order

   List order is 1 <-> 5 <-> 15 <-> 25 <-> null, newNode.prev = null, newNode.next = 5.

3. Final Answer:

   1 <-> 5 <-> 15 <-> 25 <-> null, newNode.prev = null, newNode.next = 5 -> Option C

4. Quick Check:

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

Hint: New head prev=null, next=old head node [OK]

Common Mistakes:

• Setting newNode.prev to old head
• Appending new node at end instead of beginning
• Not updating head pointer