Stack implemented as array - Data Structure

// Stack implemented as array
public class ArrayStack<T> {
     private T[] stack;
     private int numElements = 0; // points to slot after top element

     public ArrayStack(T[] s) { stack = s; }  

     public boolean emptyStack() { 
         return numElements == 0; }
   
     public T  top() {
         return stack[numElements-1];
       }

     public void push(T x) {
         stack[numElements] = x;
         numElements++;
       }
  
     public T pop() {
         numElements--;
         return stack[numElements];
      }

    public static void main(String[] args) {
       ArrayStack<Integer> s = new ArrayStack<Integer>(new Integer[100]);
       s.push(2);
       s.push(3);
       s.push(5);
       System.out.println(s.top());
       System.out.println(s.pop());
       System.out.println(s.pop());
       s.push(15);
       s.push(22);
       System.out.println(s.pop());
   }
}

[ Read More ]

Demonstrate the Stack Class

Here is a Java Program to Demonstrate the Stack class.

import java.util.*;
 
class StackDemo {
  static void showpush(Stack st, int a) {
    st.push(new Integer(a));
    System.out.println("push(" + a + ")");
    System.out.println("stack: " + st);
  }

  static void showpop(Stack st) {
    System.out.print("pop -> ");
    Integer a = (Integer) st.pop();
    System.out.println(a);
    System.out.println("stack: " + st);
  }

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

    System.out.println("stack: " + st);
    showpush(st, 42);
    showpush(st, 66);
    showpush(st, 99);
    showpop(st);
    showpop(st);
    showpop(st);
    try {
      showpop(st);
    } catch (EmptyStackException e) {
      System.out.println("empty stack");
    }
  }
}

Output of Above Java Program
stack: Stack@19821f
push(42)
stack: Stack@19821f
push(66)
stack: Stack@19821f
push(99)
stack: Stack@19821f
pop -> 99
stack: Stack@19821f
pop -> 66
stack: Stack@19821f
pop -> 42
stack: Stack@19821f
pop -> Stack underflow.
0
stack: Stack@19821f

[ Read More ]

Java class that defines an integer stack that can hold 10 values

Here is a Java class that defines an integer stack that can hold 10 values.

class Stack {
  int stck[] = new int[10];
  int tos;
  
  // Initialize top-of-stack
  Stack() {
    tos = -1;
  }

  // Push an item onto the stack
  void push(int item) {
    if(tos==9) 
      System.out.println("Stack is full.");
    else 
      stck[++tos] = item;
  }

  // Pop an item from the stack
  int pop() {
    if(tos < 0) {
      System.out.println("Stack underflow.");
      return 0;
    }
    else 
      return stck[tos--];
  }
}

Here is a Main Class to run Above Java Class

class TestStack {
  public static void main(String args[]) {
    Stack mystack1 = new Stack();
    Stack mystack2 = new Stack();

    // push some numbers onto the stack
    for(int i=0; i<10; i++) mystack1.push(i);
    for(int i=10; i<20; i++) mystack2.push(i);

    // pop those numbers off the stack
    System.out.println("Stack in mystack1:");
    for(int i=0; i<10; i++) 
       System.out.println(mystack1.pop());

    System.out.println("Stack in mystack2:");
    for(int i=0; i<10; i++) 
       System.out.println(mystack2.pop());
  }
}

Output of Above Java Program
Stack in mystack1:
9
8
7
6
5
4
3
2
1
0
Stack in mystack2:
19
18
17
16
15
14
13
12
11
10

[ Read More ]

Demonstrate the operation of Stack implementation

Define a generic Stack<> type with a method push() that adds the object that is passed as an argument to the top of the stack, and with a method pop() that removes and returns the object that is currently at the top of the stack. The pop() method should return null when the stack is empty. Demonstrate the operation of your Stack<> implementation by storing and retrieving 10 strings and 10 Double objects in stacks of a suitable type.

 A stack is a container that stores objects in a manner indicated by its name in a vertical stack where only the object at the top of the stack is accessible. It works rather like a sprung stack of plates in a cafeteria. Only the top plate is at counter level and, therefore, is the only one you can access. When you add a plate to the stack, the existing plates are pushed down so the new plate is now the one that you can access.

public class Stack<T> {
  public Stack() {
    items = new Object[initialCapacity];
  }

  // Push an item onto the stack
  public void push(T item) {
    if(itemCount==items.length) {
      Object[] newItems = new Object[items.length + increment];
      for(int i = 0 ; i < items.length ; ++i) {
        newItems[i] = items[i];
      }
      items = newItems;
    }
    items[itemCount++] = item;
  }

  // Pop an item off the top of the stack
  @SuppressWarnings("unchecked")
  public T pop() {
    if(itemCount == 0) {
      return null;
    }
    // Note: the annotation ensures this cast to type T will not result
    // in a warning from the compiler.
    T item = (T)items[--itemCount];
    items[itemCount] = null;                                           // Erase the object from the stack
    return item;
  }

  // Test for empty stack
  public boolean isEmpty() {
    return itemCount == 0;
  }

  // You cannot define an array of a parametric type T.
  // To store items in the stack of an arbitrary you can use type Object[]
  private Object[] items;                                              // Array to store items in the stack
  private int itemCount;                                               // Number of items in the stack

  private final static int initialCapacity = 10;                       // Initial stack capacity
  private final static int increment = 5;                              // Capacity increment when full
}

This is main Class to Test Above Java Class "Stack".

public class TryStack {
  public static void main(String[] args) {
    // Values to be stored in stack and then retrieved
    double[] values = { 1.0, 1.4142 , 1.732 , 2.0, 2.236, 2.449, 2.646, 2.828, 3.0, 3.162 };

    Stack<Double> data = new Stack<Double>();

    // Store the values on the stack
    System.out.println("Data pushed onto the stack in sequence is:");
    for(double v : values) {
      System.out.println(v);
      data.push(v);
    }

    double back = 0;
    System.out.println("\nData retrieved from the stack in sequence is:");
    while(!data.isEmpty()) {
      System.out.println(data.pop());
    }

    System.out.println("The stack should now be empty. Popping an item produces: " + data.pop());
  }
}

Output of Above Java Program
Data pushed onto the stack in sequence is:
1.0
1.4142
1.732
2.0
2.236
2.449
2.646
2.828
3.0
3.162

Data retrieved from the stack in sequence is:
3.162
3.0
2.828
2.646
2.449
2.236
2.0
1.732
1.4142
1.0
The stack should now be empty. Popping an item produces: null

[ Read More ]