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

In this article, we will see how to create a data structure that can handle multiple stacks with growable size. The data structure needs to handle three operations:

• push(x, stackNum) = pushes value x to the stack numbered stackNum
• pop(stackNum) = pop the top element from the stack numbered stackNum
• top(stackNum) = shows the topmost element of the stack stackNum.

Example:

Suppose the given multi stack is [{1, 2}, {4, 6}, {9, 10}]

Input: push(3, 0), top(0)
push(7, 1), top(1)
pop(2), top(2)

Output: 3, 7, 9

Explanation: When 3 is pushed in stack 0, the stack becomes {1, 2, 3}. So the top element is 3. 
When 7 is pushed in stack 1, the stack becomes {4, 6, 7}. So the top element is 7.
When topmost element is popped from stack 2, the stack becomes {9}. So the topmost element is 9

Approach: Follow the approach mentioned below to implement the idea. 

• Store the size and the top index of every stack in arrays sizes[] and topIndex[].
• The sizes will be stored in a prefix sum array (using a prefix array sum will help us find the start/size of a stack in O(1) time)
• If the size of a stack reaches the maximum reserved capacity, expand the reserved size (multiply by 2)
• If the size of a stack gets down to a quarter of the reserved size shrink the reserved size (divide it by 2)
• Every time we need to expand/shrink a stack in the data structure, the indexes of other stacks might change so we need to take care of that. That is taken care by incrementing/decrementing value of sizes[] and topIndex[] arrays (we can do that in O(number of stacks) time).

Below is the implementation : 

C++

#include <bits/stdc++.h>
using namespace std;

template <typename T>

// Class to implement multistack
class MultiStack {
    int numberOfStacks;
    vector<T> values;
    vector<int> sizes, topIndex;

public:
    // Constructor to create k stacks
    // (by default 1)
    MultiStack(int k = 1)
        : numberOfStacks(k)
    {
        // reserve 2 elements for each stack first
        values = vector<T>(numberOfStacks << 1);

        // For each stack store the index
        // of the element on the top
        // and the size (starting point)
        sizes = vector<int>(numberOfStacks);
        topIndex = vector<int>(numberOfStacks);

        // Sizes is a prefix sum vector
        for (int size = 2, i = 0; i < numberOfStacks;
             i++, size += 2)
            sizes[i] = size, topIndex[i] = size - 2;
    }

    // Push a value in a stack
    void push(int stackNum, T val)
    {

        // Check if the stack is full,
        // if so Expand it
        if (isFull(stackNum))
            Expand(stackNum);

        // Add the value to the top of the stack
        // and increment the top index
        values[topIndex[stackNum]++] = val;
    }

    // Pop the top value and
    // return it from a stack
    T pop(int stackNum)
    {

        // If the stack is empty
        // throw an error
        if (empty(stackNum))
            throw("Empty Stack!");

        // Save the top value
        T val = values[topIndex[stackNum] - 1];

        // Set top value to default data type
        values[--topIndex[stackNum]] = T();

        // Shrink the reserved size if needed
        Shrink(stackNum);

        // Return the pop-ed value
        return val;
    }

    // Return the top value form a stack
    // Same as pop (but without removal)
    T top(int stackNum)
    {
        if (empty(stackNum))
            throw("Empty Stack!");
        return values[topIndex[stackNum] - 1];
    }

    // Return the size of a stack
    // (the number of elements in the stack,
    // not the reserved size)
    int size(int stackNum)
    {
        if (!stackNum)
            return topIndex[0];
        return topIndex[stackNum] - sizes[stackNum - 1];
    }

    // Check if a stack is empty or not
    // (has no elements)
    bool empty(int stackNum)
    {
        int offset;
        if (!stackNum)
            offset = 0;
        else
            offset = sizes[stackNum - 1];
        int index = topIndex[stackNum];
        return index == offset;
    }

    // Helper function to check
    // if a stack size has reached
    // the reserved size of that stack
    bool isFull(int stackNum)
    {
        int offset = sizes[stackNum];
        int index = topIndex[stackNum];
        return index >= offset;
    }

