Dequeue Operation in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Dequeue Push and Pop Operations

What is the printed state of the dequeue after the following operations?

DSA Go

package main

import (
	"container/list"
	"fmt"
)

func main() {
	dq := list.New()
	dq.PushBack(10)
	dq.PushFront(20)
	dq.PushBack(30)
	dq.Remove(dq.Front())

	for e := dq.Front(); e != nil; e = e.Next() {
		fmt.Print(e.Value, " -> ")
	}
	fmt.Print("null")
}

A 20 -> 30 -> null

B 20 -> 10 -> 30 -> null

C 30 -> 10 -> null

D 10 -> 30 -> null

💡 Hint

Remember that PushFront adds to the front and Remove removes the element passed.

Initially, 10 is added at back, then 20 at front, then 30 at back. The dequeue looks like: 20 -> 10 -> 30. Removing the front element (20) leaves 10 -> 30.

❓ Predict Output

intermediate

Result of Removing from Empty Dequeue

What happens when you try to remove an element from an empty dequeue using Go's container/list?

DSA Go

package main

import (
	"container/list"
	"fmt"
)

func main() {
	dq := list.New()
	removed := dq.Remove(dq.Front())
	fmt.Println(removed)
}

A <nil>

B empty string

C 0

D panic: runtime error: invalid memory address or nil pointer dereference

💡 Hint

Check what dq.Front() returns when the list is empty.

If the list is empty, dq.Front() returns nil. Removing nil returns nil without panic.

🔧 Debug

advanced

Identify the Bug in Dequeue Push and Remove

What error does the following code produce when run?

DSA Go

package main

import (
	"container/list"
	"fmt"
)

func main() {
	dq := list.New()
	dq.PushBack(1)
	dq.PushBack(2)
	dq.PushFront(3)
	dq.Remove(dq.Back())
	dq.Remove(dq.Back())
	dq.Remove(dq.Back())
	dq.Remove(dq.Back())

	for e := dq.Front(); e != nil; e = e.Next() {
		fmt.Print(e.Value, " -> ")
	}
	fmt.Print("null")
}

A null

B 0 -> null

C 3 -> 1 -> null

D panic: runtime error: invalid memory address or nil pointer dereference

💡 Hint

Consider what happens when you remove elements more times than the dequeue has.

Removing elements until the dequeue is empty leaves no elements. Removing from empty returns nil and does nothing. The final print shows just "null".

🧠 Conceptual

advanced

Time Complexity of Dequeue Operations

What is the time complexity of adding or removing an element from either end of a dequeue implemented with Go's container/list?

A O(n) for adding at front, O(1) for removing at back

B O(1) for both adding and removing at either end

C O(log n) for adding and removing at either end

D O(n) for both adding and removing at either end

💡 Hint

Think about how linked lists work for insertions and deletions at ends.

Go's container/list is a doubly linked list. Adding or removing at front or back is done in constant time O(1).

🚀 Application

expert

Final State of Dequeue After Mixed Operations

Given the following sequence of operations on a dequeue, what is the final printed state?

DSA Go

package main

import (
	"container/list"
	"fmt"
)

func main() {
	dq := list.New()
	dq.PushBack(5)
	dq.PushFront(10)
	dq.PushBack(15)
	dq.Remove(dq.Front())
	dq.PushFront(20)
	dq.Remove(dq.Back())
	dq.PushBack(25)

	for e := dq.Front(); e != nil; e = e.Next() {
		fmt.Print(e.Value, " -> ")
	}
	fmt.Print("null")
}

A 20 -> 15 -> 25 -> null

B 10 -> 5 -> 25 -> null

C 20 -> 5 -> 25 -> null

D 5 -> 15 -> 25 -> null

💡 Hint

Track each operation step-by-step to see how the dequeue changes.

Operations step-by-step:
PushBack(5): 5
PushFront(10): 10 -> 5
PushBack(15): 10 -> 5 -> 15
Remove Front (10): 5 -> 15
PushFront(20): 20 -> 5 -> 15
Remove Back (15): 20 -> 5
PushBack(25): 20 -> 5 -> 25

Practice

1. What is a dequeue in data structures?

easy

A. A double-ended queue allowing insertion and deletion at both ends

B. A queue that only allows insertion at the rear and deletion at the front

C. A stack that allows insertion and deletion only at one end

D. A list that only supports random access

Solution

1. Step 1: Understand the definition of dequeue

   A dequeue is a data structure where elements can be added or removed from both the front and the rear ends.

2. Step 2: Compare with other data structures

   Unlike a queue or stack, which restrict operations to one end, dequeue supports both ends.

