Bird
Raised Fist0
DSA Goprogramming~5 mins

Double Ended Queue Deque in DSA Go - Time & Space Complexity

Choose your learning style10 modes available
LearnWhyDeepVisualTryChallengeProjectRecallTime
Time Complexity: Double Ended Queue Deque
O(n)
Understanding Time Complexity

We want to understand how fast operations on a double ended queue (deque) run as the number of items grows.

Specifically, how adding or removing items from either end scales with size.

Scenario Under Consideration

Analyze the time complexity of the following deque operations.


// Simple deque operations
func (d *Deque) PushFront(value int) {
    d.data = append([]int{value}, d.data...)
}

func (d *Deque) PopBack() int {
    val := d.data[len(d.data)-1]
    d.data = d.data[:len(d.data)-1]
    return val
}

This code adds an item to the front and removes an item from the back of a deque implemented with a slice.

Identify Repeating Operations

Look at what repeats when these operations run.

  • Primary operation: Adding to front requires shifting all existing items to the right.
  • How many times: For PushFront, it moves all n items once each time.
  • PopBack: Removes last item directly, no shifting needed.
How Execution Grows With Input

Adding to front means moving all existing items, so work grows with number of items.

Input Size (n)Approx. Operations for PushFront
1010 moves
100100 moves
10001000 moves

Pattern observation: The work grows linearly as the deque gets bigger.

Final Time Complexity

Time Complexity: O(n) for PushFront, O(1) for PopBack

This means adding to the front takes longer as the deque grows, but removing from the back stays fast.

Common Mistake

[X] Wrong: "Adding to front is always fast like adding to back."

[OK] Correct: Because adding to front shifts all items, it takes more time as size grows, unlike adding to back which just appends.

Interview Connect

Understanding these differences helps you explain trade-offs in data structures clearly and shows you know how operations scale.

Self-Check

"What if we used a linked list instead of a slice for the deque? How would the time complexity change?"

Practice

(1/5)
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
Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard