Peek Top Element of Stack in DSA C - Execution Trace

Concept Flow - Peek Top Element of Stack

Start

↓

Check if stack is empty?

Yes→Return error or NULL

No↓

Access top element

↓

Return top element

↓

End

The flow checks if the stack is empty. If not, it accesses and returns the top element without removing it.

Execution Sample

DSA C

int peek(Stack* s) {
    if (s->top == -1) return -1; // empty
    return s->arr[s->top];
}

This code returns the top element of the stack if it exists, otherwise returns -1 indicating empty stack.

Execution Table

Step	Operation	Stack Top Index	Stack Array	Pointer Changes	Visual State
1	Start peek operation	2	[10, 20, 30]	top points to index 2	30 (top) -> 20 -> 10 -> null
2	Check if stack is empty (top == -1?)	2	[10, 20, 30]	No change	30 (top) -> 20 -> 10 -> null
3	Access element at top index	2	[10, 20, 30]	No change	30 (top) -> 20 -> 10 -> null
4	Return top element (30)	2	[10, 20, 30]	No change	30 (top) -> 20 -> 10 -> null
5	End peek operation	2	[10, 20, 30]	No change	30 (top) -> 20 -> 10 -> null

💡 Peek ends after returning the top element without modifying the stack.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
top	2	2	2	2	2
stack array	[10, 20, 30]	[10, 20, 30]	[10, 20, 30]	[10, 20, 30]	[10, 20, 30]
peeked value	N/A	N/A	N/A	30	30

Key Moments - 3 Insights

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

Because if the stack is empty (top == -1), there is no element to peek. The execution_table row 2 shows this check prevents accessing invalid memory.

Does peeking remove the top element from the stack?

No, peeking only reads the top element without changing the stack. The pointer 'top' remains the same as shown in all steps in the execution_table.

What happens if we peek on an empty stack?

The function returns -1 or an error value as shown in the concept_flow and execution_table step 2, preventing invalid access.

Visual Quiz - 3 Questions

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

A 2

B -1

C 3

D 0

💡 Hint

Check the 'Stack Top Index' column in execution_table row 3.

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

A Step 1

B Step 2

C Step 4

D Step 5

💡 Hint

Look at the 'Operation' column in execution_table where the empty check happens.

If the stack was empty (top = -1), what would the peek function return?

A The bottom element

B The top element

C -1 or error value

D 0

💡 Hint

Refer to concept_flow and key_moments about empty stack handling.

Concept Snapshot

Peek Top Element of Stack:
- Check if stack is empty (top == -1)
- If empty, return error or special value
- Else, return element at stack[top]
- Does NOT remove element
- Stack remains unchanged after peek

Full Transcript

Peeking the top element of a stack means looking at the element on top without removing it. The process starts by checking if the stack is empty by verifying if the top index is -1. If empty, the function returns an error value like -1. If not empty, it accesses the element at the top index and returns it. The stack's content and top pointer do not change during this operation. This ensures safe access to the top element without modifying the stack.

Practice

1. What does the peek operation do in a stack?

easy

A. Removes the top element from the stack

B. Returns the top element without removing it

C. Adds a new element to the top of the stack

D. Checks if the stack is empty

Solution

1. Step 1: Understand the peek operation

   The peek operation looks at the top element of the stack without changing the stack.

2. Step 2: Compare with other stack operations

   Pop removes the top element, push adds an element, and isEmpty checks if stack is empty.

3. Final Answer:

   Returns the top element without removing it -> Option B

4. Quick Check:

   Peek = top element without removal [OK]

Hint: Peek shows top without removing it [OK]

Common Mistakes:

• Confusing peek with pop operation
• Thinking peek removes the element
• Mixing peek with push or isEmpty

2. Which of the following is the correct syntax to peek the top element of a stack named stack in C if top is the index of the top element and arr is the array storing stack elements?

easy

A. int x = arr[top - 1];

B. int x = arr[top + 1];

C. int x = arr[0];

D. int x = arr[top];

Solution

1. Step 1: Understand stack top indexing

   Top points to the current top element index in the array.

2. Step 2: Access the top element

   Accessing arr[top] gives the top element. Using top+1 or top-1 is incorrect as it points to wrong positions.

3. Final Answer:

   int x = arr[top]; -> Option D

4. Quick Check:

   Top index points to top element [OK]

Hint: Use arr[top] to peek top element [OK]

Common Mistakes:

• Using top+1 or top-1 instead of top
• Accessing arr[0] assuming stack bottom is top
• Confusing top index with element value

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

int stack[3] = {10, 20, 30};
int top = 2;
printf("%d", stack[top]);

medium

A. 10

B. 20

C. 30

D. Runtime error

Solution

1. Step 1: Identify the top element index and stack contents

   Stack array has elements 10 at index 0, 20 at 1, and 30 at 2. Top is 2.

2. Step 2: Access and print the top element

   stack[top] = stack[2] = 30, so printf prints 30.

3. Final Answer:

   30 -> Option C

4. Quick Check:

   stack[top] = 30 [OK]

Hint: Print stack[top] to get top element [OK]

Common Mistakes:

• Confusing index 0 as top
• Assuming top is out of range
• Expecting pop removes element but code only prints

4. Find the error in this C code snippet that tries to peek the top element of a stack:

int stack[5] = {1, 2, 3, 4, 5};
int top = 4;
int peek() {
  return stack[top + 1];
}

medium

A. Accessing stack[top + 1] causes out-of-bounds error

B. top should be initialized to -1

C. Function should return void, not int

D. Stack array size is too small

Solution

1. Step 1: Analyze the peek function access

   Peek returns stack[top + 1], which is stack[5] here (top=4), exceeding array size 5 (0-4).

2. Step 2: Understand correct top indexing

   Top points to current top element, so peek should return stack[top], not stack[top + 1].

3. Final Answer:

   Accessing stack[top + 1] causes out-of-bounds error -> Option A

4. Quick Check:

   Index out of bounds error [OK]

Hint: Peek uses stack[top], not stack[top+1] [OK]

Common Mistakes:

• Using top+1 instead of top for peek
• Ignoring array bounds causing runtime error
• Incorrect top initialization assumptions

5. Given a stack implemented using an array stack[5] and a variable top initialized to -1, which sequence of operations correctly peeks the top element after pushing 3 elements (10, 20, 30)?

hard

A. stack[++top] = 10; stack[++top] = 20; stack[++top] = 30; int x = stack[top];

B. stack[top] = 10; top = top + 1; stack[top] = 20; top = top + 1; stack[top] = 30; top = top + 1; int x = stack[top];

C. stack[top++] = 10; stack[top++] = 20; stack[top++] = 30; int x = stack[top];

D. top = 0; stack[top] = 10; top = 1; stack[top] = 20; top = 2; stack[top] = 30; int x = stack[top + 1];

Solution

1. Step 1: Understand push operation with top

   Using stack[++top] = value increments top first, then assigns value, correctly pushing elements.

2. Step 2: Peek top element after pushes

   After pushing 3 elements, top points to last pushed element. Accessing stack[top] gives top element.

3. Final Answer:

   stack[++top] = 10; stack[++top] = 20; stack[++top] = 30; int x = stack[top]; -> Option A

4. Quick Check:

   Push increments top, peek uses stack[top] [OK]

Hint: Use stack[++top] to push, stack[top] to peek [OK]

Common Mistakes:

• Using post-increment top++ causing wrong indexing
• Accessing stack[top + 1] for peek
• Not initializing top to -1 before push