    // Function to expand the reserved size
    // of a stack (multiply by 2)
    void Expand(int stackNum)
    {

        // Get the reserved_size of the stack()
        int reserved_size = size(stackNum);

        // Update the prefix sums (sizes)
        // and the top index of the next stacks
        for (int i = stackNum + 1; i < numberOfStacks; i++)
            sizes[i] += reserved_size,
                topIndex[i] += reserved_size;

        // Update the size of the recent stack
        sizes[stackNum] += reserved_size;

        // Double the size of the stack by
        // inserting 'reserved_size' elements
        values.insert(values.begin() + topIndex[stackNum],
                      reserved_size, T());
    }

    // 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)
            reserved_size = sizes[0],
            current_size = topIndex[0];
        else
            reserved_size
                = sizes[stackNum] - sizes[stackNum - 1],
                current_size
                = topIndex[stackNum] - sizes[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[i] -= dif, topIndex[i] -= dif;
        sizes[stackNum] -= dif;

        // Erase half of the reserved size
        values.erase(values.begin() + topIndex[stackNum],
                     values.begin() + topIndex[stackNum]
                         + dif);
    }
};

// Driver code
int main()
{
    // create 3 stacks
    MultiStack<int> MStack(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
    cout << MStack.top(0) << '\n';
    cout << MStack.top(1) << '\n';
    cout << MStack.top(2) << '\n';

    return 0;
}

Java

// 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_

Python3

# Python3 implementation for the above approach
class MultiStack:

      def __init__(self, k=1):

        # Initializes the MultiStack with k number of stacks.
        self.number_of_stacks = k

        # Initializes an array to hold values of all stacks.
        self.values = [None] * (self.number_of_stacks * 2)

        # Initializes an array to hold sizes of all stacks.
        self.sizes = [2 + i*2 for i in range(self.number_of_stacks)]

        # Initializes an array to hold the top index of each stack.
        self.top_index = [size-2 for size in self.sizes]

      def push(self, stack_num, val):

          # Pushes a value onto the given stack_num.
          # If the stack is full, expands the stack.
          if self.is_full(stack_num):
              self.expand(stack_num)

          self.values[self.top_index[stack_num]] = val
          self.top_index[stack_num] += 1

      def pop(self, stack_num):

          # Pops the top value off of the given stack_num.
          # If the stack is empty, raises an exception.
          if self.is_empty(stack_num):
              raise Exception("Empty Stack!")

          val = self.values[self.top_index[stack_num]-1]

          self.values[self.top_index[stack_num]-1] = None
          self.top_index[stack_num] -= 1
          self.shrink(stack_num)

          return val

      def top(self, stack_num):

          # Check if the stack is empty
          if self.is_empty(stack_num):
              raise Exception("Empty Stack!")

          # Return the top element of the stack
          return self.values[self.top_index[stack_num]-1]

      def size(self, stack_num):
          # If no stack_num specified, return the
          # total number of elements in all stacks
          if not stack_num:
              return self.top_index[0]

          # Calculate the number of elements in the specified stack
          return self.top_index[stack_num] - self.sizes[stack_num-1]

      def is_empty(self, stack_num):

          # Calculate the index offset for the specified stack
          if not stack_num:
              offset = 0
          else:
              offset = self.sizes[stack_num-1]

          # Check if the stack is empty
          index = self.top_index[stack_num]

          return index == offset

      def is_full(self, stack_num):

          # Calculate the index offset for the specified stack
          offset = self.sizes[stack_num]

          # Check if the stack is full
          index = self.top_index[stack_num]

          return index >= offset

      # This method expands a stack by copying its elements
      # to the next stack(s) and increasing its size
      def expand(self, stack_num):

          # Get the reserved size of the stack
          reserved_size = self.size(stack_num)

          # Increase the size and top index of all the
          # stacks after the current stack
          for i in range(stack_num+1, self.number_of_stacks):
              self.sizes[i] += reserved_size
              self.top_index[i] += reserved_size

          # Increase the size of the current stack
          self.sizes[stack_num] += reserved_size

          # Insert reserved_size None values at the
          # top of the current stack to expand it
          self.values = (self.values[:self.top_index[stack_num]] +
                         [None] * reserved_size +
                         self.values[self.top_index[stack_num]:])

      # This method shrinks a stack by reducing its size
      # and copying its elements to the next stack(s)
      def shrink(self, stack_num):

          # Get the reserved size and current size of the stack
          if not stack_num:
              reserved_size, current_size = self.sizes[0], self.top_index[0]
          else:
              reserved_size = self.sizes[stack_num] - self.sizes[stack_num-1]
              current_size = self.top_index[stack_num] - self.sizes[stack_num-1]

          # Check if the stack should be shrunk
          if current_size * 4 > reserved_size or reserved_size == 2:
              return

          # Calculate the difference to reduce the stack size
          dif = reserved_size // 2

          # Reduce the size and top index of all the stacks after the current stack
          for i in range(stack_num+1, self.number_of_stacks):
              self.sizes[i] -= dif
              self.top_index[i] -= dif

          # Reduce the size of the current stack
          self.sizes[stack_num] -= dif

          # Remove dif elements from the top of the current stack to shrink it
          self.values = (self.values[:self.top_index[stack_num]-dif] +
                         self.values[self.top_index[stack_num]:])

# create 3 stacks
MStack = 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
print(MStack.top(0))
print(MStack.top(1))
print(MStack.top(2))

# This code is contributed by amit_mangal_

C#

using System;
using System.Collections.Generic;

public class MultiStack<T> {
    private int numberOfStacks; // Number of stacks in the
                                // MultiStack
    private List<T> values; // List to store all the values
                            // of the stacks
    private List<int>
        sizes; // List to store the sizes of each stack
    private List<int> topIndexes; // List to store the top
                                  // indexes of each stack

    // Constructor to create a MultiStack with 'k' stacks
    // (default is 1)
    public MultiStack(int k = 1)
    {
        numberOfStacks = k;
        values = new List<T>();
        sizes = new List<int>(new int[k]);
        topIndexes = new List<int>(new int[k]);
    }

    // Push a value onto a specific stack
    public void Push(int stackNum, T val)
    {
        if (stackNum < 0 || stackNum >= numberOfStacks) {
            throw new ArgumentOutOfRangeException(
                "Invalid stack number");
        }

        // Add the value to the main list
        values.Add(val);

        // Increase the size of the stack
        sizes[stackNum]++;

        // Update the top index for this stack
        topIndexes[stackNum] = values.Count - 1;
    }

    // Pop a value from a specific stack
    public T Pop(int stackNum)
    {
        if (stackNum < 0 || stackNum >= numberOfStacks) {
            throw new ArgumentOutOfRangeException(
                "Invalid stack number");
        }

        if (IsEmpty(stackNum)) {
            throw new InvalidOperationException(
                "Stack is empty");
        }

        // Get the index of the top element of the stack
        int index = topIndexes[stackNum];

        // Get the value at this index
        T val = values[index];

        // Remove the value from the main list
        values.RemoveAt(index);

        // Decrease the size of the stack
        sizes[stackNum]--;

        // Update top indexes for the remaining stacks
        UpdateTopIndexes(stackNum, index);

        // Return the popped value
        return val;
    }

    // Get the top value of a specific stack
    public T Top(int stackNum)
    {
        if (stackNum < 0 || stackNum >= numberOfStacks) {
            throw new ArgumentOutOfRangeException(
                "Invalid stack number");
        }

        if (IsEmpty(stackNum)) {
            throw new InvalidOperationException(
                "Stack is empty");
        }

        // Return the value at the top index of this stack
        return values[topIndexes[stackNum]];
    }

    // Get the size of a specific stack
    public int Size(int stackNum)
    {
        if (stackNum < 0 || stackNum >= numberOfStacks) {
            throw new ArgumentOutOfRangeException(
                "Invalid stack number");
        }

        // Return the size of this stack
        return sizes[stackNum];
    }

    // Check if a specific stack is empty
    public bool IsEmpty(int stackNum)
    {
        if (stackNum < 0 || stackNum >= numberOfStacks) {
            throw new ArgumentOutOfRangeException(
                "Invalid stack number");
        }

        // Check if the size of this stack is 0
        return sizes[stackNum] == 0;
    }

    // Update the top indexes of stacks after a pop
    // operation
    private void UpdateTopIndexes(int stackNum,
                                  int removedIndex)
    {
        for (int i = stackNum; i < numberOfStacks; i++) {
            // Decrement the top index if it's greater than
            // the removed index
            if (topIndexes[i] > removedIndex) {
                topIndexes[i]--;
            }
        }
    }
}

class Program {
    static void Main()
    {
        // Create an instance of MultiStack with 3 stacks
        MultiStack<int> MStack = new MultiStack<int>(3);

        // Push elements into different stacks
        MStack.Push(0, 21);
        MStack.Push(0, 13);
        MStack.Push(0, 14);

        MStack.Push(1, 15);

        MStack.Push(2, 1);
        MStack.Push(2, 2);
        MStack.Push(2, 3);

        // Print the tops of each stack
        Console.WriteLine("Top of Stack 0: "
                          + MStack.Top(0));
        Console.WriteLine("Top of Stack 1: "
                          + MStack.Top(1));
        Console.WriteLine("Top of Stack 2: "
                          + MStack.Top(2));
    }
}

Javascript

class MultiStack {
    constructor(k = 1) {
        this.numberOfStacks = k;
        this.values = new Array(k * 2).fill(0);
        this.sizes = new Array(k).fill(0);
        this.topIndex = new Array(k).fill(0);

        // Sizes is a prefix sum array
        for (let size = 2, i = 0; i < this.numberOfStacks; i++, size += 2) {
            this.sizes[i] = size;
            this.topIndex[i] = size - 2;
        }
    }

    push(stackNum, val) {
        if (this.isFull(stackNum)) {
            this.expand(stackNum);
        }

        this.values[this.topIndex[stackNum]++] = val;
    }

    pop(stackNum) {
        if (this.empty(stackNum)) {
            throw new Error("Empty Stack!");
        }

        const val = this.values[this.topIndex[stackNum] - 1];
        this.values[--this.topIndex[stackNum]] = 0;
        this.shrink(stackNum);

        return val;
    }

    top(stackNum) {
        if (this.empty(stackNum)) {
            throw new Error("Empty Stack!");
        }

        return this.values[this.topIndex[stackNum] - 1];
    }

    size(stackNum) {
        if (!stackNum) {
            return this.topIndex[0];
        }
        return this.topIndex[stackNum] - this.sizes[stackNum - 1];
    }

    empty(stackNum) {
        const offset = !stackNum ? 0 : this.sizes[stackNum - 1];
        const index = this.topIndex[stackNum];
        return index === offset;
    }

    isFull(stackNum) {
        const offset = this.sizes[stackNum];
        const index = this.topIndex[stackNum];
        return index >= offset;
    }

    expand(stackNum) {
        const reservedSize = this.size(stackNum);

        for (let i = stackNum + 1; i < this.numberOfStacks; i++) {
            this.sizes[i] += reservedSize;
            this.topIndex[i] += reservedSize;
        }

        this.sizes[stackNum] += reservedSize;

        const reservedArray = new Array(reservedSize).fill(0);
        this.values.splice(this.topIndex[stackNum], 0, ...reservedArray);
    }

    shrink(stackNum) {
        let reservedSize, currentSize;
        if (!stackNum) {
            reservedSize = this.sizes[0];
            currentSize = this.topIndex[0];
        } else {
            reservedSize = this.sizes[stackNum] - this.sizes[stackNum - 1];
            currentSize = this.topIndex[stackNum] - this.sizes[stackNum - 1];
        }

        if (currentSize * 4 > reservedSize || reservedSize === 2) {
            return;
        }

        const difference = reservedSize / 2;

        for (let i = stackNum + 1; i < this.numberOfStacks; i++) {
            this.sizes[i] -= difference;
            this.topIndex[i] -= difference;
        }

        this.sizes[stackNum] -= difference;

        this.values.splice(
            this.topIndex[stackNum],
            difference,
        );
    }
}

// Driver code
const MStack = new MultiStack(3);

MStack.push(0, 21);
MStack.push(0, 13);
MStack.push(0, 14);

MStack.push(1, 15);

MStack.push(2, 1);
MStack.push(2, 2);
MStack.push(2, 3);

console.log(MStack.top(0));
console.log(MStack.top(1));
console.log(MStack.top(2));

Output

14
15
3

Time complexities:

• O(1) for top() function.
• Amortized O(1) for push() and pop() functions.

Auxiliary Space: O(N) where N is the number of stacks