Stacks for Complete Beginners

A stack is a way to organize data so the last item you put in is the first item you take out. Think of a pile of plates: you place a plate on top and remove from the top. This rule is called LIFO (Last In, First Out). Core actions are: push (add to top), pop (remove top), peek (look at top), isEmpty, size, and clear.

JavaScript Implementation


// Stack implemented with Object Oriented JavaScript
class Stack {
  constructor() {
    this._items = []; // private-by-convention
  }

  // Add an item to the top (O(1))
  push(value) {
    this._items.push(value);
    return this.size(); // often useful to return new size
  }

  // Remove the top item and return it (O(1))
  pop() {
    if (this.isEmpty()) return null;
    return this._items.pop();
  }

  // Look at the top item without removing (O(1))
  peek() {
    if (this.isEmpty()) return null;
    return this._items[this._items.length - 1];
  }

  // Is the stack empty? (O(1))
  isEmpty() {
    return this._items.length === 0;
  }

  // How many items? (O(1))
  size() {
    return this._items.length;
  }

  // Remove all items (O(n) due to memory cleanup, but fast in practice)
  clear() {
    this._items.length = 0;
  }

  // Optional helper for debugging or display
  toArray() {
    // Returns a shallow copy from bottom -> top
    return this._items.slice();
  }
}

// Example usage:
const stack = new Stack();
stack.push("plate A");
stack.push("plate B");
console.log(stack.peek());    // "plate B"
console.log(stack.pop());     // "plate B"
console.log(stack.size());    // 1
console.log(stack.isEmpty()); // false
stack.clear();
console.log(stack.isEmpty()); // true

Complete Explanation of the Code

class Stack { ... } defines a blueprint for stack objects. Each instance manages its own items.
constructor() runs once on new Stack() and initializes an empty internal array _items to hold values.
push(value) appends value to the end of _items (the “top” of the stack) and returns the updated size().
pop() first checks isEmpty(); if empty, returns null. Otherwise it removes and returns the last element with _items.pop().
peek() returns the last element (_items[_items.length - 1]) without removing it; if empty, returns null.
isEmpty() returns true when there are no elements (_items.length === 0), else false.
size() returns the number of elements stored (_items.length).
clear() empties the stack by setting _items.length = 0, removing all elements.
toArray() returns a shallow copy of the current contents so callers can inspect items safely without mutating the stack.
Example usage demonstrates pushing two items, peeking, popping the top, checking size/emptiness, and clearing.

Performance Note: push, pop, peek, isEmpty, and size are O(1). clear discards all items and is O(n) overall, but the in-place length = 0 approach is very fast in practice.

Standard Pseudocode


CLASS Stack
  PRIVATE items AS LIST

  PROCEDURE Constructor
    INITIALIZE items AS empty LIST
  END PROCEDURE

  PROCEDURE Push(value)
    CALL append value TO items
    RETURN Size()
  END PROCEDURE

  FUNCTION Pop RETURNS ANY
    IF Size() = 0 THEN
      RETURN null
    END IF
    SET top TO last element OF items
    REMOVE last element FROM items
    RETURN top
  END FUNCTION

  FUNCTION Peek RETURNS ANY
    IF Size() = 0 THEN
      RETURN null
    END IF
    RETURN last element OF items
  END FUNCTION

  FUNCTION IsEmpty RETURNS BOOLEAN
    RETURN (Size() = 0)
  END FUNCTION

  FUNCTION Size RETURNS INTEGER
    RETURN length OF items
  END FUNCTION

  PROCEDURE Clear
    SET items TO empty LIST
  END PROCEDURE

  FUNCTION ToArray RETURNS LIST
    RETURN copy OF items FROM bottom TO top
  END FUNCTION
END CLASS

Explanation of the Pseudocode

CLASS / END CLASS defines the Stack and where it ends.
PRIVATE items AS LIST stores the data; only Stack’s own routines should modify it.
Constructor INITIALIZEs the list so the stack starts empty.
Push(value) appends a value to the end (the top) and RETURNs the new Size().
Pop checks emptiness; IF empty THEN RETURN null. Otherwise it remembers the last element, removes it, and returns it.
Peek returns the last element without removing it; if empty, returns null.
IsEmpty returns true when Size() equals 0, otherwise false.
Size returns the count of elements in items.
Clear resets the structure by setting items to an empty list.
ToArray returns a copy so callers can view the contents (from bottom to top) safely.