3. Final Answer:

   A double-ended queue allowing insertion and deletion at both ends -> Option A

4. Quick Check:

   Dequeue = double-ended queue [OK]

Hint: Remember: Dequeue means double-ended queue [OK]

Common Mistakes:

• Confusing dequeue with stack or simple queue
• Thinking dequeue only allows operations at one end
• Mixing dequeue with random access lists

2. Which of the following is the correct Go syntax to create an empty dequeue using a slice?

easy

A. var dq []int = make([]int, 0)

B. dq := []int{nil}

C. var dq int = []{}

D. dq := make([]int, -1)

Solution

1. Step 1: Understand slice creation in Go

   To create an empty slice, use make with length 0, like make([]int, 0).

2. Step 2: Check each option

   var dq []int = make([]int, 0) correctly creates an empty int slice. dq := []int{nil} uses nil inside slice literal which is invalid. var dq int = []{} has wrong type assignment. dq := make([]int, -1) tries negative length which is invalid.

3. Final Answer:

   var dq []int = make([]int, 0) -> Option A

4. Quick Check:

   Empty slice = make([]int, 0) [OK]

Hint: Use make([]type, 0) for empty slices in Go [OK]

Common Mistakes:

• Using nil inside slice literal
• Assigning wrong types
• Using negative length in make

3. What will be the output of the following Go code snippet simulating dequeue operations?

package main
import "fmt"
func main() {
  dq := []int{10, 20, 30}
  // Remove from front
  dq = dq[1:]
  // Add 40 at rear
  dq = append(dq, 40)
  fmt.Println(dq)
}

medium

A. [40 20 30]

B. [10 20 30 40]

C. [20 30 40]

D. [30 40]

Solution

1. Step 1: Remove element from front

   dq = dq[1:] removes the first element (10), so dq becomes [20, 30].

2. Step 2: Add element at rear

   append(dq, 40) adds 40 at the end, so dq becomes [20, 30, 40].

3. Final Answer:

   [20 30 40] -> Option C

4. Quick Check:

   Remove front + append rear = [20 30 40] [OK]

Hint: Slice from 1 removes front; append adds rear [OK]

Common Mistakes:

• Forgetting slice removes front element
• Appending at wrong position
• Misreading slice syntax

4. Identify the error in the following Go code that tries to remove an element from the rear of a dequeue represented by a slice:

package main
import "fmt"
func main() {
  dq := []int{5, 10, 15}
  dq = dq[:len(dq)]
  fmt.Println(dq)
}

medium

A. No error; code correctly removes rear element

B. Runtime panic due to invalid slice bounds

C. Syntax error in slice expression

D. Slice operation does not remove last element; length unchanged

Solution

1. Step 1: Analyze slice operation dq[:len(dq)]

   This slice keeps all elements from start to length, so no element is removed.

2. Step 2: Understand how to remove last element

   To remove last element, slice should be dq[:len(dq)-1].

3. Final Answer:

   Slice operation does not remove last element; length unchanged -> Option D

4. Quick Check:

   dq[:len(dq)] keeps all elements [OK]

Hint: Use dq[:len(dq)-1] to remove last element [OK]

Common Mistakes:

• Using dq[:len(dq)] expecting removal
• Off-by-one errors in slicing
• Confusing slice length with index

5. Given a dequeue implemented as a slice in Go, which sequence of operations will correctly remove an element from the front and add an element at the front, resulting in [99 30 40] from initial [20 30 40]? Choose the correct code snippet:

package main
import "fmt"
func main() {
  dq := []int{20, 30, 40}
  // Your code here
  fmt.Println(dq)
}

hard

A. dq = append(dq, 99)
dq = dq[1:]

B. dq = dq[1:]
dq = append([]int{99}, dq...)

C. dq = append(dq, 99)
dq = append([]int{99}, dq...)

D. dq = dq[:len(dq)-1]
dq = append([]int{99}, dq...)

Solution

1. Step 1: Remove element from front

   dq = dq[1:] removes the first element (20), so dq becomes [30, 40].

2. Step 2: Add 99 at front

   dq = append([]int{99}, dq...) adds 99 at the front, resulting in [99, 30, 40].

3. Step 3: Verify final slice

   After these operations, dq is [99, 30, 40], which matches the expected result.

4. Final Answer:

   dq = dq[1:] dq = append([]int{99}, dq...) -> Option B

5. Quick Check:

   Remove front + add front = dq = dq[1:] dq = append([]int{99}, dq...) [OK]

Hint: Add front with append([]int{val}, dq...) [OK]

Common Mistakes:

• Removing wrong element before adding front
• Appending at rear instead of front
• Confusing slice operations order