Introduction to Stacks

What is a Stack?

A stack is a linear data structure that follows the Last-In-First-Out (LIFO) principle. This means that the last element added to the stack is the first one to be removed. Think of a stack like a pile of plates — you add plates to the top and remove them from the top.

In the visualization above, you can see a simple stack with four elements. The top of the stack is at the top of the visualization, and the bottom is at the bottom. When we add a new element, it goes on top. When we remove an element, it comes from the top.

The LIFO Principle

The defining characteristic of a stack is its LIFO (Last-In-First-Out) behavior. This means:

• The last element added to the stack will be the first element removed.
• Elements can only be added to or removed from the "top" of the stack.
• Access to other elements in the stack is restricted — you can't access elements in the middle without first removing the elements on top.

Basic Stack Operations

• Push: Add an element to the top of the stack.
• Pop: Remove the top element from the stack.
• Peek/Top: View the top element without removing it.
• isEmpty: Check if the stack is empty.
• Size: Get the number of elements in the stack.

Stack Implementation Overview

There are two common ways to implement a stack:

In this tutorial, we'll focus on the array-based implementation as it's more straightforward and commonly used.

class Stack {
  constructor() {
    this.items = [];  // Initialize empty array to store elements
  }
 
  // Core operations will be implemented in the following sections
  push(element) { /* Add element to the top */ }
  pop() { /* Remove and return the top element */ }
  peek() { /* Return the top element without removing it */ }
  
  // Utility methods
  isEmpty() {
    return this.items.length === 0;
  }
  
  size() {
    return this.items.length;
  }
}

Advantages and Disadvantages

Check Your Understanding