Bird
0
0
DSA Cprogramming

Peek Front Element of Queue in DSA C

Choose your learning style9 modes available
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 here
Dry Run Walkthrough
Input: queue: 1 -> 2 -> 3, peek front element
Goal: To see the first element in the queue without removing it
Step 1: Check if the queue is empty
front -> [1] -> [2] -> [3] -> null
Why: We must ensure there is an element to peek at
Step 2: Access the front element's value
front -> [1] -> [2] -> [3] -> null
Why: The front element holds the value we want to peek
Step 3: Return the front element's value without removing it
front -> [1] -> [2] -> [3] -> null
Why: Peeking does not change the queue structure
Result:
front -> [1] -> [2] -> [3] -> null
peeked value = 1
Annotated Code
DSA C
#include <stdio.h>
#include <stdlib.h>

// Node structure for queue
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// Queue structure with front and rear pointers
typedef struct Queue {
    Node* front;
    Node* rear;
} Queue;

// Create a new empty queue
Queue* createQueue() {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->front = NULL;
    q->rear = NULL;
    return q;
}

// Add element to the rear of the queue
void enqueue(Queue* q, int value) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = value;
    newNode->next = NULL;
    if (q->rear == NULL) {
        q->front = newNode;
        q->rear = newNode;
        return;
    }
    q->rear->next = newNode;
    q->rear = newNode;
}

// Peek the front element without removing it
int peekFront(Queue* q) {
    if (q->front == NULL) {
        printf("Queue is empty\n");
        return -1; // Indicates empty queue
    }
    return q->front->data; // Return front value without dequeue
}

int main() {
    Queue* q = createQueue();
    enqueue(q, 1);
    enqueue(q, 2);
    enqueue(q, 3);

    int frontValue = peekFront(q);
    if (frontValue != -1) {
        printf("Peeked value = %d\n", frontValue);
    }

    return 0;
}
if (q->front == NULL) {
Check if queue is empty to avoid errors
return q->front->data;
Return the value at the front without removing it
OutputSuccess
Peeked value = 1
Complexity Analysis
Time: O(1) because peeking only accesses the front element directly without traversal
Space: O(1) because no extra space is used during peek operation
vs Alternative: Compared to dequeue which removes the element and may require pointer updates, peek is faster and simpler as it only reads the front value
Edge Cases
Empty queue
Function prints 'Queue is empty' and returns -1 to indicate no element to peek
DSA C
if (q->front == NULL) {
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, causing a null pointer access
Fix: Always check if the front pointer is NULL before accessing its data
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 the queue unchanged.
The key is to access the front pointer's data safely without modifying the queue.