Peek Top Element of Stack in DSA C - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of peeking the top element in this stack?

Consider a stack implemented using an array with the following operations. What will be printed after peeking the top element?

DSA C

#include <stdio.h>
#define MAX 5

int stack[MAX];
int top = -1;

void push(int x) {
    if (top < MAX - 1) {
        stack[++top] = x;
    }
}

int peek() {
    if (top == -1) return -1;
    return stack[top];
}

int main() {
    push(10);
    push(20);
    push(30);
    printf("%d\n", peek());
    return 0;
}

A 10

B 20

C 30

D -1

💡 Hint

Peek returns the element at the top index of the stack array.

The stack has elements pushed in order: 10, 20, 30. The top points to the last pushed element, which is 30. So peek returns 30.

❓ Predict Output

intermediate

What happens when peeking an empty stack?

Given the stack implementation below, what will be the output when peek is called on an empty stack?

DSA C

#include <stdio.h>
#define MAX 3

int stack[MAX];
int top = -1;

int peek() {
    if (top == -1) return -1;
    return stack[top];
}

int main() {
    printf("%d\n", peek());
    return 0;
}

A -1

B 0

C Garbage value

D Runtime error

💡 Hint

Check the condition when top is -1 in peek function.

When the stack is empty, top is -1. The peek function returns -1 in this case, indicating no elements.

🔧 Debug

advanced

Identify the error in this peek function implementation

The peek function below is intended to return the top element of the stack. What error will occur when this code runs?

DSA C

int peek() {
    if (top == 0) return -1;
    return stack[top];
}

A Returns wrong value when stack has one element

B Returns -1 correctly when stack is empty

C Causes segmentation fault

D Compiles but returns garbage value

💡 Hint

Check the condition that checks if stack is empty.

The condition 'top == 0' incorrectly treats stack with one element as empty. The empty stack condition is 'top == -1'. So peek returns -1 even when one element exists.

❓ Predict Output

advanced

What is the output after multiple push and peek operations?

Given the following code, what will be printed?

DSA C

#include <stdio.h>
#define MAX 4

int stack[MAX];
int top = -1;

void push(int x) {
    if (top < MAX - 1) {
        stack[++top] = x;
    }
}

int peek() {
    if (top == -1) return -1;
    return stack[top];
}

int main() {
    push(5);
    push(15);
    printf("%d\n", peek());
    push(25);
    push(35);
    printf("%d\n", peek());
    return 0;
}

A

25
35

B

5
35

C

15
25

D

15
35

💡 Hint

Peek returns the last pushed element at each call.

After pushing 5 and 15, peek returns 15. After pushing 25 and 35, peek returns 35.

🧠 Conceptual

expert

What is the time complexity of the peek operation in a stack?

Consider a stack implemented using an array or linked list. What is the time complexity of the peek operation?

A O(n^2) - Quadratic time

B O(1) - Constant time

C O(log n) - Logarithmic time

D O(n) - Linear time

💡 Hint

Peek only accesses the top element without iteration.

Peek returns the top element directly using the top index or pointer, so it runs in constant time O(1).

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