Java Program to Implement a Stack Using Array

Introduction

A stack is a linear data structure that follows the Last In, First Out (LIFO) principle, where elements are added (pushed) and removed (popped) from the top of the stack. This guide will walk you through writing a Java program that implements a stack using an array. The stack operations include push, pop, peek, and checking if the stack is empty or full.

Problem Statement

Create a Java program that:

Implements a stack using an array.
Provides methods to perform standard stack operations: push, pop, peek, isEmpty, and isFull.
Displays the stack contents after various operations.

Example:

Input: Push elements: 10, 20, 30
Operations: push(40), pop(), peek()
Output:
- After pushing 40: [10, 20, 30, 40]
- After popping: [10, 20, 30]
- Peeked element: 30

Solution Steps

Create the Stack Structure: Define a Stack class to represent the stack, including methods for standard stack operations.
Implement Stack Operations: Implement methods to push elements onto the stack, pop elements from the stack, peek at the top element, and check if the stack is empty or full.
Handle Edge Cases: Ensure the stack handles underflow (popping from an empty stack) and overflow (pushing onto a full stack) conditions.
Display the Stack: Output the stack’s contents after performing various operations.

Java Program

// Java Program to Implement a Stack Using Array
// Author: https://www.rameshfadatare.com/

class Stack {
    private int maxSize;
    private int top;
    private int[] stackArray;

    // Constructor to initialize the stack
    public Stack(int size) {
        maxSize = size;
        stackArray = new int[maxSize];
        top = -1; // Stack is initially empty
    }

    // Method to push an element onto the stack
    public void push(int value) {
        if (isFull()) {
            System.out.println("Stack is full. Unable to push " + value);
        } else {
            stackArray[++top] = value;
            System.out.println("Pushed " + value + " onto the stack.");
        }
    }

    // Method to pop an element from the stack
    public int pop() {
        if (isEmpty()) {
            System.out.println("Stack is empty. Unable to pop.");
            return -1; // Return a sentinel value indicating the stack is empty
        } else {
            int poppedValue = stackArray[top--];
            System.out.println("Popped " + poppedValue + " from the stack.");
            return poppedValue;
        }
    }

    // Method to peek at the top element of the stack
    public int peek() {
        if (isEmpty()) {
            System.out.println("Stack is empty. Nothing to peek.");
            return -1; // Return a sentinel value indicating the stack is empty
        } else {
            System.out.println("Peeked at the top element: " + stackArray[top]);
            return stackArray[top];
        }
    }

    // Method to check if the stack is empty
    public boolean isEmpty() {
        return (top == -1);
    }

    // Method to check if the stack is full
    public boolean isFull() {
        return (top == maxSize - 1);
    }

    // Method to display the contents of the stack
    public void display() {
        if (isEmpty()) {
            System.out.println("Stack is empty.");
        } else {
            System.out.print("Stack contents: ");
            for (int i = 0; i <= top; i++) {
                System.out.print(stackArray[i] + " ");
            }
            System.out.println();
        }
    }
}

public class StackDemo {
    public static void main(String[] args) {
        Stack stack = new Stack(5); // Create a stack with a maximum size of 5

        // Push elements onto the stack
        stack.push(10);
        stack.push(20);
        stack.push(30);
        stack.display();

        // Push another element
        stack.push(40);
        stack.display();

        // Pop an element from the stack
        stack.pop();
        stack.display();

        // Peek at the top element
        stack.peek();
        stack.display();

        // Attempt to push more elements to test overflow
        stack.push(50);
        stack.push(60);
        stack.push(70); // This push should trigger an overflow condition
        stack.display();

        // Pop all elements to test underflow
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop(); // This pop should trigger an underflow condition
        stack.display();
    }
}

Explanation

Step 1: Initialize the Stack Class

The Stack class is used to represent a stack, including methods for standard stack operations.
The stack is represented by an integer array (stackArray), where top keeps track of the index of the top element. The maxSize defines the maximum capacity of the stack.

Step 2: Implement Stack Operations

Push: Adds an element to the top of the stack if it’s not full. If the stack is full, an overflow message is displayed.
Pop: Removes and returns the top element of the stack if it’s not empty. If the stack is empty, an underflow message is displayed.
Peek: Returns the top element without removing it. If the stack is empty, an appropriate message is displayed.
isEmpty: Checks if the stack is empty by verifying if top is -1.
isFull: Checks if the stack is full by verifying if top is maxSize - 1.
Display: Prints all elements currently in the stack.

Output Example

Pushed 10 onto the stack.
Pushed 20 onto the stack.
Pushed 30 onto the stack.
Stack contents: 10 20 30 
Pushed 40 onto the stack.
Stack contents: 10 20 30 40 
Popped 40 from the stack.
Stack contents: 10 20 30 
Peeked at the top element: 30
Stack contents: 10 20 30 
Pushed 50 onto the stack.
Pushed 60 onto the stack.
Stack is full. Unable to push 70
Stack contents: 10 20 30 50 60 
Popped 60 from the stack.
Popped 50 from the stack.
Popped 30 from the stack.
Popped 20 from the stack.
Stack is empty. Unable to pop.
Stack is empty.

Example with Different Stack Size

If you modify the stack size to 3:

Stack stack = new Stack(3); // Create a stack with a maximum size of 3

The output will adjust accordingly, demonstrating the stack’s overflow condition when more than 3 elements are pushed.

Conclusion

This Java program demonstrates how to implement a stack using an array, including handling overflow and underflow conditions. The program efficiently manages stack operations, providing fundamental functionality commonly used in various applications. This exercise is valuable for understanding how to implement and manipulate stacks in Java programming.