Stack Implementation Using Array in DSA Java - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this stack push and pop sequence?

Consider a stack implemented using an array with a maximum size of 3. The following operations are performed in order:

push(10), push(20), pop(), push(30), push(40), pop()

What is the printed state of the stack after these operations?

DSA Java

class Stack {
    int[] arr = new int[3];
    int top = -1;

    void push(int x) {
        if (top == arr.length - 1) return;
        arr[++top] = x;
    }

    int pop() {
        if (top == -1) return -1;
        return arr[top--];
    }

    void printStack() {
        for (int i = 0; i <= top; i++) {
            System.out.print(arr[i] + " -> ");
        }
        System.out.println("null");
    }
}

public class Main {
    public static void main(String[] args) {
        Stack s = new Stack();
        s.push(10);
        s.push(20);
        s.pop();
        s.push(30);
        s.push(40);
        s.pop();
        s.printStack();
    }
}

A 30 -> null

B 10 -> 20 -> 30 -> null

C 10 -> 30 -> null

D 10 -> 20 -> null

💡 Hint

Remember that pop removes the top element and push adds on top if there is space.

Initially, push 10 and 20: stack is 10 -> 20 -> null. Pop removes 20: stack is 10 -> null. Push 30: stack is 10 -> 30 -> null. Push 40: 40 is added: stack is 10 -> 30 -> 40 -> null. Then pop removes 40: stack is 10 -> 30 -> null.

🧠 Conceptual

intermediate

What happens when you try to push an element into a full stack implemented using an array?

If a stack is implemented using an array of fixed size 5 and currently holds 5 elements, what happens when you try to push another element?

A The push operation overwrites the top element.

B The new element replaces the bottom element of the stack.

C The stack automatically resizes to hold more elements.

D The push operation is ignored or rejected because the stack is full.

💡 Hint

Think about fixed size arrays and their capacity limits.

In a fixed size array stack, once the array is full, no more elements can be added. The push operation is ignored or rejected to prevent overflow.

🔧 Debug

advanced

Identify the error in this stack pop method implementation

What error will occur when calling pop() on an empty stack with this code?

DSA Java

class Stack {
    int[] arr = new int[3];
    int top = -1;

    int pop() {
        return arr[top--];
    }
}

A No error, returns -1

B ArrayIndexOutOfBoundsException

C NullPointerException

D StackOverflowError

💡 Hint

What happens if top is -1 and you try to access arr[top]?

If top is -1 (empty stack), accessing arr[top] tries to access arr[-1], which is invalid and causes ArrayIndexOutOfBoundsException.

❓ Predict Output

advanced

What is the output after pushing and popping with boundary checks?

Given this stack implementation with boundary checks, what is the printed stack after these operations?

push(5), push(15), push(25), push(35), pop(), pop(), push(45), printStack()

DSA Java

class Stack {
    int[] arr = new int[3];
    int top = -1;

    void push(int x) {
        if (top == arr.length - 1) return;
        arr[++top] = x;
    }

    int pop() {
        if (top == -1) return -1;
        return arr[top--];
    }

    void printStack() {
        for (int i = 0; i <= top; i++) {
            System.out.print(arr[i] + " -> ");
        }
        System.out.println("null");
    }
}

public class Main {
    public static void main(String[] args) {
        Stack s = new Stack();
        s.push(5);
        s.push(15);
        s.push(25);
        s.push(35);
        s.pop();
        s.pop();
        s.push(45);
        s.printStack();
    }
}

A 5 -> 45 -> null

B 5 -> 15 -> 45 -> null

C 5 -> 15 -> 25 -> null

D 15 -> 25 -> 45 -> null

💡 Hint

Remember the stack size limit and that push ignores if full.

Push 5,15,25 fills stack: 5->15->25->null. Push 35 ignored (full). Pop removes 25 and then 15: stack is 5->null. Push 45 adds on top: 5->45->null.

🧠 Conceptual

expert

Why is stack implemented using array faster than linked list in some cases?

Choose the best reason why a stack implemented using an array can be faster than one implemented using a linked list.

A Because arrays use contiguous memory, improving cache performance.

B Because linked lists do not support push and pop operations.

C Because linked lists use less memory per element.

D Because arrays allow dynamic resizing automatically.

💡 Hint

Think about how memory is accessed in arrays vs linked lists.

Arrays store elements in contiguous memory locations, which helps CPU cache to access data faster compared to linked lists where nodes are scattered in memory.

Practice

1. What is the main purpose of using an array in stack implementation?

easy

A. To allow random access to elements anywhere in the stack

B. To store elements in a fixed-size linear structure

C. To automatically resize the stack when full

D. To store elements in a linked manner with pointers

Solution

1. Step 1: Understand stack storage using array

   An array provides a fixed-size linear block of memory to store stack elements sequentially.

2. Step 2: Compare with other storage methods

   Unlike linked lists, arrays do not use pointers and have fixed size, so they store elements linearly.

3. Final Answer:

   To store elements in a fixed-size linear structure -> Option B

4. Quick Check:

   Array = fixed-size linear storage [OK]

Hint: Stack array stores elements linearly with fixed size [OK]

Common Mistakes:

• Thinking array allows automatic resizing
• Confusing array with linked list storage
• Assuming random access is main stack feature

2. Which of the following is the correct way to declare a stack array of size 10 in Java?

easy

A. int[] stack = new int[10];

B. int stack = new int[10];

C. int stack[] = int[10];

D. int stack = int[10];

Solution

