Data Structures & AlgorithmsStack Operations & Interface

Stack Operations & Interface

LevelBeginner

Duration55 mins

TopicStack Operations & Interface

5 / 5

Size — Number of Elements

Knowing the Magnitude of Your Stack

While isEmpty() tells you whether the stack has any elements, sometimes you need to know how many. How deep is this recursion? How many undo operations have accumulated? Are we approaching capacity?

The size operation (also called count, length, or depth in various contexts) returns the exact number of elements currently in the stack. This quantitative information enables capacity management, progress tracking, and algorithms that need to know the stack's magnitude, not just its emptiness.

What You Will Learn

By the end of this page, you will understand the size operation's semantics and contract, how it compares to isEmpty, its implementation across array and linked list representations, the importance of O(1) size tracking, capacity-related considerations, and practical use cases where size provides value beyond simple emptiness checks.

What Size Means Conceptually

The size operation returns the number of elements currently stored in the stack. It's a non-negative integer that changes predictably with push and pop:

After each push(), size increases by 1
After each pop(), size decreases by 1
peek() and isEmpty() don't change size
A newly created stack has size 0

The invariant:

size() === (number of push operations) - (number of pop operations)

This relationship holds from the moment the stack is created, providing a simple mental model for tracking size.

Size Tracking Through Operations
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Operation          Stack State          size()    Change
─────────────────────────────────────────────────────────────
(initial)          []                   0         -
push(A)            [A]                  1         +1
push(B)            [A, B]               2         +1
push(C)            [A, B, C]            3         +1
peek()             [A, B, C]            3         (no change)
pop()              [A, B]               2         -1
isEmpty()          [A, B]               2         (no change)
push(D)            [A, B, D]            3         +1
pop()              [A, B]               2         -1
pop()              [A]                  1         -1
pop()              []                   0         -1
pop()              (error)              -         (blocked by underflow)
 
Note: size() can never become negative. 
      Attempting to pop when size is 0 results in an error, not -1.

Size is Always Non-Negative

By definition, a stack cannot have a negative number of elements. The minimum size is 0 (empty stack). Any implementation that allows negative size has a bug. This is a fundamental invariant to maintain.

The relationship with isEmpty:

isEmpty() === true   ⟺   size() === 0
isEmpty() === false  ⟺   size() > 0
isEmpty() === !Boolean(size())  // In JavaScript

These are logically equivalent, but each has its place. isEmpty is preferred when you only care about emptiness; size is preferred when you need the count.

The Size Contract — Preconditions and Postconditions

Like isEmpty, size is a pure observation operation with no preconditions and no side effects. It simply reports the current element count.

Size Operation Contract

•Precondition: None. size() can be called on any stack at any time.
•Postcondition #1: Returns a non-negative integer representing the number of elements.
•Postcondition #2: The stack is completely unchanged after the call.
•Consistency: If no push/pop occurs between calls, size() returns the same value.
•Idempotency: Calling size() multiple times has no cumulative effect.
•No failure mode: size() never throws or errors—it always returns a valid integer.

Size Contract Summary
Aspect	Description
Input	None
Output	Non-negative integer (0, 1, 2, ...)
Side Effect	None — purely observational
Time Guarantee	O(1) with proper implementation
Space Guarantee	O(1) — no allocations
Failure Mode	None — always succeeds

Size and isEmpty Are Both Safe

Like isEmpty, size() can never fail. Both are pure queries that observe state without risk. Unlike peek() and pop() which fail on empty stacks, size() and isEmpty() are always safe to call. Use them liberally for defensive checks.

Size Implementation — Array-Based Stack

In an array-based stack, size is derived directly from topIndex. Since topIndex represents the index of the top element (with -1 meaning empty), the size is simply topIndex + 1.

ArrayStack.ts - Size Method
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
class ArrayStack<T> {
    private items: T[];
    private topIndex: number;
    private capacity: number;
 
    constructor(capacity: number = 1000) {
        this.items = new Array<T>(capacity);
        this.topIndex = -1;  // -1 indicates empty stack
        this.capacity = capacity;
    }
 
