Double Ended Queue Deque in DSA Go - Execution Trace

Concept Flow - Double Ended Queue Deque

Start

↓

Check Operation Type

↓

Add Front

↓

Update Pointers

↓

Add Node at Front or Rear

↓

Check Remove Operation

↓

Remove Front

↓

Update Pointers

↓

Return Value or Empty

↓

End

The deque allows adding or removing nodes from both front and rear ends by updating pointers accordingly.

Execution Sample

DSA Go

deque := NewDeque()
deque.AddRear(10)
deque.AddFront(20)
deque.RemoveRear()
deque.RemoveFront()

This code creates a deque, adds 10 at rear, adds 20 at front, then removes from rear and front.

Execution Table

Step	Operation	Nodes in List	Pointer Changes	Visual State
1	Create empty deque	[]	head = nil, tail = nil	null
2	AddRear(10)	[10]	head = node(10), tail = node(10)	10 -> null
3	AddFront(20)	[20, 10]	head = node(20), tail = node(10), node(20).next = node(10)	20 -> 10 -> null
4	RemoveRear()	[20]	tail = node(20), node(20).next = nil	20 -> null
5	RemoveFront()	[]	head = nil, tail = nil	null

💡 Deque is empty after last removal, head and tail pointers are nil.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5
head	nil	node(10)	node(20)	node(20)	nil
tail	nil	node(10)	node(10)	node(20)	nil
size	0	1	2	1	0

Key Moments - 3 Insights

Why does adding at front update head but not tail?

Because the new node becomes the first element, head points to it, but tail remains the last node as shown in step 3 of execution_table.

What happens to pointers when deque becomes empty after removals?

Both head and tail are set to nil to indicate the deque is empty, as seen in step 5 of execution_table.

Why do we update node(20).next to nil after removing rear?

To disconnect the removed node and mark the new tail's next as nil, ensuring no dangling references, shown in step 4.

Visual Quiz - 3 Questions

Look at the execution_table, what is the visual state after step 3?

A 20 -> 10 -> null

B 10 -> 20 -> null

C 20 -> null

D null

💡 Hint

Check the Visual State column for step 3 in execution_table.

At which step does the deque become empty?

A Step 2

B Step 5

C Step 3

D Step 4

💡 Hint

Look for empty Nodes in List and null pointers in execution_table.

If we add AddFront(30) after step 5, what will be the head and tail?

A head = node(20), tail = node(10)

B head = nil, tail = nil

C head = node(30), tail = node(30)

D head = node(10), tail = node(30)

💡 Hint

After empty deque, adding one node sets both head and tail to that node.

Concept Snapshot

Double Ended Queue (Deque):
- Supports adding/removing at both front and rear.
- head points to front, tail points to rear.
- AddFront: new node becomes head.
- AddRear: new node becomes tail.
- RemoveFront/RemoveRear update pointers accordingly.
- Empty deque: head and tail are nil.

Full Transcript

A double ended queue or deque allows insertion and deletion from both ends. We start with an empty deque where head and tail pointers are nil. Adding at rear when empty sets both head and tail to the new node. Adding at front updates head to new node and links it to previous head. Removing from rear updates tail pointer and disconnects the removed node. Removing from front updates head pointer. When all nodes are removed, both head and tail become nil indicating empty deque. This structure allows flexible queue operations from both ends efficiently.

Practice

1. What is a Double Ended Queue (Deque)?

easy

A. A data structure where elements can be added or removed from both ends

B. A queue where elements can only be added at the rear

C. A stack where elements can only be added or removed from the top

D. A list that allows random access to elements

Solution

1. Step 1: Understand the definition of Deque

   A Deque allows insertion and deletion from both front and rear ends, unlike a queue or stack.

2. Step 2: Compare with other data structures

   Queue allows insertion at rear and deletion at front; stack allows insertion and deletion only at one end.

3. Final Answer:

   A data structure where elements can be added or removed from both ends -> Option A

4. Quick Check:

   Deque = double-ended queue [OK]

Hint: Deque means double-ended queue, both ends usable [OK]

Common Mistakes:

• Confusing deque with stack or queue
• Thinking deque allows random access
• Assuming insertion only at one end

