Dynamic Stack Using Resizable Array in DSA Python - Build from Scratch

Dynamic Stack Using Resizable Array

📖 Scenario: Imagine you are building a simple stack data structure that can grow when needed, like a stack of plates that can get taller if more plates are added.

🎯 Goal: You will create a dynamic stack using a list that resizes itself when it gets full. You will implement push and pop operations and see how the stack changes.

📋 What You'll Learn

Create a list called stack to hold stack elements

Create an integer variable capacity to track the current size limit of the stack

Create an integer variable top to track the index of the top element in the stack

Implement a push function that adds an element to the stack and doubles the capacity if full

Implement a pop function that removes and returns the top element from the stack

Print the stack after push and pop operations to see the current elements

💡 Why This Matters

🌍 Real World

Dynamic stacks are used in many programs where the number of items is not fixed, like undo features or expression evaluation.

💼 Career

Understanding dynamic data structures like resizable stacks is important for software development and technical interviews.

1

Create the initial stack and variables

Create a list called stack with size 2 filled with None, an integer variable capacity set to 2, and an integer variable top set to -1.

DSA Python

# Create stack list, capacity, and top variables
# Your code here

Hint

Think of stack as a list with empty slots, capacity as how many slots it has, and top as the position of the last added item.

2

Add a function to push elements with resizing

Define a function called push that takes a parameter value. Inside, check if top + 1 equals capacity. If yes, double the capacity, create a new list with double size, copy old elements, and assign it to stack. Then increase top by 1 and set stack[top] to value.

DSA Python

stack = [None, None]
capacity = 2
top = -1

# Define push function to add value and resize if needed
# Your code here

Hint

Remember to use global to modify variables outside the function. Copy elements one by one to the new bigger list.

3

Add a function to pop elements from the stack

Define a function called pop that returns the top element from stack. If top is -1, return None. Otherwise, store stack[top] in a variable, set stack[top] to None, decrease top by 1, and return the stored value.

DSA Python

stack = [None, None]
capacity = 2
top = -1

def push(value):
    global stack, capacity, top
    if top + 1 == capacity:
        capacity *= 2
        new_stack = [None] * capacity
        for i in range(top + 1):
            new_stack[i] = stack[i]
        stack = new_stack
    top += 1
    stack[top] = value

# Define pop function to remove and return top element
# Your code here

Hint

Check if the stack is empty by seeing if top is -1. Remove the top element and update top.

4

Test the stack by pushing and popping elements

Call push(10), push(20), push(30), then print the stack and capacity. Next, call pop() and print the popped value, then print the stack and capacity again.

DSA Python

stack = [None, None]
capacity = 2
top = -1

def push(value):
    global stack, capacity, top
    if top + 1 == capacity:
        capacity *= 2
        new_stack = [None] * capacity
        for i in range(top + 1):
            new_stack[i] = stack[i]
        stack = new_stack
    top += 1
    stack[top] = value

def pop():
    global stack, top
    if top == -1:
        return None
    value = stack[top]
    stack[top] = None
    top -= 1
    return value

# Push 10, 20, 30; print stack and capacity
# Pop one element; print popped value, stack and capacity
# Your code here

Hint

After pushing 3 elements, the stack should resize from 2 to 4. Popping removes the last pushed element.

Practice

1. What is the main advantage of using a dynamic stack implemented with a resizable array over a fixed-size array stack?

easy

A. It always has a fixed capacity.

B. It uses less memory than a linked list stack.

C. It does not require resizing when full.

D. It can grow or shrink automatically as elements are pushed or popped.

Solution

1. Step 1: Understand fixed-size array stack limitation

   A fixed-size array stack has a set capacity and cannot grow beyond it, causing overflow if exceeded.

2. Step 2: Analyze dynamic stack behavior

   A dynamic stack using a resizable array automatically increases or decreases its size when needed, avoiding overflow and wasted space.

3. Final Answer:

   It can grow or shrink automatically as elements are pushed or popped. -> Option D

4. Quick Check:

   Dynamic resizing = automatic growth/shrink [OK]

Hint: Dynamic stacks resize arrays automatically when full or empty [OK]

Common Mistakes:

• Thinking dynamic stack never resizes
• Confusing dynamic stack with linked list stack
• Assuming fixed capacity for dynamic stack

2. Which of the following is the correct way to double the size of the internal array in a dynamic stack implemented in Python?

