Dynamic Stack Using Resizable Array in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to push an element onto the stack.

DSA Java

public void push(int value) {
    if (size == capacity) {
        resize();
    }
    arr[size] = [1];
    size++;
}

Drag options to blanks, or click blank then click option'

Avalue

Bsize

Ccapacity

Darr

Attempts:

3 left

💡 Hint

Common Mistakes

Using size instead of value to assign array element.

Assigning to arr instead of arr[size].

We assign the input value to the array at the current size index before increasing size.

2fill in blank

medium

Complete the code to resize the array when capacity is reached.

DSA Java

private void resize() {
    capacity = capacity [1] 2;
    int[] newArr = new int[capacity];
    for (int i = 0; i < size; i++) {
        newArr[i] = arr[i];
    }
    arr = newArr;
}

Drag options to blanks, or click blank then click option'

A/

B+

C*

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Using addition instead of multiplication.

Dividing capacity instead of multiplying.

We multiply capacity by 2 to double the array size.

3fill in blank

hard

Fix the error in the pop method to correctly return the top element.

DSA Java

public int pop() {
    if (size == 0) {
        throw new EmptyStackException();
    }
    size--;
    return arr[[1]];
}

Drag options to blanks, or click blank then click option'

Asize

Bsize - 1

Ccapacity - 1

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using size - 1 after decrementing size.

Using capacity - 1 or 0 as index.

After decreasing size, the top element is at index size.

4fill in blank

hard

Fill both blanks to check if the stack is empty and return the correct boolean.

DSA Java

public boolean isEmpty() {
    return size [1] [2];
}

Drag options to blanks, or click blank then click option'

A==

B!=

C0

Dsize

Attempts:

3 left

💡 Hint

Common Mistakes

Using '!=' instead of '==' operator.

Comparing size to size instead of 0.

The stack is empty if size equals 0.

5fill in blank

hard

Fill in the blank to implement the peek method that returns the top element without removing it.

DSA Java

public int peek() {
    if (size == 0) {
        throw new EmptyStackException();
    }
    return arr[[1]];
}

Drag options to blanks, or click blank then click option'

Asize

B0

Ccapacity

Dsize - 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using size as index which is out of bounds.

Using capacity or 0 as index.

The top element is at index size - 1 without changing size.

Practice

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

easy

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

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

C. It does not require any resizing operations.

D. It always has a fixed maximum size.

Solution

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

   A fixed-size array stack has a maximum capacity that cannot change, so it can overflow if too many elements are pushed.

2. Step 2: Understand dynamic stack resizing

   A dynamic stack using a resizable array can increase or decrease its size automatically when needed, avoiding overflow and wasting less memory.

3. Final Answer:

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

4. Quick Check:

   Dynamic resizing = automatic growth/shrink [OK]

Hint: Dynamic stack resizes array automatically on overflow or underflow [OK]

Common Mistakes:

• Thinking dynamic stack never resizes
• Confusing dynamic stack with linked list stack
• Assuming fixed size means dynamic resizing

2. Which of the following Java code snippets correctly doubles the size of the internal array when the stack is full?

easy

A. if (top == arr.length) { arr = Arrays.copyOf(arr, arr.length * 2); }

B. if (top > arr.length) { arr = Arrays.copyOf(arr, arr.length / 2); }

C. if (top == arr.length) { arr = Arrays.copyOf(arr, arr.length / 2); }

D. if (top < arr.length) { arr = Arrays.copyOf(arr, arr.length * 2); }

Solution

1. Step 1: Check condition for resizing

   The array should resize when the stack is full, i.e., when top equals array length.

2. Step 2: Check resizing operation

   The array size should double to accommodate more elements, so new size is arr.length * 2.

3. Final Answer:

   if (top == arr.length) { arr = Arrays.copyOf(arr, arr.length * 2); } -> Option A

4. Quick Check:

   Resize when full, double size [OK]

Hint: Resize when top == length, double array size [OK]

Common Mistakes:

