Delete from End of Doubly Linked List in DSA Java - Execution Trace

Concept Flow - Delete from End of Doubly Linked List

Start at tail node

↓

Check if list is empty?

| No↓

Check if only one node?

↓

Set head=null

↓

Set tail=null

↓

Done

Start from the tail node, check if list is empty or has one node, then update pointers to remove the last node.

Execution Sample

DSA Java

class Node {
  int data;
  Node prev, next;
}

void deleteFromEnd() {
  if (tail == null) return;
  if (tail.prev == null) head = tail = null;
  else {
    tail = tail.prev;
    tail.next = null;
  }
}

Deletes the last node from a doubly linked list by updating tail and next pointers.

Execution Table

Step	Operation	Nodes in List	Pointer Changes	Visual State
1	Start with list: 10 <-> 20 <-> 30 <-> 40	10 <-> 20 <-> 30 <-> 40	head → 10, tail → 40	┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐ │ data:10│ │ data:20│ │ data:30│ │ data:40│ │ prev:∅ │←── │ prev:10│←── │ prev:20│←── │ prev:30│ │ next:20│──→ │ next:30│──→ │ next:40│──→ │ next:∅ │ └────────┘ └────────┘ └────────┘ └────────┘ head tail
2	Delete from end: tail is 40	10 <-> 20 <-> 30 <-> 40	tail moves from 40 to 30	Step 2: tail moves to tail.prev (30) ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐ │ data:10│ │ data:20│ │ data:30│ │ data:40│ │ prev:∅ │←── │ prev:10│←── │ prev:20│←── │ prev:30│ │ next:20│──→ │ next:30│──→ │ next:40│──→ │ next:∅ │ └────────┘ └────────┘ └────────┘ └────────┘ head tail (old)
3	Set tail.next = null to remove last node	10 <-> 20 <-> 30	tail.next (30.next) set to null, 40 disconnected	Step 3: tail.next = null ┌────────┐ ┌────────┐ ┌────────┐ │ data:10│ │ data:20│ │ data:30│ │ prev:∅ │←── │ prev:10│←── │ prev:20│ │ next:20│──→ │ next:30│──→ │ next:∅ │ └────────┘ └────────┘ └────────┘ head tail
4	End of deletion	10 <-> 20 <-> 30	tail points to 30, 40 removed	Final list: ┌────────┐ ┌────────┐ ┌────────┐ │ data:10│ │ data:20│ │ data:30│ │ prev:∅ │←── │ prev:10│←── │ prev:20│ │ next:20│──→ │ next:30│──→ │ next:∅ │ └────────┘ └────────┘ └────────┘ head tail
5	Delete from end when only one node (10)	10	head and tail set to null	Step 5: single node list ┌────────┐ │ data:10│ │ prev:∅ │ │ next:∅ │ └────────┘ head & tail After deletion: List is empty (head=null, tail=null)
6	Delete from end when list empty	empty	No change	List is empty (head=null, tail=null), nothing to delete

💡 Deletion stops when tail is null (empty list) or after tail.next is set to null removing last node

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6
head	Node(10)	Node(10)	Node(10)	Node(10)	null	null
tail	Node(40)	Node(30)	Node(30)	Node(30)	null	null
tail.next	null	Node(40)	null	null	null	null
list size	4	4	3	3	1 to 0	0

Key Moments - 3 Insights

Why do we set tail.next to null after moving tail to tail.prev?

Setting tail.next to null removes the reference to the old last node, effectively disconnecting it from the list as shown in execution_table step 3.

What happens if the list has only one node when deleting from end?

As shown in step 5, both head and tail are set to null, making the list empty.

Why do we check if tail is null at the start?

Because if tail is null, the list is empty and there is nothing to delete, so we stop immediately (step 6).

Visual Quiz - 3 Questions

Look at the execution_table, what is the tail node after step 2?

A Node with data 20

B Node with data 40

C Node with data 30

D null

💡 Hint

Check the 'Pointer Changes' column in step 2 where tail moves from 40 to 30.

At which step does the list size reduce from 4 to 3?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at variable_tracker row 'list size' and see when it changes from 4 to 3.

If the list has only one node, what happens to head and tail after deletion?

A Both head and tail become null

B head points to the node, tail is null

C tail points to the node, head is null

D No change

💡 Hint

Refer to execution_table step 5 and key_moments about single node deletion.

Concept Snapshot

Delete from End of Doubly Linked List:
- If list empty (tail == null), do nothing.
- If only one node, set head = tail = null.
- Else move tail to tail.prev.
- Set tail.next = null to disconnect last node.
- List size decreases by one.

Full Transcript

