Delete from Beginning of Doubly Linked List in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after deleting the first node from a doubly linked list

What is the printed state of the doubly linked list after deleting the first node?

DSA Go

package main

import "fmt"

type Node struct {
	data int
	prev *Node
	next *Node
}

type DoublyLinkedList struct {
	head *Node
}

func (dll *DoublyLinkedList) InsertEnd(data int) {
	newNode := &Node{data: data}
	if dll.head == nil {
		dll.head = newNode
		return
	}
	current := dll.head
	for current.next != nil {
		current = current.next
	}
	current.next = newNode
	newNode.prev = current
}

func (dll *DoublyLinkedList) DeleteBeginning() {
	if dll.head == nil {
		return
	}
	if dll.head.next == nil {
		dll.head = nil
		return
	}
	dll.head = dll.head.next
	dll.head.prev = nil
}

func (dll *DoublyLinkedList) PrintList() {
	current := dll.head
	for current != nil {
		fmt.Printf("%d <-> ", current.data)
		current = current.next
	}
	fmt.Println("null")
}

func main() {
	dll := DoublyLinkedList{}
	dll.InsertEnd(10)
	dll.InsertEnd(20)
	dll.InsertEnd(30)
	dll.DeleteBeginning()
	dll.PrintList()
}

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

B null

C 30 <-> null

D 20 <-> 30 <-> null

💡 Hint

Deleting the first node means the head moves to the next node.

Initially, the list is 10 <-> 20 <-> 30 <-> null.

After deleting the first node (10), the head points to 20.

So the list becomes 20 <-> 30 <-> null.

❓ Predict Output

intermediate

Result after deleting from a single-node doubly linked list

What is the output after deleting the first node from a doubly linked list with only one node?

DSA Go

package main

import "fmt"

type Node struct {
	data int
	prev *Node
	next *Node
}

type DoublyLinkedList struct {
	head *Node
}

func (dll *DoublyLinkedList) InsertEnd(data int) {
	newNode := &Node{data: data}
	if dll.head == nil {
		dll.head = newNode
		return
	}
	current := dll.head
	for current.next != nil {
		current = current.next
	}
	current.next = newNode
	newNode.prev = current
}

func (dll *DoublyLinkedList) DeleteBeginning() {
	if dll.head == nil {
		return
	}
	if dll.head.next == nil {
		dll.head = nil
		return
	}
	dll.head = dll.head.next
	dll.head.prev = nil
}

func (dll *DoublyLinkedList) PrintList() {
	current := dll.head
	for current != nil {
		fmt.Printf("%d <-> ", current.data)
		current = current.next
	}
	fmt.Println("null")
}

func main() {
	dll := DoublyLinkedList{}
	dll.InsertEnd(100)
	dll.DeleteBeginning()
	dll.PrintList()
}

A Error: nil pointer dereference

B 100 <-> null

C null

D 100

💡 Hint

Deleting the only node should leave the list empty.

With only one node (100), deleting the beginning sets head to nil.

Printing the list shows null.

🔧 Debug

advanced

Identify the error in DeleteBeginning method

What error will this code produce when deleting from an empty doubly linked list?

DSA Go

func (dll *DoublyLinkedList) DeleteBeginning() {
	dll.head = dll.head.next
	dll.head.prev = nil
}

A No error, deletes correctly

B runtime error: invalid memory address or nil pointer dereference

C Syntax error: missing if statement

D Compile error: cannot assign to dll.head

💡 Hint

Check what happens if dll.head is nil before accessing dll.head.next.

If dll.head is nil, accessing dll.head.next causes a runtime nil pointer dereference error.

🧠 Conceptual

advanced

Effect of DeleteBeginning on doubly linked list pointers

After deleting the first node from a doubly linked list, which pointers must be updated to maintain list integrity?

A Head pointer moves to next node; new head's prev pointer set to nil

B Tail pointer moves to previous node; new tail's next pointer set to nil

C Head pointer moves to previous node; new head's next pointer set to nil

D Tail pointer moves to next node; new tail's prev pointer set to nil

💡 Hint

Deleting from beginning affects the head and its previous pointer.

Deleting the first node means head moves to the next node.

The new head's prev pointer must be nil to indicate start of list.

🚀 Application

expert

Number of nodes after multiple deletions from beginning

Given a doubly linked list with nodes 5 <-> 15 <-> 25 <-> 35 <-> 45 <-> null, after deleting from the beginning three times, how many nodes remain?

A 2

B 3

C 4

D 1

💡 Hint

Each deletion removes one node from the start.

Starting with 5 nodes, deleting 3 nodes from beginning leaves 2 nodes.

Practice

1. What happens to the head pointer when you delete the first node from a doubly linked list?

easy

A. It moves to the second node in the list

B. It becomes null immediately

C. It points to the last node

D. It remains unchanged

Solution