• Resizing when top > length (impossible)
• Shrinking array instead of doubling
• Resizing when array not full

3. Consider the following Java code for a dynamic stack using a resizable array:

DynamicStack stack = new DynamicStack();
stack.push(10);
stack.push(20);
stack.push(30);
stack.pop();
stack.push(40);
stack.push(50);
System.out.println(stack);

What will be the printed output if the stack's toString method prints elements from bottom to top separated by ' -> ' and ends with ' -> null'?

medium

A. 50 -> 40 -> 20 -> 10 -> null

B. 10 -> 20 -> 30 -> 40 -> 50 -> null

C. 10 -> 20 -> null

D. 10 -> 20 -> 40 -> 50 -> null

Solution

1. Step 1: Trace push and pop operations

   Push 10, 20, 30: stack = [10, 20, 30]
   Pop removes 30: stack = [10, 20]
   Push 40, 50: stack = [10, 20, 40, 50]

2. Step 2: Understand toString output

   Prints from bottom to top separated by ' -> ' ending with ' -> null'. So output is "10 -> 20 -> 40 -> 50 -> null".

3. Final Answer:

   10 -> 20 -> 40 -> 50 -> null -> Option D

4. Quick Check:

   Stack after operations = 10,20,40,50 [OK]

Hint: Track push/pop stepwise, print bottom to top [OK]

Common Mistakes:

• Forgetting pop removes last pushed element
• Printing top to bottom instead of bottom to top
• Including popped element in output

4. The following Java method is part of a dynamic stack implementation. It is supposed to pop an element and shrink the array size by half when the number of elements is less than a quarter of the array length. Identify the bug:

public int pop() {
    if (top == 0) throw new EmptyStackException();
    int val = arr[--top];
    if (top < arr.length / 4) {
        arr = Arrays.copyOf(arr, arr.length / 2);
    }
    return val;
}

medium

A. The pop method does not decrement top before accessing arr.

B. Shrinking array without checking minimum size can cause array size zero.

C. The condition should be top > arr.length / 4 to shrink.

D. The method should double the array size instead of halving it.

Solution

1. Step 1: Analyze shrinking condition and operation

   The array shrinks when top < arr.length / 4 by halving the array size.

2. Step 2: Identify potential bug

   If array size is small (like 1 or 2), halving repeatedly can reduce array size to zero, causing errors on next push/pop.

3. Final Answer:

   Shrinking array without checking minimum size can cause array size zero. -> Option B

4. Quick Check:

   Check minimum array size before shrinking [OK]

Hint: Always check minimum array size before shrinking [OK]

Common Mistakes:

• Not checking for empty stack before pop
• Wrong condition for shrinking
• Shrinking array too small causing errors

5. You want to implement a dynamic stack using a resizable array that doubles its size when full and halves its size when the number of elements falls below one-fourth of the array length, but never shrinks below a minimum capacity of 4. Which of the following code snippets correctly implements the pop method with this behavior?

public int pop() {
    if (top == 0) throw new EmptyStackException();
    int val = arr[--top];
    if (top < arr.length / 4 && arr.length > 4) {
        arr = Arrays.copyOf(arr, Math.max(arr.length / 2, 4));
    }
    return val;
}

hard

A. Does not shrink array at all.

B. Shrinks array below size 4 causing errors.

C. Correctly shrinks array but never below size 4.

D. Doubles array size on pop instead of shrinking.

Solution

1. Step 1: Check shrinking condition and minimum size

   The code shrinks array only if top < arr.length / 4 and arr.length > 4, ensuring minimum size 4.

2. Step 2: Verify shrinking operation

   Uses Math.max(arr.length / 2, 4) to avoid shrinking below 4, preventing errors.

3. Final Answer:

   Correctly shrinks array but never below size 4. -> Option C

4. Quick Check:

   Shrink with minimum size check = correct pop method [OK]

Hint: Use Math.max to enforce minimum array size when shrinking [OK]

Common Mistakes:

• Shrinking array below minimum size
• Not shrinking array when needed
• Incorrect condition for shrinking