2. Which of the following is the correct way to declare a deque using Go's container/list package?

easy

A. var d []int

B. d := list.New()

C. d := make(deque, 0)

D. var d map[int]int

Solution

1. Step 1: Recall Go's deque implementation

   Go does not have a built-in deque type but container/list can be used as a double-ended queue.

2. Step 2: Check syntax for creating a new list

   list.New() returns a pointer to a new doubly linked list, suitable for deque operations.

3. Final Answer:

   d := list.New() -> Option B

4. Quick Check:

   Use list.New() for deque in Go [OK]

Hint: Use list.New() to create a deque in Go [OK]

Common Mistakes:

• Using slice instead of list for deque
• Trying to make a deque type directly
• Confusing map with deque

3. What will be the output of the following Go code using container/list as a deque?

package main
import (
  "container/list"
  "fmt"
)
func main() {
  d := list.New()
  d.PushBack(10)
  d.PushFront(20)
  d.PushBack(30)
  for e := d.Front(); e != nil; e = e.Next() {
    fmt.Print(e.Value, " ")
  }
}

medium

A. 30 10 20

B. 10 20 30

C. 20 10 30

D. 20 30 10

Solution

1. Step 1: Trace the Push operations on deque

   PushBack(10) adds 10 at rear; PushFront(20) adds 20 at front; PushBack(30) adds 30 at rear.

2. Step 2: Traverse from front to back

   Elements order: 20 (front), 10 (middle), 30 (rear).

3. Final Answer:

   20 10 30 -> Option C

4. Quick Check:

   Front to back traversal = 20 10 30 [OK]

Hint: PushFront adds front, PushBack adds rear [OK]

Common Mistakes:

• Mixing order of PushFront and PushBack
• Assuming PushBack adds to front
• Confusing traversal direction

4. Identify the error in this Go code snippet using container/list as a deque:

package main
import (
  "container/list"
  "fmt"
)
func main() {
  d := list.New()
  d.PushFront(1)
  d.Remove(d.Back())
  fmt.Println(d.Back().Value)
}

medium

A. Using PushFront instead of PushBack

B. Not initializing the list with make()

C. Printing d.Back().Value without converting to string

D. Calling Remove on d.Back() before checking if d.Back() is nil

Solution

1. Step 1: Understand Remove and Back usage

   d.Remove(d.Back()) removes the last element; after removal, d.Back() may be nil if list is empty.

2. Step 2: Check the print statement

   fmt.Println(d.Back().Value) accesses Value of d.Back() without checking if d.Back() is nil, causing runtime panic if nil.

3. Final Answer:

   Calling Remove on d.Back() before checking if d.Back() is nil -> Option D

4. Quick Check:

   Check nil before accessing Back() after Remove [OK]

Hint: Check nil after Remove before accessing Back() [OK]

Common Mistakes:

• Ignoring nil check after removal
• Confusing PushFront and PushBack
• Thinking fmt.Println needs string conversion

5. You want to implement a sliding window maximum using a deque in Go. Which deque operation sequence correctly maintains the window elements in decreasing order from front to rear?

// Assume d is a deque of indices
for i := 0; i < len(nums); i++ {
  for d.Len() > 0 && nums[d.Back().Value.(int)] <= nums[i] {
    d.Remove(d.Back())
  }
  d.PushBack(i)
  if d.Front().Value.(int) <= i - k {
    d.Remove(d.Front())
  }
}

hard

A. Remove from back while current element is greater or equal, then add current index at back

B. Remove from front while current element is smaller, then add current index at front

C. Add current index at front without removals

D. Remove from back while current element is smaller, then add current index at front

Solution

1. Step 1: Understand sliding window max logic

   We remove smaller or equal elements from back to keep deque decreasing, then add current index at back.

2. Step 2: Remove indices out of window from front

   If front index is out of current window (i - k), remove it from front to maintain window size.

3. Final Answer:

   Remove from back while current element is greater or equal, then add current index at back -> Option A

4. Quick Check:

   Sliding window max uses back removals and back insertions [OK]

Hint: Remove smaller from back, add new at back for max window [OK]

Common Mistakes:

• Removing from front instead of back for smaller elements
• Adding new elements at front incorrectly
• Not removing out-of-window indices