    /**
     * Size: Return the number of elements in the stack
     * 
     * Time Complexity: O(1)
     * Space Complexity: O(1)
     * 
     * @returns Non-negative integer representing element count
     */
    size(): number {
        return this.topIndex + 1;
    }
 
    /**
     * Alternative: if we track size separately
     * (redundant with topIndex, but common in other implementations)
     */
    // private _size: number = 0;
    // 
    // size(): number {
    //     return this._size;
    // }
 
    /**
     * isEmpty derived from size (showing the relationship)
     */
    isEmpty(): boolean {
        return this.size() === 0;
        // Equivalent to: return this.topIndex < 0;
    }
 
    /**
     * Capacity: maximum number of elements (for bounded stacks)
     */
    getCapacity(): number {
        return this.capacity;
    }
 
    /**
     * Check if stack is full
     */
    isFull(): boolean {
        return this.size() >= this.capacity;
        // Equivalent to: return this.topIndex >= this.capacity - 1;
    }
 
    /**
     * Remaining capacity
     */
    remainingCapacity(): number {
        return this.capacity - this.size();
    }
}

Why topIndex + 1?

Array indices are 0-based, so:

Empty stack: topIndex = -1, size = -1 + 1 = 0 ✓
One element: topIndex = 0, size = 0 + 1 = 1 ✓
Five elements: topIndex = 4, size = 4 + 1 = 5 ✓

The formula correctly converts the last occupied index to a count.

Size Calculation Examples
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
State: items = [10, 20, 30, _, _, ...]
        topIndex = 2
 
size() = topIndex + 1 = 2 + 1 = 3
 
Verification: Elements at indices 0, 1, 2 → three elements ✓
 
─────────────────────────────────────────
 
State: items = [_, _, _, _, _, ...]
        topIndex = -1
 
size() = topIndex + 1 = -1 + 1 = 0
 
Verification: No elements → zero ✓

Single Source of Truth

In array-based stacks, topIndex serves as the single source of truth for size. We derive size from topIndex rather than maintaining a separate count. This prevents synchronization bugs—there's only one value to update on push/pop.

Size Implementation — Linked List-Based Stack

In a linked list-based stack, size can be computed in two ways:

Count on demand (O(n)): Traverse the list and count nodes each time size() is called.
Track count (O(1)): Maintain a count variable, updating it on push (+1) and pop (-1).

The second approach is strongly preferred for performance. Let's examine both.

LinkedListStack.ts - Size Methods
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
class StackNode<T> {
    value: T;
    next: StackNode<T> | null;
 
    constructor(value: T) {
        this.value = value;
        this.next = null;
    }
}
 
class LinkedListStack<T> {
    private head: StackNode<T> | null;
    private _count: number;  // Tracked on each push/pop
 
    constructor() {
        this.head = null;
        this._count = 0;
    }
 
    /**
     * Size: Return the number of elements in the stack
     * 
     * Time Complexity: O(1) — using tracked count
     * Space Complexity: O(1)
     */
    size(): number {
        return this._count;
    }
 
    /**
     * BAD Alternative: Compute size by traversing (O(n))
     * Don't use this! Included only to show why tracking is better.
     */
    sizeByTraversal(): number {
        let count = 0;
        let current = this.head;
        while (current !== null) {
            count++;
            current = current.next;
        }
        return count;
        // This is O(n) every time size() is called — inefficient!
    }
 
    /**
     * Push: Add element and increment count
     */
    push(element: T): void {
        const newNode = new StackNode(element);
        newNode.next = this.head;
        this.head = newNode;
        this._count++;  // O(1) update keeps size() O(1)
    }
 
    /**
     * Pop: Remove element and decrement count
     */
    pop(): T {
        if (this.head === null) {
            throw new Error("Stack underflow");
        }
        const value = this.head.value;
        this.head = this.head.next;
        this._count--;  // O(1) update keeps size() O(1)
        return value;
    }
 
