Delete from End of Doubly Linked List in DSA C# - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after deleting the last node?

Consider a doubly linked list with nodes 10 <-> 20 <-> 30 <-> 40. After deleting the last node, what is the printed list?

DSA C#

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

class DoublyLinkedList {
    public Node head;

    public void Append(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
            return;
        }
        Node temp = head;
        while (temp.next != null) {
            temp = temp.next;
        }
        temp.next = newNode;
        newNode.prev = temp;
    }

    public void DeleteFromEnd() {
        if (head == null) return;
        if (head.next == null) {
            head = null;
            return;
        }
        Node temp = head;
        while (temp.next != null) {
            temp = temp.next;
        }
        temp.prev.next = null;
    }

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

var dll = new DoublyLinkedList();
dll.Append(10);
dll.Append(20);
dll.Append(30);
dll.Append(40);
dll.DeleteFromEnd();
dll.PrintList();

A 10 <-> 20 <-> 30 <-> 40

B 20 <-> 30 <-> 40

C 10 <-> 20 <-> 30

D 10 <-> 20

💡 Hint

Deleting from end removes the last node and updates the previous node's next pointer.

The last node with value 40 is removed. The previous node 30's next pointer is set to null, so the list ends at 30.

❓ Predict Output

intermediate

What happens when deleting from an empty doubly linked list?

Given an empty doubly linked list, what is the output after calling DeleteFromEnd() and then printing the list?

DSA C#

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

class DoublyLinkedList {
    public Node head;

    public void DeleteFromEnd() {
        if (head == null) return;
        if (head.next == null) {
            head = null;
            return;
        }
        Node temp = head;
        while (temp.next != null) {
            temp = temp.next;
        }
        temp.prev.next = null;
    }

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

var dll = new DoublyLinkedList();
dll.DeleteFromEnd();
dll.PrintList();

A List is empty

B null

C 0

D Throws NullReferenceException

💡 Hint

Check if the list is empty before deleting.

Since the list is empty, DeleteFromEnd does nothing and PrintList prints 'List is empty'.

🔧 Debug

advanced

Identify the bug in DeleteFromEnd method

What is the bug in the following DeleteFromEnd method of a doubly linked list?

DSA C#

public void DeleteFromEnd() {
    if (head == null) return;
    if (head.next == null) {
        head = null;
        return;
    }
    Node temp = head;
    while (temp.next != null) {
        temp = temp.next;
    }
    temp.next = null;
}

A Missing check for head == null

B temp.next = null; should be temp.prev.next = null;

C Should set head = null when only one node

D No bug, code is correct

💡 Hint

Think about how to remove the last node and update the previous node's next pointer.

The code tries to set temp.next = null, but temp.next is already null (last node). It should update temp.prev.next to null to remove the last node.

🧠 Conceptual

advanced

What is the time complexity of deleting from the end of a doubly linked list without tail pointer?

If a doubly linked list does not maintain a tail pointer, what is the time complexity of deleting the last node?

A O(n^2) because of nested loops

B O(1) because you can directly access the last node

C O(log n) because of binary search

D O(n) because you must traverse to the last node

💡 Hint

Without a tail pointer, you must start from head and go to the end.

Without a tail pointer, you must traverse all nodes to reach the last node, which takes O(n) time.

🚀 Application

expert

After multiple deletions from end, what is the final list?

Starting with a doubly linked list: 5 <-> 15 <-> 25 <-> 35 <-> 45, after calling DeleteFromEnd() three times, what is the printed list?

DSA C#

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

class DoublyLinkedList {
    public Node head;

    public void Append(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
            return;
        }
        Node temp = head;
        while (temp.next != null) {
            temp = temp.next;
        }
        temp.next = newNode;
        newNode.prev = temp;
    }

    public void DeleteFromEnd() {
        if (head == null) return;
        if (head.next == null) {
            head = null;
            return;
        }
        Node temp = head;
        while (temp.next != null) {
            temp = temp.next;
        }
        temp.prev.next = null;
    }

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

var dll = new DoublyLinkedList();
dll.Append(5);
dll.Append(15);
dll.Append(25);
dll.Append(35);
dll.Append(45);
dll.DeleteFromEnd();
dll.DeleteFromEnd();
dll.DeleteFromEnd();
dll.PrintList();

A 5 <-> 15

B 5 <-> 15 <-> 25

C 25 <-> 35 <-> 45

D 5

💡 Hint

Each deletion removes the last node, so after three deletions, three nodes are removed.

The last three nodes 45, 35, and 25 are removed. Remaining nodes are 5 and 15.

Practice

1. What happens when you delete the last node from a doubly linked list that has multiple nodes?

easy

A. The first node is deleted instead.

B. The head pointer is set to null.

C. The list becomes empty immediately.

D. The second last node becomes the new tail and its next pointer is set to null.

Solution

1. Step 1: Identify the last node and its previous node

