Peek Front Element of Queue in DSA Java

Mental Model

A queue lets you see the first item waiting without removing it. Peeking means looking at the front without changing the queue.

Analogy: Imagine a line at a coffee shop. Peeking is like glancing at the first person in line without letting them order or leaving the line.

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

Dry Run Walkthrough

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

Goal: See the first element (1) without removing it from the queue

Step 1: Access the front element of the queue

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

Why: We want to know the first element without changing the queue

Step 2: Return the value of the front element (1)

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

Why: Peeking only reads the front, so the queue stays the same

Result:

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

Annotated Code

DSA Java

import java.util.NoSuchElementException;

class QueueNode {
    int value;
    QueueNode next;
    QueueNode(int val) { this.value = val; this.next = null; }
}

class Queue {
    private QueueNode front;
    private QueueNode rear;

    public Queue() {
        front = null;
        rear = null;
    }

    public void enqueue(int val) {
        QueueNode newNode = new QueueNode(val);
        if (rear == null) {
            front = newNode;
            rear = newNode;
            return;
        }
        rear.next = newNode;
        rear = newNode;
    }

    public int peek() {
        if (front == null) {
            throw new NoSuchElementException("Queue is empty");
        }
        return front.value; // return front value without removing
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();
        QueueNode curr = front;
        while (curr != null) {
            sb.append(curr.value).append(" -> ");
            curr = curr.next;
        }
        sb.append("null");
        return sb.toString();
    }
}

public class PeekFrontQueue {
    public static void main(String[] args) {
        Queue q = new Queue();
        q.enqueue(1);
        q.enqueue(2);
        q.enqueue(3);
        System.out.println("Queue: " + q);
        int frontValue = q.peek();
        System.out.println("Peeked value = " + frontValue);
        System.out.println("Queue after peek: " + q);
    }
}

if (front == null) { throw new NoSuchElementException("Queue is empty"); }

check if queue is empty to avoid errors

return front.value; // return front value without removing

return the front element value without changing the queue

Output

Queue: 1 -> 2 -> 3 -> null

Peeked value = 1

Queue after peek: 1 -> 2 -> 3 -> null

Complexity Analysis

Time: O(1) because peek just reads the front element without traversal

Space: O(n) because the queue stores n elements; peek uses no extra space

vs Alternative: Compared to dequeue which removes and may need pointer updates, peek is faster and safer as it does not modify the queue

Edge Cases

empty queue

throws NoSuchElementException to signal no elements to peek

DSA Java

if (front == null) { throw new NoSuchElementException("Queue is empty"); }

When to Use This Pattern

When a problem asks to check the next item to process without removing it, use the peek operation on a queue to safely inspect the front.

Common Mistakes

Mistake: Removing the front element instead of just reading it during peek
Fix: Return front.value without changing front pointer or queue structure

Summary

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

Use peek when you need to see the next item to process but keep the queue unchanged.

The key insight is that peek reads the front pointer's value without moving or deleting nodes.

Practice

1. What does the peek() method do in a Java Queue?

easy

A. Returns the front element without removing it

B. Removes and returns the front element

C. Adds an element to the end of the queue

D. Checks if the queue is empty

Solution

1. Step 1: Understand the purpose of peek()

   The peek() method is designed to look at the front element of the queue without changing the queue.

2. Step 2: Compare with other queue methods

   Unlike poll() which removes the front element, peek() only returns it without removal.

3. Final Answer:

   Returns the front element without removing it -> Option A

4. Quick Check:

   peek() returns front element without removal [OK]

Hint: peek() shows front without removing [OK]

Common Mistakes:

• Confusing peek() with poll() which removes element
• Thinking peek() adds elements
• Assuming peek() checks if queue is empty

2. Which of the following is the correct syntax to peek the front element of a Java Queue named q?

easy

A. q.getFirst();

B. q.front();

C. q.peek();

D. q.pop();

Solution

1. Step 1: Recall Java Queue methods

   The standard method to look at the front element without removing it is peek().

2. Step 2: Check other options

   front() and pop() are not methods of Java Queue interface; getFirst() belongs to Deque, not Queue.

3. Final Answer:

   q.peek(); -> Option C

4. Quick Check:

   Use peek() to view front element [OK]