    /**
     * isEmpty using tracked count
     */
    isEmpty(): boolean {
        return this._count === 0;
        // Equivalent to: return this.head === null;
    }
}

Size Implementation Comparison
Approach	Time Complexity	Space Overhead	Pros	Cons
Traversal	O(n)	None	No extra state to maintain	Slow for large stacks; repeated calls are wasteful
Tracked count	O(1)	One integer	Fast, constant-time	Must update on every push/pop (easy to forget)

Always Track Count

Never implement size() as O(n) traversal in production code. Users expect size() to be O(1)—like isEmpty(), it's a simple query. An O(n) size() can cause unexpected performance degradation in algorithms that call it frequently, such as in loop conditions.

Size in the Context of Capacity

For bounded stacks (fixed-size array implementation), size and capacity form a pair:

Size: Current number of elements
Capacity: Maximum number of elements the stack can hold

The relationship size ≤ capacity must always hold. When size === capacity, the stack is full, and push operations will fail.

CapacityAwareStack.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
class BoundedStack<T> {
    private items: T[];
    private topIndex: number;
    private capacity: number;
 
    constructor(capacity: number) {
        this.items = new Array<T>(capacity);
        this.topIndex = -1;
        this.capacity = capacity;
    }
 
    size(): number {
        return this.topIndex + 1;
    }
 
    getCapacity(): number {
        return this.capacity;
    }
 
    /**
     * Check if stack is full
     * This is the 'capacity guard' — the complement to isEmpty
     */
    isFull(): boolean {
        return this.size() >= this.capacity;
    }
 
    /**
     * How many more elements can be pushed?
     */
    remainingCapacity(): number {
        return this.capacity - this.size();
    }
 
    /**
     * What percentage of capacity is used?
     */
    usagePercentage(): number {
        return (this.size() / this.capacity) * 100;
    }
 
    /**
     * Push with capacity check
     */
    push(element: T): boolean {
        if (this.isFull()) {
            return false;  // Or throw an error
        }
        this.topIndex++;
        this.items[this.topIndex] = element;
        return true;
    }
 
    /**
     * Attempt to push multiple elements
     * Returns number successfully pushed
     */
    pushMany(elements: T[]): number {
        let pushed = 0;
        for (const element of elements) {
            if (this.isFull()) break;
            this.push(element);
            pushed++;
        }
        return pushed;
    }
}
 
// Usage example:
const stack = new BoundedStack<number>(100);
console.log(stack.size());              // 0
console.log(stack.getCapacity());       // 100
console.log(stack.remainingCapacity()); // 100
console.log(stack.isFull());            // false
 
for (let i = 0; i < 100; i++) {
    stack.push(i);
}
 
console.log(stack.size());              // 100
console.log(stack.remainingCapacity()); // 0
console.log(stack.isFull());            // true
console.log(stack.push(999));           // false (failed)

Unbounded Stacks

Linked list stacks and dynamic array stacks have no fixed capacity—they grow until memory is exhausted. In these cases, getCapacity() might return Infinity or throw 'not applicable.' The concept of 'full' doesn't apply, only 'out of memory.'

Practical Use Cases for Size

While isEmpty covers most 'is it empty?' checks, size() is needed for more sophisticated scenarios involving counts, limits, and thresholds.

When Size Matters

•Capacity management: Checking if there's room for N more elements: stack.size() + n <= capacity
•Progress tracking: 'Processed 47 of 100 items' — knowing how many remain (e.g., in undo stacks)
•Depth limiting: Preventing stack overflow by checking: if (callStack.size() >= MAX_DEPTH) throw new Error('Too deep')
•Resource monitoring: Logging or alerting when stack size exceeds thresholds for debugging
•Comparison operations: Checking if two stacks have the same number of elements
•Batch operations: 'Pop at most N elements' or 'Push these only if size stays below limit'
•Stack-based algorithms: Some algorithms need to know the depth, not just emptiness (e.g., expression balance counting)