Deleting from the end of a doubly linked list involves starting at the tail node. If the list is empty, no action is taken. If there is only one node, both head and tail pointers are set to null, making the list empty. Otherwise, the tail pointer moves to the previous node, and the next pointer of the new tail is set to null to disconnect the old last node. This process reduces the list size by one. The execution steps show the pointer changes and how the list nodes are connected before and after deletion.

Practice

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

easy

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

B. The head pointer is set to null.

C. The list becomes circular.

D. The first node is deleted instead.

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, making it the new tail.

3. Final Answer:

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

4. Quick Check:

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

Hint: Tail's previous node next pointer becomes 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 Java code snippets correctly deletes the last node from a doubly linked list named dll?

easy

A. dll.tail.next = dll.tail.prev; dll.tail = null;

B. dll.head = dll.head.next; dll.head.prev = null;

C. dll.tail = dll.tail.prev; dll.tail.next = null;

D. dll.head.prev = dll.tail; dll.tail = dll.tail.next;

Solution

1. Step 1: Move tail pointer to previous node

   Set dll.tail to dll.tail.prev to remove last node reference.

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

   Update dll.tail.next to null to mark end of list.

3. Final Answer:

   dll.tail = dll.tail.prev; dll.tail.next = null; -> Option C

4. Quick Check:

   Correct tail update and next pointer null [OK]

Hint: Tail moves back, next pointer set to null [OK]

Common Mistakes:

• Updating head instead of tail
• Setting tail to null without updating pointers
• Confusing next and prev pointers

3. Consider the following Java code for deleting the last node from a doubly linked list:

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

class DoublyLinkedList {
  Node head, tail;

  void deleteFromEnd() {
    if (tail == null) return;
    if (head == tail) {
      head = tail = null;
      return;
    }
    tail = tail.prev;
    tail.next = null;
  }
}

DoublyLinkedList dll = new DoublyLinkedList();
dll.head = new Node(1);
Node second = new Node(2);
dll.head.next = second;
second.prev = dll.head;
dll.tail = second;
dll.deleteFromEnd();
System.out.println(dll.head.data + " -> " + (dll.head.next == null ? "null" : dll.head.next.data));

What is the output?

medium

A. 1 -> 2

B. null -> null

C. 2 -> null

D. 1 -> null

Solution

1. Step 1: Setup list with two nodes 1 and 2

   Head points to node 1, tail points to node 2, linked properly.

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

   Tail moves to node 1, tail.next set to null, removing node 2.

3. Final Answer:

   1 -> null -> Option D

4. Quick Check:

   After deletion, only node 1 remains with next null [OK]

Hint: After deleting tail, tail.prev.next is null [OK]

Common Mistakes:

• Printing old tail node data
• Not updating tail.next to null
• Confusing head and tail pointers

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

void deleteFromEnd() {
  if (tail == null) return;
  tail = tail.prev;
  tail.next = null;
}

What is the error and how to fix it?

medium

A. Compilation error due to missing semicolon; fix by adding semicolon.

B. NullPointerException when list has one node; fix by checking if tail.prev is null.

C. Logical error deleting head instead of tail; fix by updating head pointer.

D. No error; code works fine.

Solution

1. Step 1: Identify cause of NullPointerException

   If list has one node, tail.prev is null, so tail becomes null, then tail.next causes error.

2. Step 2: Fix by checking single node case

   Add condition: if head == tail, set head and tail to null before updating pointers.

3. Final Answer:

   NullPointerException when list has one node; fix by checking if tail.prev is null. -> Option B

4. Quick Check:

   Check single node case before pointer update [OK]

Hint: Check if tail.prev is null before accessing tail.next [OK]

Common Mistakes:

• Not handling single node list
• Assuming tail.prev always exists
• Ignoring null pointer exceptions

5. You have a doubly linked list with nodes: 10 <-> 20 <-> 30 <-> 40. After deleting the last node twice using the correct deleteFromEnd method, what is the final list?

hard

A. 10 <-> 20

B. 10 <-> 20 <-> 30

C. 20 <-> 30

D. 30 <-> 40

Solution

1. Step 1: Delete last node once

   Deleting last node 40 removes it; list becomes 10 <-> 20 <-> 30.

2. Step 2: Delete last node second time

   Deleting last node 30 removes it; list becomes 10 <-> 20.

3. Final Answer:

   10 <-> 20 -> Option A

4. Quick Check:

   Two deletions remove last two nodes [OK]

Hint: Each deleteFromEnd removes tail node [OK]

Common Mistakes:

• Deleting from head instead of tail
• Not updating tail pointer after deletion
• Confusing node values after deletion