Stack Implementation Using Array in DSA Java - Build from Scratch

Stack Implementation Using Array

📖 Scenario: You are building a simple stack to manage books in a small library. The stack will hold the book IDs as integers. You will use an array to store the stack elements.

🎯 Goal: Create a stack using an array with basic operations: push, pop, and display the stack content.

📋 What You'll Learn

Create an integer array called stack with size 5

Create an integer variable called top initialized to -1

Write a method push to add an element to the stack

Write a method pop to remove the top element from the stack

Write a method displayStack to print the stack elements from top to bottom

💡 Why This Matters

🌍 Real World

Stacks are used in undo features in text editors, browser history, and expression evaluation.

💼 Career

Understanding stack implementation helps in software development roles that require managing data in last-in-first-out order.

1

Create the stack array and top variable

Create an integer array called stack with size 5 and an integer variable called top initialized to -1.

DSA Java

// Create the stack array and top variable
// Your code here

Hint

Use int[] stack = new int[5]; to create the array and int top = -1; to track the top index.

2

Write the push method

Add a static method called push that takes an integer parameter value. Inside the method, check if top is less than 4. If yes, increment top by 1 and assign value to stack[top]. If the stack is full, print "Stack Overflow".

DSA Java

public class Stack {
    static int[] stack = new int[5];
    static int top = -1;

    // Write the push method below
    // Your code here
}

Hint

Check if top is less than 4 before adding. Increase top and assign the value to stack[top].

3

Write the pop method

Add a static method called pop that returns an integer. Inside the method, check if top is greater than or equal to 0. If yes, store stack[top] in a variable, decrement top by 1, and return the stored value. If the stack is empty, print "Stack Underflow" and return -1.

DSA Java

public class Stack {
    static int[] stack = new int[5];
    static int top = -1;

    static void push(int value) {
        if (top < 4) {
            top++;
            stack[top] = value;
        } else {
            System.out.println("Stack Overflow");
        }
    }

    // Write the pop method below
    // Your code here
}

Hint

Check if top is at least 0 before popping. Save the top value, decrease top, and return the saved value.

4

Write the displayStack method and test the stack

Add a static method called displayStack that prints the stack elements from top to 0 separated by spaces. Then, in the main method, push the values 10, 20, and 30 onto the stack, call displayStack, pop one element, and call displayStack again.

DSA Java

public class Stack {
    static int[] stack = new int[5];
    static int top = -1;

    static void push(int value) {
        if (top = 0) {
            int value = stack[top];
            top--;
            return value;
        } else {
            System.out.println("Stack Underflow");
            return -1;
        }
    }

    // Write the displayStack method and main method below
    // Your code here
}

Hint

Use a for loop from top down to 0 to print elements. In main, push 10, 20, 30, display, pop once, then display again.

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