Peek Front Element of Queue in DSA Go

Mental Model

A queue is like a line where the first person in is the first person out. Peeking means looking at the first person without removing them.

Analogy: Imagine waiting in line at a coffee shop. Peeking is like glancing at the person at the front of the line to see who is next without letting them leave the line.

front -> [1] -> 2 -> 3 -> null
          ↑peek

Dry Run Walkthrough

Input: queue: 1 -> 2 -> 3, peek front element

Goal: See the front element without removing it

Step 1: Check if queue is empty

front -> [1] -> 2 -> 3 -> null
          ↑peek

Why: We must ensure there is an element to peek at

Step 2: Return the value at the front node

front -> [1] -> 2 -> 3 -> null
          ↑peek

Why: Peeking means looking at the front value without removing it

Result:

front -> [1] -> 2 -> 3 -> null
peeked value = 1

Annotated Code

DSA Go

package main

import (
	"fmt"
	"errors"
)

type Node struct {
	value int
	next  *Node
}

type Queue struct {
	front *Node
	rear  *Node
}

func (q *Queue) Enqueue(val int) {
	node := &Node{value: val}
	if q.rear == nil {
		q.front = node
		q.rear = node
		return
	}
	q.rear.next = node
	q.rear = node
}

func (q *Queue) Peek() (int, error) {
	if q.front == nil {
		return 0, errors.New("queue is empty")
	}
	return q.front.value, nil
}

func main() {
	q := &Queue{}
	q.Enqueue(1)
	q.Enqueue(2)
	q.Enqueue(3)

	val, err := q.Peek()
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println(val)
	}
}

if q.front == nil {

check if queue is empty to avoid error

return q.front.value, nil

return the value at the front without removing it

Output

1

Complexity Analysis

Time: O(1) because peeking only reads the front element without traversal

Space: O(1) because no extra space is used for peeking

vs Alternative: Compared to dequeue which removes the element, peek is faster as it does not modify the structure

Edge Cases

empty queue

returns an error indicating the queue is empty

DSA Go

if q.front == nil {

When to Use This Pattern

When you need to see the next item to process in a queue without removing it, use the peek operation to check the front element safely.

Common Mistakes

Mistake: Trying to peek when the queue is empty without checking causes errors
Fix: Always check if the queue is empty before peeking

Summary

Peek returns the front element of the queue without removing it.

Use peek when you want to know the next item to process but keep it in the queue.

The key insight is that peek reads the front node's value without changing the queue structure.

Practice

1. What does the Peek operation do in a queue?

easy

A. Returns the front element without removing it

B. Removes the front element from the queue

C. Adds an element to the back of the queue

D. Checks if the queue is empty

Solution

1. Step 1: Understand the queue operations

   A queue supports adding elements at the back and removing from the front.

2. Step 2: Define Peek operation

   Peek returns the front element without removing it, unlike dequeue which removes it.

3. Final Answer:

   Returns the front element without removing it -> Option A

4. Quick Check:

   Peek = front element without removal [OK]

Hint: Peek shows front without removal, unlike dequeue [OK]

Common Mistakes:

• Confusing peek with dequeue
• Thinking peek adds elements
• Assuming peek checks emptiness

2. Which of the following is the correct Go syntax to peek the front element of a queue implemented as a slice named queue?

easy

A. front := queue[len(queue)-1]

B. front := queue[len(queue)]

C. front := queue[0]

D. front := queue.pop()

Solution

1. Step 1: Understand Go slice indexing

   Go slices are zero-indexed, so the first element is at index 0.

2. Step 2: Identify front element access

   The front element of a queue is the first element, so queue[0] gives it.

3. Final Answer:

   front := queue[0] -> Option C

4. Quick Check:

   First element index = 0 [OK]

Hint: Front element is always at index 0 in slice queue [OK]

Common Mistakes:

• Using len(queue) which is out of range
• Using last element instead of first
• Using pop() which is not a Go slice method

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

queue := []int{10, 20, 30}
front := queue[0]
fmt.Println(front)

medium

A. runtime error

B. 10

C. 30

D. 20

Solution

1. Step 1: Initialize queue slice

   The queue slice contains elements [10, 20, 30].

2. Step 2: Access front element

   front := queue[0] assigns 10 to front.

3. Step 3: Print front

   fmt.Println(front) prints 10.

4. Final Answer:

   10 -> Option B

5. Quick Check:

   queue[0] = 10 [OK]

Hint: queue[0] gives first element value [OK]

Common Mistakes:

• Printing queue[1] instead of queue[0]
• Expecting last element output
• Thinking it causes runtime error

4. Identify the error in this Go code that tries to peek the front element of a queue:

var queue []int
front := queue[0]
fmt.Println(front)

medium

A. No error, prints 0

B. Prints nil

C. Compile-time syntax error

D. Runtime panic: index out of range

Solution

1. Step 1: Check queue initialization

   queue is declared but not initialized, so length is 0.

2. Step 2: Accessing queue[0]

   Accessing queue[0] causes runtime panic because slice is empty.

3. Final Answer:

   Runtime panic: index out of range -> Option D

4. Quick Check:

   Empty slice access causes panic [OK]

Hint: Empty slice access causes runtime panic [OK]

Common Mistakes:

• Assuming default zero value is returned
• Expecting compile-time error
• Thinking it prints nil

5. Given a queue implemented as a slice queue := []int{5, 10, 15}, write the correct Go code snippet to safely peek the front element and handle the empty queue case by printing "Empty" if no elements exist.

hard

A. if len(queue) > 0 {
fmt.Println(queue[0])
} else {
fmt.Println("Empty")
}

B. fmt.Println(queue[0])

C. if queue != nil {
fmt.Println(queue[0])
} else {
fmt.Println("Empty")
}

D. if len(queue) == 0 {
fmt.Println(queue[0])
} else {
fmt.Println("Empty")
}

Solution

1. Step 1: Check queue length before access

   Use len(queue) > 0 to ensure queue has elements.

2. Step 2: Print front or "Empty"

   If queue has elements, print queue[0]; else print "Empty".

3. Final Answer:

   if len(queue) > 0 { fmt.Println(queue[0]) } else { fmt.Println("Empty") } -> Option A

4. Quick Check:

   Check length before access to avoid panic [OK]

Hint: Always check length before peeking front [OK]

Common Mistakes:

• Not checking length before access
• Checking nil instead of length
• Reversing if-else logic