1. Step 1: Understand the head pointer role

   The head pointer always points to the first node in the list.

2. Step 2: Effect of deleting the first node

   When the first node is deleted, the head pointer must move to the next node, which becomes the new first node.

3. Final Answer:

   It moves to the second node in the list -> Option A

4. Quick Check:

   Head points to new first node after deletion [OK]

Hint: Head always points to the first node [OK]

Common Mistakes:

• Thinking head becomes null without checking list emptiness
• Assuming head points to last node after deletion
• Not updating head pointer after deletion

2. Which of the following Go code snippets correctly deletes the first node from a doubly linked list named dll?

easy

A. dll.head.prev = nil; dll.head = dll.head.next

B. dll.head = dll.head.next; if dll.head != nil { dll.head.prev = nil }

C. dll.head.next.prev = nil; dll.head = dll.head.next

D. dll.head = nil; dll.tail = nil

Solution

1. Step 1: Move head to next node

   Set dll.head = dll.head.next to remove first node reference.

2. Step 2: Update new head's prev pointer

   If new head exists, set dll.head.prev = nil to detach backward link.

3. Final Answer:

   dll.head = dll.head.next; if dll.head != nil { dll.head.prev = nil } -> Option B

4. Quick Check:

   Correct pointer updates for deletion [OK]

Hint: Update head then clear new head's prev [OK]

Common Mistakes:

• Setting prev pointer before moving head
• Not checking if new head is nil
• Clearing head and tail without condition

3. Given the following doubly linked list with nodes 10 <-> 20 <-> 30, what will be the list after deleting the first node?

type Node struct {
  data int
  prev *Node
  next *Node
}

head := &Node{data: 10}
second := &Node{data: 20}
third := &Node{data: 30}
head.next = second
second.prev = head
second.next = third
third.prev = second

// Delete from beginning
head = head.next
head.prev = nil

// Print list
curr := head
for curr != nil {
  fmt.Print(curr.data)
  if curr.next != nil {
    fmt.Print(" <-> ")
  }
  curr = curr.next
}

medium

A. 20 <-> 30

B. 10 <-> 20 <-> 30

C. 30

D. nil

Solution

1. Step 1: Initial list setup

   List is 10 <-> 20 <-> 30 with head at 10.

2. Step 2: Delete first node

   Head moves to 20, and 20's prev is set to nil, detaching 10.

3. Final Answer:

   20 <-> 30 -> Option A

4. Quick Check:

   First node removed, list starts at 20 [OK]

Hint: Head moves to next, prev cleared [OK]

Common Mistakes:

• Not clearing prev pointer of new head
• Printing old head node
• Confusing next and prev pointers

4. Identify the error in this Go code snippet that tries to delete the first node from a doubly linked list:

if dll.head != nil {
  dll.head = dll.head.next
  dll.head.prev = nil
}

medium

A. It should assign dll.head.prev to dll.head.next

B. It should set dll.head.next.prev to nil instead

C. No error, code is correct

D. It does not check if dll.head.next is nil before accessing prev

Solution

1. Step 1: Check condition before accessing pointers

   The code moves head to next node without checking if next node exists.

2. Step 2: Accessing prev of nil causes runtime error

   If dll.head.next is nil, then dll.head becomes nil and accessing dll.head.prev causes panic.

3. Final Answer:

   It does not check if dll.head.next is nil before accessing prev -> Option D

4. Quick Check:

   Always check for nil before pointer access [OK]

Hint: Check nil before accessing pointers [OK]

Common Mistakes:

• Assuming next node always exists
• Not handling empty list after deletion
• Confusing prev and next pointers

5. You have a doubly linked list with nodes 5 <-> 15. You want to delete the first node and then insert a new node with value 10 at the beginning. Which sequence of operations correctly updates the list?

hard

A. Delete first node by moving head to next; create new node with prev = head, next = nil; set head.next to new node

B. Delete first node by setting head to nil; create new node with next = nil, prev = nil; set head to new node

C. Delete first node by moving head to next and clearing prev; then create new node with next = head, prev = nil; update head.prev to new node; finally set head to new node

D. Delete first node by moving head to next; create new node with next = nil, prev = nil; set head to new node

Solution

1. Step 1: Delete first node properly

   Move head to next node and set new head's prev to nil to detach old first node.

2. Step 2: Insert new node at beginning

   Create new node with next pointing to current head and prev nil; update current head's prev to new node; update head pointer to new node.

3. Final Answer:

   Delete first node by moving head to next and clearing prev; then create new node with next = head, prev = nil; update head.prev to new node; finally set head to new node -> Option C

4. Quick Check:

   Proper delete then insert at head [OK]

Hint: Delete then insert by updating head and pointers [OK]

Common Mistakes:

• Not updating prev pointer of old head after insertion
• Setting new node's prev incorrectly
• Overwriting head without linking new node