Implement Dynamic Multi Stack (K stacks) using only one Data Structure

// Java implementation for the above approach

import java.util.*;

class MultiStack<T> {
  private int numberOfStacks;
  private ArrayList<T> values;
  private ArrayList<Integer> sizes, topIndex;

  // Constructor for MultiStack
  // Takes the number of stacks (k) as input and initializes the MultiStack object
  public MultiStack(int k) {
    
    // Set the number of stacks
    numberOfStacks = k;
    
    // Initialize the values ArrayList with an initial capacity of k*2
    values = new ArrayList<>(numberOfStacks << 1);
    
    // Initialize the sizes ArrayList with a size of k
    sizes = new ArrayList<>(numberOfStacks);
    
    // Initialize the topIndex ArrayList with a size of k
    topIndex = new ArrayList<>(numberOfStacks);

      // Loop through k times
      for (int size = 2, i = 0; i < numberOfStacks; i++, size += 2) {
        
          // Add size to the sizes ArrayList
          sizes.add(size);
        
          // Add size-2 to the topIndex ArrayList
          topIndex.add(size - 2);
      }
  }

  // Push a value onto a specified stack
  public void push(int stackNum, T val) {
    
    // If the stack is full, expand it
    if (isFull(stackNum))
        Expand(stackNum);

    // Add the value to the ArrayList at the index 
    // specified by the topIndex of the specified stack
    values.add(topIndex.get(stackNum), val);
    
    // Increment the topIndex of the specified stack
    topIndex.set(stackNum, topIndex.get(stackNum) + 1);
  }

  // Pop a value off a specified stack
  public T pop(int stackNum) {
    
    // If the stack is empty, throw an exception
    if (empty(stackNum))
        throw new RuntimeException("Empty Stack!");

    // Get the value at the top of the specified stack
    T val = values.get(topIndex.get(stackNum) - 1);
    
    // Set the value at the top of the specified stack to null
    values.set(topIndex.get(stackNum) - 1, null);
    
    // Decrement the topIndex of the specified stack
    topIndex.set(stackNum, topIndex.get(stackNum) - 1);

    // Shrink the specified stack if necessary
    shrink(stackNum);

    // Return the value at the top of the specified stack
    return val;

  }

  // Returns the element at the top of the specified stack
  public T top(int stackNum) {
    
    if (empty(stackNum))
        throw new RuntimeException("Empty Stack!");
    
    return values.get(topIndex.get(stackNum) - 1);
  }

  // Returns the number of elements in the specified stack
  public int size(int stackNum) {
    
  if (stackNum == 0)
      return topIndex.get(0);
    
  return topIndex.get(stackNum) - sizes.get(stackNum - 1);
  }

  // Checks if the specified stack is empty
  public boolean empty(int stackNum) {
    
    int offset;
    
    if (stackNum == 0)
        offset = 0;
    else
        offset = sizes.get(stackNum - 1);
    
    int index = topIndex.get(stackNum);
    return index == offset;
  }

  // Checks if the specified stack is full
  public boolean isFull(int stackNum) {
    
    int offset = sizes.get(stackNum);
    int index = topIndex.get(stackNum);
    return index >= offset;
  }


  public void Expand(int stackNum) {
      int reserved_size = size(stackNum);

      for (int i = stackNum + 1; i < numberOfStacks; i++) {
          sizes.set(i, sizes.get(i) + reserved_size);
          topIndex.set(i, topIndex.get(i) + reserved_size);
      }

      sizes.set(stackNum, sizes.get(stackNum) + reserved_size);

      for (int i = 0; i < reserved_size; i++)
          values.add(topIndex.get(stackNum), null);
  }

  // Function to shrink the reserved size
  // of a stack (divide by2)
  void shrink(int stackNum) {

      // Get the reserved size and the current size
      int reserved_size, current_size;
      if (stackNum == 0) {
        reserved_size = sizes.get(0);
        current_size = topIndex.get(0);
      } else {

          reserved_size = sizes.get(stackNum) - sizes.get(stackNum - 1);
          current_size = topIndex.get(stackNum) - sizes.get(stackNum - 1);
      }

      // Shrink only if the size is
      // lower than a quarter of the
      // reserved size and avoid shrinking
      // if the reserved size is 2
      if (current_size * 4 > reserved_size || reserved_size == 2) {
          return;
      }

      // Divide the size by 2 and update
      // the prefix sums (sizes) and
      // the top index of the next stacks
      int dif = reserved_size / 2;
      for (int i = stackNum + 1; i < numberOfStacks; i++) {
        sizes.set(i, sizes.get(i) - dif);
        topIndex.set(i, topIndex.get(i) - dif);
      }
      sizes.set(stackNum, sizes.get(stackNum) - dif);

      // Erase half of the reserved size
      values.subList(topIndex.get(stackNum), topIndex.get(stackNum) + dif).clear();
  }

  // Driver code
  public static void main(String[] args) {
    
  // create 3 stacks
  MultiStack<Integer> MStack = new MultiStack<>(3);
    
  // push elements in stack 0:
  MStack.push(0, 21);
  MStack.push(0, 13);
  MStack.push(0, 14);

  // Push one element in stack 1:
  MStack.push(1, 15);

  // Push two elements in stack 2:
  MStack.push(2, 1);
  MStack.push(2, 2);
  MStack.push(2, 3);

  // Print the top elements of the stacks
  System.out.println(MStack.top(0));
  System.out.println(MStack.top(1));
  System.out.println(MStack.top(2));
  }
};

// This code is contributed by amit_mangal_