Peek Top Element of Stack in DSA Typescript - Deep Dive

Overview - Peek Top Element of Stack

What is it?

A stack is a collection where you add and remove items in a last-in, first-out order. Peeking means looking at the top item without removing it. This lets you see what is next to be removed without changing the stack. It's like checking the top book on a pile without taking it off.

Why it matters

Peeking helps you decide what to do next without losing data. Without peeking, you'd have to remove the top item to see it, which changes the stack and can cause errors. Many programs need to check the next item without removing it, like undo actions or expression evaluation.

Where it fits

You should know what a stack is and how push and pop work before learning peek. After peek, you can learn about stack applications like balancing symbols or undo features. Later, you might explore other data structures like queues or linked lists.

Mental Model

Core Idea

Peeking lets you see the top item of a stack without changing the stack itself.

Think of it like...

It's like looking at the top book on a stack without pulling it out, so the pile stays the same.

Stack (top at the right):
┌─────┐
│  5  │  <- top
├─────┤
│  3  │
├─────┤
│  1  │
└─────┘

Peek returns 5 but stack stays:
1 -> 3 -> 5 -> null

Build-Up - 7 Steps

1

Foundation

Understanding Stack Basics

Concept: Learn what a stack is and how push and pop work.

A stack is like a pile of plates. You add plates on top (push) and remove from the top (pop). The last plate you put is the first you take out. This is called Last-In, First-Out (LIFO).

Result

You can add and remove items only from the top of the stack.

Understanding push and pop is essential because peek works with the same top position without removing items.

2

Foundation

Implementing Stack with Array

Concept: Use an array to store stack items and track the top index.

In TypeScript, use an array to hold items. Push adds to the end, pop removes from the end. The last element in the array is the top of the stack.

Result

Stack operations work with array methods: push() and pop().

Knowing the array-based stack helps visualize how peek accesses the last element without removal.

3

Intermediate

Introducing Peek Operation

🤔Before reading on: do you think peek removes the top item or just shows it? Commit to your answer.

Concept: Peek returns the top item without removing it from the stack.

Peek looks at the last element in the array (top of stack) and returns it. It does not change the array or stack size.

Result

Calling peek on [1, 3, 5] returns 5 and stack remains [1, 3, 5].

Understanding peek as a non-destructive read prevents accidental data loss during stack operations.

4

Intermediate

Handling Empty Stack in Peek

🤔Before reading on: what should peek return if the stack is empty? Commit to your answer.

Concept: Peek must handle empty stacks safely, usually by returning null or undefined.

If the stack array is empty, peek returns null or undefined to signal no top item exists. This avoids errors when accessing elements.

Result

Peek on [] returns null or undefined, stack stays [].

Knowing how to handle empty stacks in peek prevents runtime errors and improves program safety.

5

Intermediate

TypeScript Peek Method Example

Concept: Write a peek method in TypeScript for a stack class.

class Stack { private items: T[] = []; push(item: T): void { this.items.push(item); } pop(): T | undefined { return this.items.pop(); } peek(): T | null { if (this.items.length === 0) { return null; } return this.items[this.items.length - 1]; } } // Example usage: const stack = new Stack(); stack.push(1); stack.push(3); stack.push(5); console.log(stack.peek()); // Output: 5 console.log(stack.pop()); // Output: 5 console.log(stack.peek()); // Output: 3

Result

Peek returns 5 before pop, then 3 after pop, stack updates accordingly.

Seeing peek in code clarifies how it accesses the last element safely without removal.

6

Advanced

Peek in Linked List Stack Implementation

🤔Before reading on: do you think peek is faster or slower in linked list stacks compared to array stacks? Commit to your answer.

Concept: Peek in linked list stacks returns the value of the head node without removal.

In a linked list stack, the top is the head node. Peek returns head's value without changing links. This is O(1) time, same as array peek.

Result

Peek returns the head node's value, stack remains unchanged.

Understanding peek works similarly in linked list stacks shows its consistent O(1) efficiency regardless of implementation.

7

Expert

Peek and Concurrency Challenges

🤔Before reading on: do you think peek is always safe in multi-threaded environments? Commit to your answer.

Concept: In concurrent systems, peek may read stale or changing data without synchronization.

If multiple threads access the stack, peek might see inconsistent top if another thread pops or pushes simultaneously. Synchronization or locks are needed to ensure peek returns correct data.