SizeUseCaseExamples.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
// Use Case 1: Depth-limited recursion simulation
function limitedDFS(root: Node, maxDepth: number): void {
    const stack: Array<{node: Node, depth: number}> = [];
    stack.push({node: root, depth: 0});
    
    while (stack.length > 0) {
        const {node, depth} = stack.pop()!;
        
        // SIZE-BASED LIMIT: Don't go deeper than maxDepth
        if (depth >= maxDepth) continue;
        
        process(node);
        for (const child of node.children) {
            stack.push({node: child, depth: depth + 1});
        }
    }
}
 
// Use Case 2: Progress reporting for undo system
class UndoManager {
    private undoStack: Action[] = [];
    private maxUndoSize: number = 100;
    
    recordAction(action: Action): void {
        this.undoStack.push(action);
        // SIZE-BASED LIMIT: Prevent unlimited memory usage
        if (this.undoStack.length > this.maxUndoSize) {
            this.undoStack.shift();  // Remove oldest
        }
    }
    
    // SIZE for user feedback
    getUndoCount(): number {
        return this.undoStack.length;
    }
    
    getStatusMessage(): string {
        const count = this.getUndoCount();
        if (count === 0) return "Nothing to undo";
        return `${count} action${count > 1 ? 's' : ''} can be undone`;
    }
}
 
// Use Case 3: Batch pop with size awareness
function popUpTo<T>(stack: Stack<T>, maxCount: number): T[] {
    const result: T[] = [];
    // Use SIZE to limit iterations
    const toPop = Math.min(maxCount, stack.size());
    for (let i = 0; i < toPop; i++) {
        result.push(stack.pop());
    }
    return result;
}
 
// Use Case 4: Monitoring and alerting
function monitoredPush<T>(stack: Stack<T>, element: T, warnThreshold: number): void {
    stack.push(element);
    // SIZE-BASED monitoring
    if (stack.size() > warnThreshold) {
        console.warn(`Stack size ${stack.size()} exceeds threshold ${warnThreshold}`);
    }
}

Size for Debugging

During development, logging stack sizes at key points helps catch issues like 'stack growing unexpectedly' or 'stack not emptying when it should.' Size-based assertions like assert(stack.size() === expectedSize) catch bugs early.

Naming Conventions Across Languages

Different languages and libraries use different names for the size operation. Being aware of these variations helps you work across ecosystems.

Size Naming Across Languages
Language/Library	Method Name	Return Type	Notes
Java Stack	size()	int	From Collection interface
C++ std::stack	size()	size_type	Returns size_t (unsigned)
Python list	len(stack)	int	Built-in function, not method
JavaScript Array	arr.length	number	Property, not method
C# Stack<T>	Count	int	Property, capitalized
Go slice	len(slice)	int	Built-in function
Rust Vec	.len()	usize	Unsigned size type
Swift Array	.count	Int	Property

Key variations to note:

Method vs Property vs Function: Java uses size(), JavaScript uses .length, Python uses len(). Know your language's convention.
Naming: size, length, count, len — all mean the same thing in this context.
Return type: Some languages use unsigned integers (C++ size_t, Rust usize), others use signed integers (Java int). Unsigned prevents negative values but can cause overflow bugs in certain calculations.
Property vs Method: Properties (like JavaScript's .length) don't use parentheses. Calling arr.length() in JavaScript is an error.

Best practice: When implementing your own stack, use size() as a method for consistency with most standard libraries. It's more universally understood than alternatives.

Consistency Matters

If you're implementing a Stack class, match the conventions of your primary language. In Java, use size(). In JavaScript, you might use a length property or a length() method. The key is consistency within your codebase.

Summary: Mastering Size

Size completes the stack interface, providing quantitative state information that isEmpty alone cannot provide. With push, pop, peek, isEmpty, and size, you have the complete toolkit for stack operations.

Key Takeaways

•Size returns the element count: A non-negative integer representing how many elements are currently in the stack. Size 0 means empty.
•Size complements isEmpty: isEmpty() is size() === 0. Use isEmpty for boolean checks; use size when you need the count.
•O(1) implementation is essential: Track size incrementally (update on push/pop). Never traverse to count—that's O(n) and unacceptable.
•Capacity relationships: For bounded stacks, size ≤ capacity. isFull() is size === capacity. Capacity management uses size extensively.
•Practical use cases: Depth limiting, progress tracking, batch operations, monitoring, and debugging all rely on knowing the size.
•Naming varies: size(), length, count, len() — know your language's convention and be consistent.

Module Complete:

With this page, we've comprehensively covered all five standard stack operations:

Push — Add to top (O(1))
Pop — Remove from top (O(1))
Peek — View top without removing (O(1))
isEmpty — Check if empty (O(1))
Size — Count elements (O(1))

These operations form the complete interface for interacting with stacks. In the next module, we'll see how to implement stacks using arrays, applying everything we've learned about these operations.

Module Complete: Stack Operations & Interface

You now have comprehensive mastery of the complete stack interface. You understand what each operation does, how it's implemented in both array and linked list representations, its complexity characteristics, edge cases, and practical patterns. You're ready to implement full stack data structures and use them effectively in algorithms.

5 / 5

Loading learning content...

Data Structures & AlgorithmsStack Operations & Interface

Stack Operations & Interface

LevelBeginner

Duration55 mins

TopicStack Operations & Interface

5 / 5

Size — Number of Elements

Knowing the Magnitude of Your Stack

What You Will Learn

What Size Means Conceptually

The size operation returns the number of elements currently stored in the stack. It's a non-negative integer that changes predictably with push and pop:

After each push(), size increases by 1
After each pop(), size decreases by 1
peek() and isEmpty() don't change size
A newly created stack has size 0

The invariant:

size() === (number of push operations) - (number of pop operations)

This relationship holds from the moment the stack is created, providing a simple mental model for tracking size.

Size Tracking Through Operations
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Operation          Stack State          size()    Change
─────────────────────────────────────────────────────────────
(initial)          []                   0         -
push(A)            [A]                  1         +1
push(B)            [A, B]               2         +1
push(C)            [A, B, C]            3         +1
peek()             [A, B, C]            3         (no change)
pop()              [A, B]               2         -1
isEmpty()          [A, B]               2         (no change)
push(D)            [A, B, D]            3         +1
pop()              [A, B]               2         -1
pop()              [A]                  1         -1
pop()              []                   0         -1
pop()              (error)              -         (blocked by underflow)
 
Note: size() can never become negative. 
      Attempting to pop when size is 0 results in an error, not -1.

Size is Always Non-Negative

The relationship with isEmpty:

isEmpty() === true   ⟺   size() === 0
isEmpty() === false  ⟺   size() > 0
isEmpty() === !Boolean(size())  // In JavaScript

These are logically equivalent, but each has its place. isEmpty is preferred when you only care about emptiness; size is preferred when you need the count.

The Size Contract — Preconditions and Postconditions

Like isEmpty, size is a pure observation operation with no preconditions and no side effects. It simply reports the current element count.

Size Operation Contract

•Precondition: None. size() can be called on any stack at any time.
•Postcondition #1: Returns a non-negative integer representing the number of elements.
•Postcondition #2: The stack is completely unchanged after the call.
•Consistency: If no push/pop occurs between calls, size() returns the same value.
•Idempotency: Calling size() multiple times has no cumulative effect.
•No failure mode: size() never throws or errors—it always returns a valid integer.

Size Contract Summary
Aspect	Description
Input	None
Output	Non-negative integer (0, 1, 2, ...)
Side Effect	None — purely observational
Time Guarantee	O(1) with proper implementation
Space Guarantee	O(1) — no allocations
Failure Mode	None — always succeeds

Size and isEmpty Are Both Safe

Size Implementation — Array-Based Stack

In an array-based stack, size is derived directly from topIndex. Since topIndex represents the index of the top element (with -1 meaning empty), the size is simply topIndex + 1.

ArrayStack.ts - Size Method
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
class ArrayStack<T> {
    private items: T[];
    private topIndex: number;
    private capacity: number;
 
    constructor(capacity: number = 1000) {
        this.items = new Array<T>(capacity);
        this.topIndex = -1;  // -1 indicates empty stack
        this.capacity = capacity;
    }
 
    /**
     * Size: Return the number of elements in the stack
     * 
     * Time Complexity: O(1)
     * Space Complexity: O(1)
     * 
     * @returns Non-negative integer representing element count
     */
    size(): number {
        return this.topIndex + 1;
    }
 
    /**
     * Alternative: if we track size separately
     * (redundant with topIndex, but common in other implementations)
     */
    // private _size: number = 0;
    // 
    // size(): number {
    //     return this._size;
    // }
 
    /**
     * isEmpty derived from size (showing the relationship)
     */
    isEmpty(): boolean {
        return this.size() === 0;
        // Equivalent to: return this.topIndex < 0;
    }
 
    /**
     * Capacity: maximum number of elements (for bounded stacks)
     */
    getCapacity(): number {
        return this.capacity;
    }
 
    /**
     * Check if stack is full
     */
    isFull(): boolean {
        return this.size() >= this.capacity;
        // Equivalent to: return this.topIndex >= this.capacity - 1;
    }
 
    /**
     * Remaining capacity
     */
    remainingCapacity(): number {
        return this.capacity - this.size();
    }
}

Why topIndex + 1?

Array indices are 0-based, so:

Empty stack: topIndex = -1, size = -1 + 1 = 0 ✓
One element: topIndex = 0, size = 0 + 1 = 1 ✓
Five elements: topIndex = 4, size = 4 + 1 = 5 ✓

The formula correctly converts the last occupied index to a count.

Size Calculation Examples
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
State: items = [10, 20, 30, _, _, ...]
        topIndex = 2
 
size() = topIndex + 1 = 2 + 1 = 3
 
Verification: Elements at indices 0, 1, 2 → three elements ✓
 
─────────────────────────────────────────
 
State: items = [_, _, _, _, _, ...]
        topIndex = -1
 
size() = topIndex + 1 = -1 + 1 = 0
 
Verification: No elements → zero ✓

Single Source of Truth

Size Implementation — Linked List-Based Stack

In a linked list-based stack, size can be computed in two ways:

Count on demand (O(n)): Traverse the list and count nodes each time size() is called.
Track count (O(1)): Maintain a count variable, updating it on push (+1) and pop (-1).

The second approach is strongly preferred for performance. Let's examine both.

LinkedListStack.ts - Size Methods
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
class StackNode<T> {
    value: T;
    next: StackNode<T> | null;
 
    constructor(value: T) {
        this.value = value;
        this.next = null;
    }
}
 
class LinkedListStack<T> {
    private head: StackNode<T> | null;
    private _count: number;  // Tracked on each push/pop
 
    constructor() {
        this.head = null;
        this._count = 0;
    }
 
    /**
     * Size: Return the number of elements in the stack
     * 
     * Time Complexity: O(1) — using tracked count
     * Space Complexity: O(1)
     */
    size(): number {
        return this._count;
    }
 
    /**
     * BAD Alternative: Compute size by traversing (O(n))
     * Don't use this! Included only to show why tracking is better.
     */
    sizeByTraversal(): number {
        let count = 0;
        let current = this.head;
        while (current !== null) {
            count++;
            current = current.next;
        }
        return count;
        // This is O(n) every time size() is called — inefficient!
    }
 
    /**
     * Push: Add element and increment count
     */
    push(element: T): void {
        const newNode = new StackNode(element);
        newNode.next = this.head;
        this.head = newNode;
        this._count++;  // O(1) update keeps size() O(1)
    }
 
    /**
     * Pop: Remove element and decrement count
     */
    pop(): T {
        if (this.head === null) {
            throw new Error("Stack underflow");
        }
        const value = this.head.value;
        this.head = this.head.next;
        this._count--;  // O(1) update keeps size() O(1)
        return value;
    }
 
    /**
     * isEmpty using tracked count
     */
    isEmpty(): boolean {
        return this._count === 0;
        // Equivalent to: return this.head === null;
    }
}

Size Implementation Comparison
Approach	Time Complexity	Space Overhead	Pros	Cons
Traversal	O(n)	None	No extra state to maintain	Slow for large stacks; repeated calls are wasteful
Tracked count	O(1)	One integer	Fast, constant-time	Must update on every push/pop (easy to forget)

Always Track Count

Size in the Context of Capacity

For bounded stacks (fixed-size array implementation), size and capacity form a pair:

Size: Current number of elements
Capacity: Maximum number of elements the stack can hold

The relationship size ≤ capacity must always hold. When size === capacity, the stack is full, and push operations will fail.

CapacityAwareStack.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
class BoundedStack<T> {
    private items: T[];
    private topIndex: number;
    private capacity: number;
 
    constructor(capacity: number) {
        this.items = new Array<T>(capacity);
        this.topIndex = -1;
        this.capacity = capacity;
    }
 
    size(): number {
        return this.topIndex + 1;
    }
 
    getCapacity(): number {
        return this.capacity;
    }
 
    /**
     * Check if stack is full
     * This is the 'capacity guard' — the complement to isEmpty
     */
    isFull(): boolean {
        return this.size() >= this.capacity;
    }
 
    /**
     * How many more elements can be pushed?
     */
    remainingCapacity(): number {
        return this.capacity - this.size();
    }
 
    /**
     * What percentage of capacity is used?
     */
    usagePercentage(): number {
        return (this.size() / this.capacity) * 100;
    }
 
    /**
     * Push with capacity check
     */
    push(element: T): boolean {
        if (this.isFull()) {
            return false;  // Or throw an error
        }
        this.topIndex++;
        this.items[this.topIndex] = element;
        return true;
    }
 
    /**
     * Attempt to push multiple elements
     * Returns number successfully pushed
     */
    pushMany(elements: T[]): number {
        let pushed = 0;
        for (const element of elements) {
            if (this.isFull()) break;
            this.push(element);
            pushed++;
        }
        return pushed;
    }
}
 
// Usage example:
const stack = new BoundedStack<number>(100);
console.log(stack.size());              // 0
console.log(stack.getCapacity());       // 100
console.log(stack.remainingCapacity()); // 100
console.log(stack.isFull());            // false
 
for (let i = 0; i < 100; i++) {
    stack.push(i);
}
 
console.log(stack.size());              // 100
console.log(stack.remainingCapacity()); // 0
console.log(stack.isFull());            // true
console.log(stack.push(999));           // false (failed)

Unbounded Stacks

Practical Use Cases for Size

While isEmpty covers most 'is it empty?' checks, size() is needed for more sophisticated scenarios involving counts, limits, and thresholds.

When Size Matters

•Capacity management: Checking if there's room for N more elements: stack.size() + n <= capacity
•Progress tracking: 'Processed 47 of 100 items' — knowing how many remain (e.g., in undo stacks)
•Depth limiting: Preventing stack overflow by checking: if (callStack.size() >= MAX_DEPTH) throw new Error('Too deep')
•Resource monitoring: Logging or alerting when stack size exceeds thresholds for debugging
•Comparison operations: Checking if two stacks have the same number of elements
•Batch operations: 'Pop at most N elements' or 'Push these only if size stays below limit'
•Stack-based algorithms: Some algorithms need to know the depth, not just emptiness (e.g., expression balance counting)

SizeUseCaseExamples.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
// Use Case 1: Depth-limited recursion simulation
function limitedDFS(root: Node, maxDepth: number): void {
    const stack: Array<{node: Node, depth: number}> = [];
    stack.push({node: root, depth: 0});
    
    while (stack.length > 0) {
        const {node, depth} = stack.pop()!;
        
        // SIZE-BASED LIMIT: Don't go deeper than maxDepth
        if (depth >= maxDepth) continue;
        
        process(node);
        for (const child of node.children) {
            stack.push({node: child, depth: depth + 1});
        }
    }
}
 
// Use Case 2: Progress reporting for undo system
class UndoManager {
    private undoStack: Action[] = [];
    private maxUndoSize: number = 100;
    
    recordAction(action: Action): void {
        this.undoStack.push(action);
        // SIZE-BASED LIMIT: Prevent unlimited memory usage
        if (this.undoStack.length > this.maxUndoSize) {
            this.undoStack.shift();  // Remove oldest
        }
    }
    
    // SIZE for user feedback
    getUndoCount(): number {
        return this.undoStack.length;
    }
    
    getStatusMessage(): string {
        const count = this.getUndoCount();
        if (count === 0) return "Nothing to undo";
        return `${count} action${count > 1 ? 's' : ''} can be undone`;
    }
}
 
// Use Case 3: Batch pop with size awareness
function popUpTo<T>(stack: Stack<T>, maxCount: number): T[] {
    const result: T[] = [];
    // Use SIZE to limit iterations
    const toPop = Math.min(maxCount, stack.size());
    for (let i = 0; i < toPop; i++) {
        result.push(stack.pop());
    }
    return result;
}
 
// Use Case 4: Monitoring and alerting
function monitoredPush<T>(stack: Stack<T>, element: T, warnThreshold: number): void {
    stack.push(element);
    // SIZE-BASED monitoring
    if (stack.size() > warnThreshold) {
        console.warn(`Stack size ${stack.size()} exceeds threshold ${warnThreshold}`);
    }
}

Size for Debugging

Naming Conventions Across Languages

Different languages and libraries use different names for the size operation. Being aware of these variations helps you work across ecosystems.

Size Naming Across Languages
Language/Library	Method Name	Return Type	Notes
Java Stack	size()	int	From Collection interface
C++ std::stack	size()	size_type	Returns size_t (unsigned)
Python list	len(stack)	int	Built-in function, not method
JavaScript Array	arr.length	number	Property, not method
C# Stack<T>	Count	int	Property, capitalized
Go slice	len(slice)	int	Built-in function
Rust Vec	.len()	usize	Unsigned size type
Swift Array	.count	Int	Property

Key variations to note:

Method vs Property vs Function: Java uses size(), JavaScript uses .length, Python uses len(). Know your language's convention.
Naming: size, length, count, len — all mean the same thing in this context.
Return type: Some languages use unsigned integers (C++ size_t, Rust usize), others use signed integers (Java int). Unsigned prevents negative values but can cause overflow bugs in certain calculations.
Property vs Method: Properties (like JavaScript's .length) don't use parentheses. Calling arr.length() in JavaScript is an error.

Best practice: When implementing your own stack, use size() as a method for consistency with most standard libraries. It's more universally understood than alternatives.

Consistency Matters

Summary: Mastering Size

Key Takeaways

•Size returns the element count: A non-negative integer representing how many elements are currently in the stack. Size 0 means empty.
•Size complements isEmpty: isEmpty() is size() === 0. Use isEmpty for boolean checks; use size when you need the count.
•O(1) implementation is essential: Track size incrementally (update on push/pop). Never traverse to count—that's O(n) and unacceptable.
•Capacity relationships: For bounded stacks, size ≤ capacity. isFull() is size === capacity. Capacity management uses size extensively.
•Practical use cases: Depth limiting, progress tracking, batch operations, monitoring, and debugging all rely on knowing the size.
•Naming varies: size(), length, count, len() — know your language's convention and be consistent.

Module Complete:

With this page, we've comprehensively covered all five standard stack operations:

Push — Add to top (O(1))
Pop — Remove from top (O(1))
Peek — View top without removing (O(1))
isEmpty — Check if empty (O(1))
Size — Count elements (O(1))

These operations form the complete interface for interacting with stacks. In the next module, we'll see how to implement stacks using arrays, applying everything we've learned about these operations.

Module Complete: Stack Operations & Interface

5 / 5