Peek Top Element of Stack in DSA C - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to return the top element of the stack.

DSA C

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

Drag options to blanks, or click blank then click option'

A[top]

B[s->top]

C[s->top - 1]

D[0]

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong index like 0 or top-1.

Trying to access a variable named 'top' instead of s->top.

The top element is at index s->top in the array.

2fill in blank

medium

Complete the code to check if the stack is empty before peeking.

DSA C

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

Drag options to blanks, or click blank then click option'

As->top == -1

Bs->top == 0

Cs->top > 0

Ds->top < 0

Attempts:

3 left

💡 Hint

Common Mistakes

Checking if top is 0 instead of -1.

Using greater than or less than comparisons incorrectly.

The stack is empty when s->top is -1.

3fill in blank

hard

Fix the error in the peek function to correctly return the top element.

DSA C

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

Drag options to blanks, or click blank then click option'

A[s->top + 1]

B[0]

C[s->top - 1]

D[s->top]

Attempts:

3 left

💡 Hint

Common Mistakes

Using s->top + 1 which is out of bounds.

Using s->top - 1 which points to the wrong element.

The top element is at index s->top. Using s->top + 1 or others is incorrect.

4fill in blank

hard

Fill both blanks to complete the peek function that returns the top element safely.

DSA C

int peek(Stack *s) {
    if ([1]) {
        return -1;
    }
    return s->array[2];
}

Drag options to blanks, or click blank then click option'

As->top == -1

Bs->top == 0

C[s->top]

D[0]

Attempts:

3 left

💡 Hint

Common Mistakes

Checking wrong condition for empty stack.

Accessing array at wrong index.

Check if stack is empty with s->top == -1 and return the element at s->array[s->top].

5fill in blank

hard

Fill all three blanks to implement a safe peek function that returns the top element or -1 if empty.

DSA C

int peek(Stack *s) {
    if ([1]) {
        return [2];
    }
    return s->array[3];
}

Drag options to blanks, or click blank then click option'

As->top == -1

B-1

C[s->top]

Ds->top == 0

Attempts:

3 left

💡 Hint

Common Mistakes

Returning wrong value when empty.

Accessing array at wrong index.

Check if stack is empty with s->top == -1, return -1 if empty, else return the top element at s->array[s->top].

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