Result

Without locks, peek can return outdated or invalid values in concurrent use.

Knowing concurrency issues with peek prevents subtle bugs in multi-threaded programs and guides safe stack design.

Under the Hood

Peek accesses the memory location of the top element in the stack's underlying storage (array or linked list) without modifying pointers or indices. It reads the value directly and returns it, leaving the data structure intact.

Why designed this way?

Peek was designed to provide a safe way to inspect the next item to be removed without changing the stack. This avoids side effects and allows decision-making based on the top element. Alternatives like pop remove the item, which is not always desired.

Stack (array-based):
┌───────────────┐
│ items array   │
│ [1, 3, 5]     │
└───────────────┘
       ↑
       top index = length - 1

Peek reads items[top index] without changing array or length.

Myth Busters - 4 Common Misconceptions

Quick: Does peek remove the top element from the stack? Commit yes or no.

Common Belief: Peek removes the top element just like pop but also shows it.

Reality: Peek only shows the top element without removing it from the stack.

Why it matters: If you think peek removes the item, you might accidentally lose data or misuse peek when you only want to check the top.

Quick: Can peek return a valid value when the stack is empty? Commit yes or no.

Common Belief: Peek always returns a value, even if the stack is empty.

Reality: Peek returns null or undefined if the stack is empty because there is no top element.

Why it matters: Assuming peek always returns a value can cause runtime errors or crashes when the stack is empty.

Quick: Is peek operation slower than pop or push? Commit yes or no.

Common Belief: Peek is slower because it needs extra steps to avoid removing the item.

Reality: Peek is O(1) time, just like push and pop, because it only reads the top element without modification.

Why it matters: Thinking peek is slow might discourage its use, missing out on efficient stack inspection.

Quick: In multi-threaded programs, is peek always safe without locks? Commit yes or no.

Common Belief: Peek is always safe to use without synchronization in concurrent environments.

Reality: Peek can read inconsistent or stale data if other threads modify the stack simultaneously without locks.

Why it matters: Ignoring concurrency issues can cause subtle bugs and incorrect program behavior in multi-threaded systems.

Expert Zone

1

Peek does not change stack size but can expose stale data if the stack is modified concurrently.

2

In linked list stacks, peek accesses the head node directly, making it equally efficient as array-based peek.

3

Some languages or libraries implement peek to throw exceptions on empty stacks instead of returning null, affecting error handling.

When NOT to use

Avoid using peek in concurrent environments without proper synchronization; use thread-safe stacks or locks instead. Also, if you need to remove the top item, use pop rather than peek.

Production Patterns

Peek is used in expression evaluators to check the next operator or operand without consuming it. Undo systems peek at the last action to decide if undo is possible. Parsing algorithms peek at the next token to decide parsing steps.

Connections

Queue Peek Operation

Similar pattern of inspecting the next item without removal but in FIFO order.

Understanding peek in stacks helps grasp peek in queues, showing how data structures allow safe inspection of next elements.

Cache Lookups

Peek is like checking if data is in cache without modifying it.

Knowing peek helps understand how caches check stored data before deciding to fetch or update.

Human Decision-Making

Peek resembles looking ahead before acting, like checking a recipe step before cooking.

This connection shows how peek models cautious inspection before committing to an action.

Common Pitfalls

#1 Calling peek on an empty stack without checking causes errors.

Wrong approach:

const top = stack.peek();
console.log(top.toString()); // Error if top is null

Correct approach:

const top = stack.peek();
if (top !== null) {
console.log(top.toString());
} else {
console.log('Stack is empty');
}

Root cause:

Not handling the empty stack case leads to null or undefined being used as a value.

#2 Using peek when you actually want to remove the top item.

Wrong approach:

const top = stack.peek();
// expecting stack to lose top item, but it stays

Correct approach:

const top = stack.pop();
// stack loses top item as expected

Root cause:

Confusing peek with pop causes logic errors where the stack does not change as intended.

#3 Assuming peek is thread-safe without synchronization in multi-threaded code.

Wrong approach:

// Thread 1
const top = stack.peek();
// Thread 2
stack.pop();
// No locks used

Correct approach:

// Use locks or thread-safe stack
lock.acquire();
const top = stack.peek();
lock.release();

Root cause:

Ignoring concurrency control leads to inconsistent or invalid peek results.

Key Takeaways

