Algorithm

  1. Initialize Stack:

    • Create a class for the stack.
    • Define an array to store the elements of the stack.
    • Maintain a variable to keep track of the top of the stack.

  2. Push Operation:

    • Increment the top pointer.
    • Add the new element at the top of the stack.

  3. Pop Operation:

    • Check if the stack is empty (top pointer is -1).
    • If not empty, retrieve the element at the top.
    • Decrement the top pointer.

  4. Peek Operation:

    • Check if the stack is empty.
    • If not empty, return the element at the top without removing it.

  5. isEmpty Operation:

    • Check if the top pointer is -1.

  6. isFull Operation (optional for a fixed-size array-based implementation):

    • Check if the top pointer is equal to the size of the array minus 1.

 

Code Examples

#1 Code Example- Java program to implement Stack

Code - Java Programming

// Stack implementation in Java

class Stack {

  // store elements of stack
  private int arr[];
  // represent top of stack
  private int top;
  // total capacity of the stack
  private int capacity;

  // Creating a stack
  Stack(int size) {
    // initialize the array
    // initialize the stack variables
    arr = new int[size];
    capacity = size;
    top = -1;
  }

  // push elements to the top of stack
  public void push(int x) {
    if (isFull()) {
      System.out.println("Stack OverFlow");

      // terminates the program
      System.exit(1);
    }

    // insert element on top of stack
    System.out.println("Inserting " + x);
    arr[++top] = x;
  }

  // pop elements from top of stack
  public int pop() {

    // if stack is empty
    // no element to pop
    if (isEmpty()) {
      System.out.println("STACK EMPTY");
      // terminates the program
      System.exit(1);
    }

    // pop element from top of stack
    return arr[top--];
  }

  // return size of the stack
  public int getSize() {
    return top + 1;
  }

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

  // check if the stack is full
  public Boolean isFull() {
    return top == capacity - 1;
  }

  // display elements of stack
  public void printStack() {
    for (int i = 0; i  < = top; i++) {
      System.out.print(arr[i] + ", ");
    }
  }

  public static void main(String[] args) {
    Stack stack = new Stack(5);

    stack.push(1);
    stack.push(2);
    stack.push(3);

    System.out.print("Stack: ");
    stack.printStack();

    // remove element from stack
    stack.pop();
    System.out.println("\nAfter popping out");
    stack.printStack();

  }
}
Copy The Code & Try With Live Editor

Output

x
–
+
cmd
Inserting 1
Inserting 2
Inserting 3
Stack: 1, 2, 3,
After popping out
1, 2

#2 Code Example- Implement stack using Stack class

Code - Java Programming

import java.util.Stack;

class Main {
  public static void main(String[] args) {

    // create an object of Stack class
    Stack < String> animals= new Stack<>();

    // push elements to top of stack
    animals.push("Dog");
    animals.push("Horse");
    animals.push("Cat");
    System.out.println("Stack: " + animals);

    // pop element from top of stack
    animals.pop();
    System.out.println("Stack after pop: " + animals);
    }
}
Copy The Code & Try With Live Editor

Output

x
–
+
cmd
Stack: [Dog, Horse, Cat]
Stack after pop: [Dog, Horse]
Advertisements

Demonstration

Java Programing Example to Implement stack data structure-DevsEnv