   In a doubly linked list, the last node's previous node is the second last node.

2. Step 2: Update the second last node's next pointer

   Set the second last node's next pointer to null to remove the last node from the list.

3. Final Answer:

   The second last node becomes the new tail and its next pointer is set to null. -> Option D

4. Quick Check:

   Deleting last node updates tail's next to null [OK]

Hint: Last node's previous next pointer must be null after deletion [OK]

Common Mistakes:

• Setting head to null instead of updating tail
• Not updating the previous node's next pointer
• Deleting the first node by mistake

2. Which of the following is the correct C# syntax to delete the last node from a doubly linked list named dll?

easy

A. dll.Head = dll.Head.Next; dll.Head.Previous = null;

B. dll.Tail = dll.Tail.Previous; dll.Tail.Next = null;

C. dll.Tail = null; dll.Head = null;

D. dll.Head.Previous = dll.Tail; dll.Tail.Next = dll.Head;

Solution

1. Step 1: Move tail pointer to previous node

   Set dll.Tail to dll.Tail.Previous to remove the last node.

2. Step 2: Set new tail's next pointer to null

   Update dll.Tail.Next to null to mark the end of the list.

3. Final Answer:

   dll.Tail = dll.Tail.Previous; dll.Tail.Next = null; -> Option B

4. Quick Check:

   Correct tail update syntax = dll.Tail = dll.Tail.Previous; dll.Tail.Next = null; [OK]

Hint: Tail moves back, next pointer cleared [OK]

Common Mistakes:

• Updating head instead of tail
• Not setting tail's next to null
• Setting both head and tail to null unnecessarily

3. Consider the following C# code that deletes the last node from a doubly linked list. What will be the printed list after deletion?

dll.AddLast(1); dll.AddLast(2); dll.AddLast(3); dll.DeleteFromEnd(); dll.PrintList();

medium

A. 2 -> 3 -> null

B. 1 -> 2 -> 3 -> null

C. 1 -> 2 -> null

D. null

Solution

1. Step 1: Add nodes 1, 2, 3 to the list

   The list becomes 1 -> 2 -> 3 -> null.

2. Step 2: Delete the last node (3)

   After deletion, the list becomes 1 -> 2 -> null.

3. Final Answer:

   1 -> 2 -> null -> Option C

4. Quick Check:

   Last node removed, list ends at 2 [OK]

Hint: Deleting last removes tail node only [OK]

Common Mistakes:

• Assuming list remains unchanged
• Deleting head instead of tail
• Printing list before deletion

4. The following code attempts to delete the last node from a doubly linked list but causes a runtime error. What is the error?

if (dll.Tail != null) { dll.Tail = dll.Tail.Previous; dll.Tail.Next = null; }

medium

A. NullReferenceException when list has only one node

B. Syntax error due to missing braces

C. The head pointer is not updated

D. The list becomes circular

Solution

1. Step 1: Check deletion when only one node exists

   If only one node exists, dll.Tail.Previous is null, so dll.Tail becomes null.

2. Step 2: Accessing dll.Tail.Next causes error

   After setting dll.Tail to null, accessing dll.Tail.Next throws NullReferenceException.

3. Final Answer:

   NullReferenceException when list has only one node -> Option A

4. Quick Check:

   Accessing property on null tail causes error [OK]

Hint: Check for null tail before accessing Next [OK]

Common Mistakes:

• Not handling single-node list case
• Ignoring null checks before pointer access
• Assuming head updates automatically

5. You have a doubly linked list with nodes: 10 <-> 20 <-> 30 <-> 40. After deleting the last node twice, what will be the list and the tail node's value?

hard

A. 10 <-> 20 -> null, Tail = 20

B. 10 <-> 20 <-> 30 -> null, Tail = 30

C. 10 -> null, Tail = 10

D. Empty list, Tail = null

Solution

1. Step 1: Initial list and first deletion

   List is 10 <-> 20 <-> 30 <-> 40. Deleting last node removes 40, list becomes 10 <-> 20 <-> 30.

2. Step 2: Second deletion removes 30

   After second deletion, list becomes 10 <-> 20, and tail points to node with value 20.

3. Final Answer:

   10 <-> 20 -> null, Tail = 20 -> Option A

4. Quick Check:

   Two deletions remove last two nodes [OK]

Hint: Each deletion removes tail, tail moves back [OK]

Common Mistakes:

• Deleting only one node instead of two
• Not updating tail after deletions
• Confusing head and tail pointers