easy

A. self.array.extend([None] * len(self.array))

B. self.array = self.array * 2

C. self.array = [None] * (len(self.array) * 2)

D. self.array.append(self.array)

Solution

1. Step 1: Understand array resizing in Python list

   To double the size, we add extra None elements equal to current length to the list.

2. Step 2: Check each option

   self.array.extend([None] * len(self.array)) correctly extends the list by adding None elements equal to current length, doubling size.

3. Final Answer:

   self.array.extend([None] * len(self.array)) -> Option A

4. Quick Check:

   Extend with None * current length = double size [OK]

Hint: Use extend with None times current length to double array [OK]

Common Mistakes:

• Using multiplication on list copies elements, not size
• Assigning new list loses old elements
• Appending array inside itself causes nested list

3. Consider this Python code for a dynamic stack push operation:

def push(self, item):
    if self.top == len(self.array):
        self.array.extend([None] * len(self.array))
    self.array[self.top] = item
    self.top += 1

stack = DynamicStack()
stack.push(10)
stack.push(20)
stack.push(30)
print(stack.array[:stack.top])

What will be the printed output?

medium

A. [10, 20, 30]

B. [10, 20, 30, None, None, None]

C. [None, None, None]

D. IndexError

Solution

1. Step 1: Trace push calls and array state

   Initially array is empty or small. On first push, item 10 is placed at index 0, top becomes 1. Similarly for 20 and 30 at indices 1 and 2.

2. Step 2: Print array slice up to top

   Printing array[:top] shows only elements at indices 0,1,2 which are [10, 20, 30].

3. Final Answer:

   [10, 20, 30] -> Option A

4. Quick Check:

   Print array slice up to top = pushed elements [OK]

Hint: Print only up to top index to see current stack elements [OK]

Common Mistakes:

• Printing full array including None values
• Confusing top index with length
• Expecting error due to resizing

4. Given this buggy pop method for a dynamic stack:

def pop(self):
    if self.top == 0:
        return None
    self.top -= 1
    item = self.array[self.top]
    self.array[self.top] = None
    if self.top < len(self.array) // 4:
        self.array = self.array[:len(self.array) // 2]
    return item

What is the main issue with this code?

medium

A. It does not set popped element to None.

B. It does not check for empty stack before popping.

C. It shrinks the array too early, causing frequent resizing.

D. It doubles the array size instead of shrinking.

Solution

1. Step 1: Understand shrinking condition

   The array shrinks when top is less than one-fourth of array length, which can cause frequent resizing if elements fluctuate near this threshold.

2. Step 2: Identify problem with frequent resizing

   Frequent shrinking and expanding wastes time and resources, so better to shrink less aggressively.

3. Final Answer:

   It shrinks the array too early, causing frequent resizing. -> Option C

4. Quick Check:

   Shrink threshold too high = frequent resize [OK]

Hint: Shrink array only when usage is very low to avoid thrashing [OK]

Common Mistakes:

• Ignoring empty stack check (it is present)
• Confusing shrinking with doubling
• Not clearing popped element

5. You want to implement a dynamic stack that minimizes memory usage by shrinking the internal array only when the number of elements is less than 1/8 of the array size. Which change should you make to the pop method's shrinking condition?

def pop(self):
    if self.top == 0:
        return None
    self.top -= 1
    item = self.array[self.top]
    self.array[self.top] = None
    if ???:
        self.array = self.array[:len(self.array) // 2]
    return item

hard

A. if self.top == 0

B. if self.top < len(self.array) // 8

C. if self.top <= len(self.array) // 2

D. if self.top < len(self.array) // 4

Solution

1. Step 1: Understand shrinking threshold

   To shrink only when usage is less than 1/8, the condition must check if top is less than array length divided by 8.

2. Step 2: Match condition to code

   if self.top < len(self.array) // 8 correctly uses 'if self.top < len(self.array) // 8' to trigger shrinking at 1/8 usage.

3. Final Answer:

   if self.top < len(self.array) // 8 -> Option B

4. Quick Check:

   Shrink when usage < 1/8 = condition in if self.top < len(self.array) // 8 [OK]

Hint: Use 1/8 threshold to shrink less often and save memory [OK]

Common Mistakes:

• Using 1/4 threshold shrinks too early
• Using equality instead of less than
• Shrinking when stack is empty only