Peek lets you see the top item of a stack without removing it, preserving the stack's state.

Peek runs in constant time O(1) and works similarly in array or linked list stacks.

Always handle empty stacks in peek to avoid errors by returning null or undefined.

In concurrent environments, peek requires synchronization to ensure safe and consistent reads.

Understanding peek helps build safer and more predictable stack-based algorithms and applications.

Practice

1. What does the peek operation do in a stack?

easy

A. Returns the top element without removing it

B. Removes the top element and returns it

C. Adds a new element to the top

D. Checks if the stack is empty

Solution

1. Step 1: Understand stack operations

   A stack supports push (add), pop (remove), and peek (view) operations.

2. Step 2: Define peek operation

   Peek returns the top element without removing it, unlike pop which removes it.

3. Final Answer:

   Returns the top element without removing it -> Option A

4. Quick Check:

   Peek = view top element only [OK]

Hint: Peek shows top without removing it [OK]

Common Mistakes:

• Confusing peek with pop
• Thinking peek adds elements
• Assuming peek checks emptiness

2. Which of the following is the correct TypeScript syntax to peek the top element of a stack implemented as an array named stack?

easy

A. stack[stack.length - 1]

B. stack.peek()

C. stack.pop()

D. stack.top()

Solution

1. Step 1: Recall array indexing for top element

   The top element of a stack implemented as an array is at index length - 1.

2. Step 2: Identify correct syntax

   Accessing stack[stack.length - 1] returns the top element without removing it.

3. Final Answer:

   stack[stack.length - 1] -> Option A

4. Quick Check:

   Array top = stack[length - 1] [OK]

Hint: Use stack[length - 1] to peek top [OK]

Common Mistakes:

• Using pop() which removes element
• Using non-existent peek() method on array
• Using top() which is not a standard method

3. What will be the output of the following TypeScript code?

const stack: number[] = [];
stack.push(10);
stack.push(20);
stack.push(30);
console.log(stack[stack.length - 1]);

medium

A. 10

B. 20

C. 30

D. undefined

Solution

1. Step 1: Trace stack push operations

   Elements pushed in order: 10, then 20, then 30. Stack is [10, 20, 30].

2. Step 2: Access top element using stack[stack.length - 1]

   stack.length is 3, so index 2 is top element which is 30.

3. Final Answer:

   30 -> Option C

4. Quick Check:

   Top element after pushes = 30 [OK]

Hint: Last pushed element is top [OK]

Common Mistakes:

• Confusing first pushed element as top
• Using pop() instead of peek
• Off-by-one error in index

4. Identify the error in the following TypeScript code that tries to peek the top element of a stack implemented as an array:

const stack: number[] = [5, 15, 25];
function peek() {
  return stack.pop();
}
console.log(peek());
console.log(stack);

medium

A. Missing return type in peek function

B. stack array is not initialized properly

C. peek function should return stack[0]

D. Using pop() removes the top element instead of just peeking

Solution

1. Step 1: Understand pop() behavior

   pop() removes and returns the top element, modifying the stack.

2. Step 2: Identify peek operation requirement

   Peek should return the top element without removing it, so pop() is incorrect here.

3. Final Answer:

   Using pop() removes the top element instead of just peeking -> Option D

4. Quick Check:

   pop() removes element, peek should not [OK]

Hint: Peek must not remove element; pop() does [OK]

Common Mistakes:

• Using pop() instead of accessing last element
• Returning stack[0] which is bottom element
• Ignoring side effects of pop()

5. You have a stack implemented as an array stack. You want to safely peek the top element but return null if the stack is empty to avoid errors. Which TypeScript code snippet correctly does this?

hard

A. return stack.pop() || null;

B. return stack.length ? stack[stack.length - 1] : null;

C. return stack[0] || null;

D. return stack[stack.length];

Solution

1. Step 1: Check if stack is empty

   Use stack.length to verify if stack has elements.

2. Step 2: Return top element or null

   If stack is not empty, return stack[stack.length - 1], else return null.

3. Final Answer:

   return stack.length ? stack[stack.length - 1] : null; -> Option B

4. Quick Check:

   Safe peek with empty check = return stack.length ? stack[stack.length - 1] : null; [OK]

Hint: Check length before peek to avoid errors [OK]

Common Mistakes:

• Using pop() which removes element
• Accessing stack[0] which is bottom element
• Accessing stack[stack.length] which is undefined