Peek Top Element of Stack in DSA C - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the 'peek' operation do in a stack?

The 'peek' operation returns the top element of the stack without removing it, allowing you to see the current top value.

beginner

In a stack implemented using an array, which index usually represents the top element?

The top element is usually at the index represented by the 'top' variable, which points to the last inserted element.

intermediate

What should the 'peek' function do if the stack is empty?

If the stack is empty, the 'peek' function should handle it gracefully, often by returning a special value or indicating an error, since there is no top element to show.

beginner

Show the basic C code snippet to peek the top element of a stack implemented with an array and a 'top' index.

int peek(int stack[], int top) { if (top == -1) { // Stack is empty return -1; // or some error code } return stack[top]; }

beginner

Why is it important that 'peek' does not remove the top element from the stack?

Because 'peek' is meant only to view the top element without changing the stack's state, so other operations can still use the stack as expected.

What does the 'peek' operation return in a stack?

A The top element without removing it

B Removes and returns the top element

C Returns the bottom element

D Clears the stack

Peek returns the top element without removing it from the stack.

If the stack is empty, what should the peek function do?

A Return the top element

B Remove the bottom element

C Add a new element

D Return an error or special value

Peek should handle empty stack by returning an error or special value since no top element exists.

In a stack implemented with an array, what does the 'top' variable represent?

A Index of the top element

B Number of elements in the stack

C Index of the bottom element

D Size of the array

'top' points to the index of the current top element in the stack array.

Which of these is true about the peek operation?

A It returns the top element and removes it

B It returns the top element without removing it

C It removes the top element

D It clears the stack

Peek returns the top element but does not remove it from the stack.

What value is commonly used to indicate an empty stack in C implementations?

A top = 0

B top = NULL

C top = -1

D top = 1

top = -1 usually means the stack is empty in array-based stack implementations.

Explain how the peek operation works in a stack implemented with an array.

Think about how you find the last added item without changing the stack.

Describe why peek is useful and how it differs from pop in stack operations.

Consider what happens to the stack after each operation.

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