Peek Front Element of Queue in DSA Go - Execution Trace

Concept Flow - Peek Front Element of Queue

Start with Queue

↓

Check if Queue is empty?

Yes→Return error or nil

No↓

Access front element

↓

Return front element without removal

↓

End

The flow checks if the queue is empty, then accesses and returns the front element without removing it.

Execution Sample

DSA Go

package main

import "fmt"

func main() {
    queue := []int{10, 20, 30}
    if len(queue) == 0 {
        fmt.Println("Queue is empty")
    } else {
        front := queue[0]
        fmt.Println(front)
    }
}

This code checks if the queue is empty and prints the front element if not.

Execution Table

Step	Operation	Queue State	Pointer Changes	Visual State
1	Start with queue initialized	[10, 20, 30]	front=nil	Front -> 10 -> 20 -> 30 -> nil
2	Check if queue is empty	[10, 20, 30]	front=nil	Queue not empty
3	Access front element	[10, 20, 30]	front=10	Front -> 10 -> 20 -> 30 -> nil
4	Return front element	[10, 20, 30]	front=10	Front element is 10
5	End	[10, 20, 30]	front=10	Queue unchanged

💡 Queue is not empty, front element accessed without removal

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
queue	[10, 20, 30]	[10, 20, 30]	[10, 20, 30]	[10, 20, 30]
front	nil	nil	10	10

Key Moments - 3 Insights

Why do we check if the queue is empty before peeking?

Because if the queue is empty, there is no front element to return. The execution_table row 2 shows this check prevents errors.

Does peeking remove the front element from the queue?

No, peeking only reads the front element without removing it. The queue state remains the same as shown in rows 3 and 5.

What happens if we try to peek an empty queue?

The code returns an error or nil to indicate no element exists. This is shown in the concept flow where the empty check leads to a return.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'front' after step 3?

A nil

B 10

C 20

D 30

💡 Hint

Check the 'Pointer Changes' column at step 3 in the execution_table.

At which step does the code confirm the queue is not empty?

A Step 2

B Step 1

C Step 3

D Step 4

💡 Hint

Look at the 'Operation' and 'Visual State' columns in the execution_table for the empty check.

If the queue was empty, what would the execution_table show at step 2?

A Queue would have elements

B Front element would be accessed

C Queue state would be empty and return error

D Front pointer would be 10

💡 Hint

Refer to the concept_flow and key_moments about empty queue handling.

Concept Snapshot

Peek Front Element of Queue:
- Check if queue is empty first
- If not empty, access queue[0]
- Return front element without removing
- Queue remains unchanged after peek
- Useful to see next item without dequeueing

Full Transcript

This concept shows how to peek the front element of a queue. First, we check if the queue is empty to avoid errors. If it is not empty, we access the first element at index 0 and return it without removing it from the queue. The queue stays the same after peeking. This is useful when you want to see the next item to process without changing the queue. The execution table tracks each step, showing the queue state and pointer changes. Key moments clarify why the empty check is important and that peeking does not remove elements.

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