1. Step 1: Recall Java array declaration syntax

   In Java, arrays are declared with type[], variable = new type[size];

2. Step 2: Match correct syntax

   int[] stack = new int[10]; matches this syntax: int[] stack = new int[10]; others have syntax errors.

3. Final Answer:

   int[] stack = new int[10]; -> Option A

4. Quick Check:

   Java array declaration = int[] name = new int[size]; [OK]

Hint: Use 'type[] name = new type[size];' for arrays in Java [OK]

Common Mistakes:

• Missing 'new' keyword
• Wrong placement of brackets
• Assigning array without 'new'

3. What will be the output after the following operations on a stack of size 3?

Stack s = new Stack(3);
s.push(10);
s.push(20);
s.pop();
s.push(30);
s.push(40);

Assuming push prints "Pushed: value" and pop prints "Popped: value".

medium

A. "Pushed: 10\nPushed: 20\nPopped: 20\nStack Overflow\nPushed: 40"

B. "Pushed: 10\nPushed: 20\nPopped: 20\nPushed: 30"

C. "Pushed: 10\nPushed: 20\nPopped: 20\nPushed: 30\nStack Overflow"

D. "Pushed: 10\nPushed: 20\nPopped: 20\nPushed: 30\nPushed: 40"

Solution

1. Step 1: Trace push and pop operations on stack size 3

   push(10) prints "Pushed: 10" stack:[10]; push(20) "Pushed: 20" [10,20]; pop() "Popped: 20" [10]; push(30) "Pushed: 30" [10,30]; push(40) "Pushed: 40" [10,30,40] (capacity 3, net 3 elements).

2. Step 2: Identify outputs printed

   All pushes and pop print their messages; no overflow since 3 <= capacity 3.

3. Final Answer:

   "Pushed: 10\nPushed: 20\nPopped: 20\nPushed: 30\nPushed: 40" -> Option D

4. Quick Check:

   Net 3 elements <= size 3 = no overflow [OK]

Hint: Net pushes (4 push - 1 pop = 3) <= size 3: no overflow [OK]

Common Mistakes:

• Thinking stack doesn't reuse space after pop
• Miscalculating net elements (3 <= 3)
• Expecting overflow on 3rd net push

4. Identify the error in the following stack push method and select the correct fix:

public void push(int x) {
  if (top == size) {
    System.out.println("Stack Overflow");
  } else {
    stack[top] = x;
    top++;
  }
}

medium

A. Change condition to if (top >= size) to correctly detect overflow

B. Change condition to if (top == size - 1) to avoid overflow

C. Initialize top to 1 instead of 0 to fix indexing

D. Replace top++ with ++top to fix increment order

Solution

1. Step 1: Analyze overflow condition

   Since array indices go from 0 to size-1, top == size means stack is full; condition should catch top >= size to prevent overflow.

2. Step 2: Check other options

   Changing to size - 1 is incorrect because top points to next free slot; initializing top to 1 or changing increment order is unrelated.

3. Final Answer:

   Change condition to if (top >= size) to correctly detect overflow -> Option A

4. Quick Check:

   Overflow check = top >= size [OK]

Hint: Overflow when top index reaches or exceeds size [OK]

Common Mistakes:

• Using top == size - 1 instead of top >= size
• Incorrect top initialization
• Misunderstanding increment order

5. Given a stack implemented using an array with size 5, which sequence of operations will result in the stack containing elements [5, 10, 15] from bottom to top?

Operations:
1) push(5)
2) push(10)
3) pop()
4) push(15)
5) push(10)

hard

A. Perform operations in order: 1, 2, 3, 4, 5

B. Perform operations in order: 1, 3, 2, 4, 5

C. Perform operations in order: 1, 2, 5, 3, 4

D. Perform operations in order: 1, 2, 4, 3, 5

Solution

1. Step 1: Trace operations in order 1,2,3,4,5

   push(5) -> [5]; push(10) -> [5,10]; pop() removes 10 -> [5]; push(15) -> [5,15]; push(10) -> [5,15,10]

2. Step 2: Check final stack order bottom to top

   Stack is [5,15,10], which is not [5,10,15]. So Perform operations in order: 1, 2, 3, 4, 5 is incorrect. Check other options similarly.

3. Step 3: Trace Perform operations in order: 1, 3, 2, 4, 5 (1,3,2,4,5)

   push(5) -> [5]; pop() removes 5 -> []; push(10) -> [10]; push(15) -> [10,15]; push(10) -> [10,15,10] not correct.

4. Step 4: Trace Perform operations in order: 1, 2, 4, 3, 5 (1,2,4,3,5)

   push(5) -> [5]; push(10) -> [5,10]; push(15) -> [5,10,15]; pop() removes 15 -> [5,10]; push(10) -> [5,10,10] not correct.

5. Step 5: Trace Perform operations in order: 1, 2, 5, 3, 4 (1,2,5,3,4)

   push(5) -> [5]; push(10) -> [5,10]; push(10) -> [5,10,10]; pop() removes 10 -> [5,10]; push(15) -> [5,10,15] correct final stack.

6. Final Answer:

   Perform operations in order: 1, 2, 5, 3, 4 -> Option C

7. Quick Check:

   Final stack = [5,10,15] after Perform operations in order: 1, 2, 5, 3, 4 [OK]

Hint: Simulate stack step-by-step to verify final order [OK]

Common Mistakes:

• Assuming order of operations does not affect stack
• Not simulating pop effects correctly
• Confusing push order with final stack order