Hint: Use q.peek() to see front element [OK]

Common Mistakes:

• Using pop() which is not in Queue interface
• Using front() which doesn't exist in Java Queue
• Confusing getFirst() with peek()

3. What will be the output of the following Java code?

import java.util.*;
public class Main {
  public static void main(String[] args) {
    Queue<Integer> q = new LinkedList<>();
    q.add(10);
    q.add(20);
    q.add(30);
    System.out.println(q.peek());
    q.poll();
    System.out.println(q.peek());
  }
}

medium

A. 10\n10

B. 30\n20

C. 20\n30

D. 10\n20

Solution

1. Step 1: Add elements to queue

   Elements 10, 20, 30 are added in order. Queue is now [10, 20, 30].

2. Step 2: Peek and poll operations

   First peek() returns 10 (front). Then poll() removes 10. Next peek() returns 20 (new front).

3. Final Answer:

   10\n20 -> Option D

4. Quick Check:

   peek() before poll = 10, after poll = 20 [OK]

Hint: peek() shows front; poll() removes front [OK]

Common Mistakes:

• Assuming peek() removes element
• Confusing poll() with peek()
• Expecting peek() to return last element

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

import java.util.*;
public class Main {
  public static void main(String[] args) {
    Queue<Integer> q = new LinkedList<>();
    q.add(5);
    q.add(15);
    int front = q.peek();
    System.out.println(front);
  }
}

medium

A. peek() returns Integer, cannot assign to int without unboxing

B. No error, code runs fine and prints 5

C. Queue interface does not have peek() method

D. Must cast peek() result to int explicitly

Solution

1. Step 1: Check peek() return type

   peek() returns an Integer object, which Java auto-unboxes to int automatically.

2. Step 2: Verify code correctness

   Code compiles and runs fine, printing 5 as expected.

3. Final Answer:

   No error, code runs fine and prints 5 -> Option B

4. Quick Check:

   Auto-unboxing allows Integer to int assignment [OK]

Hint: Java auto-unboxes Integer to int [OK]

Common Mistakes:

• Thinking explicit cast needed from Integer to int
• Assuming peek() returns primitive int
• Believing Queue lacks peek() method

5. Given a queue q containing integers, write a Java method peekOrDefault that returns the front element if the queue is not empty, or returns -1 if it is empty. Which of the following implementations is correct?

hard

A. public int peekOrDefault(Queue<Integer> q) { return q.isEmpty() ? -1 : q.peek(); }

B. public int peekOrDefault(Queue<Integer> q) { return q.peek() == null ? -1 : q.poll(); }

C. public int peekOrDefault(Queue<Integer> q) { return q.poll() == null ? -1 : q.peek(); }

D. public int peekOrDefault(Queue<Integer> q) { if(q.peek() == null) return -1; else return q.poll(); }

Solution

1. Step 1: Check for empty queue safely

   Use q.isEmpty() to check if queue has elements before peeking.

2. Step 2: Return front or default

   If empty, return -1; else return q.peek() which does not remove element.

3. Step 3: Analyze other options

   public int peekOrDefault(Queue<Integer> q) { return q.peek() == null ? -1 : q.poll(); }: public int peekOrDefault(Queue<Integer> q) { return q.peek() == null ? -1 : q.poll(); } peeks to check but polls to return, removing the front element—wrong. public int peekOrDefault(Queue<Integer> q) { return q.poll() == null ? -1 : q.peek(); }: public int peekOrDefault(Queue<Integer> q) { return q.poll() == null ? -1 : q.peek(); } polls first; if not empty, removes front then peeks new front—wrong. public int peekOrDefault(Queue<Integer> q) { if(q.peek() == null) return -1; else return q.poll(); }: public int peekOrDefault(Queue<Integer> q) { if(q.peek() == null) return -1; else return q.poll(); } returns poll() in else, removing element—wrong.

4. Final Answer:

   public int peekOrDefault(Queue<Integer> q) { return q.isEmpty() ? -1 : q.peek(); } -> Option A

5. Quick Check:

   Check empty first, then peek without removal [OK]

Hint: Check isEmpty() before peek() to avoid null [OK]

Common Mistakes:

• Using poll() which removes element
• Peeking to check null but then polling which removes
• Not handling empty queue before peeking