Dequeue Operation in DSA Go - Build from Scratch

Dequeue Operation

📖 Scenario: Imagine you are managing a line of customers waiting for service. Sometimes customers leave from the front or the back of the line. You want to keep track of the line using a double-ended queue (deque) so you can add or remove customers from both ends easily.

🎯 Goal: You will create a deque with some customers, set up a variable to track how many customers to remove, remove that many customers from the front, and then print the remaining customers in the deque.

📋 What You'll Learn

Create a deque with exact customers: "Alice", "Bob", "Charlie", "Diana", "Ethan"

Create a variable called removeCount with the value 2

Remove removeCount customers from the front of the deque

Print the remaining customers in the deque separated by -> and ending with -> null

💡 Why This Matters

🌍 Real World

Deques are useful in real life for managing lines or queues where people can join or leave from both ends, like waiting lines or task scheduling.

💼 Career

Understanding deque operations is important for software developers working on systems that require flexible data structures for efficient insertion and removal, such as web servers, real-time systems, and user interface event handling.

1

Create the initial deque

Create a slice of strings called deque with these exact customers in order: "Alice", "Bob", "Charlie", "Diana", "Ethan"

DSA Go

# Create the deque with the customers
# Your code here

Hint

Use a slice of strings to represent the deque. Write deque := []string{"Alice", "Bob", "Charlie", "Diana", "Ethan"}.

2

Set the number of customers to remove

Create an integer variable called removeCount and set it to 2

DSA Go

package main

import "fmt"

func main() {
    deque := []string{"Alice", "Bob", "Charlie", "Diana", "Ethan"}
    // Set how many customers to remove
    // Your code here
}

Hint

Write removeCount := 2 to set the number of customers to remove.

3

Remove customers from the front of the deque

Remove removeCount customers from the front of the deque by slicing it

DSA Go

package main

import "fmt"

func main() {
    deque := []string{"Alice", "Bob", "Charlie", "Diana", "Ethan"}
    removeCount := 2
    // Remove customers from the front
    // Your code here
}

Hint

Use slicing to remove the first removeCount elements: deque = deque[removeCount:].

4

Print the remaining deque

Print the remaining customers in deque separated by -> and ending with -> null

DSA Go

package main

import "fmt"

func main() {
    deque := []string{"Alice", "Bob", "Charlie", "Diana", "Ethan"}
    removeCount := 2
    deque = deque[removeCount:]
    // Print the deque
    // Your code here
}

Hint

Use a for loop to print each customer followed by -> , and after the last customer print -> null.

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