Stack Implementation Using Array in DSA C++ - Build from Scratch

Stack Implementation Using Array

📖 Scenario: Imagine you are building a simple text editor. You want to keep track of the actions a user performs so you can undo them one by one. A stack is perfect for this because it works like a stack of plates: the last action done is the first one to undo.

🎯 Goal: You will build a stack using an array in C++. You will create the stack, set its size, add items (push), remove items (pop), and finally print the stack's contents.

📋 What You'll Learn

Create an integer array called stack with size 5

Create an integer variable called top and set it to -1

Create an integer variable called max_size and set it to 5

Write a push operation that adds an integer to the stack if there is space

Write a pop operation that removes the top item from the stack if it is not empty

Print the stack contents from bottom to top after operations

💡 Why This Matters

🌍 Real World

Stacks are used in undo features, browser history, expression evaluation, and more.

💼 Career

Understanding stack implementation helps in software development, debugging, and working with system internals.

1

Create the stack array and top variable

Create an integer array called stack with size 5 and an integer variable called top set to -1.

DSA C++

// Your code here

Hint

Think of top as the pointer to the last added item. Initially, it is -1 because the stack is empty.

2

Add max_size variable

Create an integer variable called max_size and set it to 5.

DSA C++

int stack[5];
int top = -1;
// Your code here

Hint

This variable will help us check if the stack is full before adding new items.

3

Write push and pop operations

Write a push operation that adds an integer value to stack only if top is less than max_size - 1. Then write a pop operation that removes the top item by decreasing top only if top is not -1.

DSA C++

int stack[5];
int top = -1;
int max_size = 5;

// Your code here

Hint

Remember, push adds an item on top, and pop removes the top item by moving top down.

4

Push values, pop one, and print stack

Use push to add 10, 20, 30 to the stack. Then use pop once. Finally, print the stack contents from bottom (index 0) to top (index top) separated by spaces.

DSA C++

int stack[5];
int top = -1;
int max_size = 5;

// Push operation
void push(int value) {
    if (top < max_size - 1) {
        top++;
        stack[top] = value;
    }
}

// Pop operation
void pop() {
    if (top != -1) {
        top--;
    }
}

int main() {
    // Your code here
    return 0;
}

Hint

After pushing 10, 20, 30 and popping once, the stack should have 10 and 20 left. Print them from bottom to top.

Practice

1. What is the main purpose of using an array in stack implementation?

easy

A. To store elements in a fixed-size linear structure

B. To allow random access to elements anywhere

C. To sort elements automatically

D. To store elements in a tree-like structure

Solution

1. Step 1: Understand stack storage

   A stack stores elements in a linear order, last-in first-out (LIFO).

2. Step 2: Role of array in stack

   An array provides a fixed-size linear structure to hold stack elements efficiently.

3. Final Answer:

   To store elements in a fixed-size linear structure -> Option A

4. Quick Check:

   Stack uses array for fixed linear storage [OK]

Hint: Stack uses array for fixed linear storage [OK]

Common Mistakes:

• Confusing stack with queue or tree
• Thinking array sorts elements automatically
• Assuming stack allows random access

2. Which of the following is the correct syntax to declare a stack array of size 10 in C++?

easy

A. stack int[10];

B. int stack[10];

C. int stack();

D. array stack[10];

Solution

1. Step 1: Recall C++ array declaration syntax

   In C++, arrays are declared as: type name[size];

2. Step 2: Match with options

   int stack[10]; matches correct syntax: int stack[10];

3. Final Answer:

   int stack[10]; -> Option B

4. Quick Check:

   C++ array declaration = int stack[10]; [OK]

Hint: Array declaration: type name[size]; [OK]

Common Mistakes:

• Using parentheses instead of brackets
• Wrong order of type and name
• Using non-existent 'array' keyword

3. What will be the output after executing the following code?

int stack[5];
int top = -1;
// Push 10
stack[++top] = 10;
// Push 20
stack[++top] = 20;
// Pop
int x = stack[top--];
// Push 30
stack[++top] = 30;
// Print top element
std::cout << stack[top];

medium

A. Runtime error

B. 20

C. 10

D. 30

Solution

1. Step 1: Trace stack operations step-by-step

   Initially top = -1.
   Push 10: top=0, stack[0]=10
   Push 20: top=1, stack[1]=20
   Pop: x=stack[1]=20, top=0
   Push 30: top=1, stack[1]=30

2. Step 2: Identify top element after operations

   Top is 1, stack[1] = 30, so output is 30.

3. Final Answer:

   30 -> Option D

4. Quick Check:

   Last pushed after pop is 30 [OK]

Hint: Track top index changes carefully [OK]

Common Mistakes:

• Confusing push and pop order
• Not updating top correctly
• Assuming pop removes element permanently

4. Identify the error in the following stack push function using array:

void push(int stack[], int &top, int size, int value) {
  if (top == size) {
    std::cout << "Stack Overflow";
    return;
  }
  stack[++top] = value;
}

medium

A. No error, function is correct

B. The increment of top should be after assignment

C. The condition should be 'top == size - 1' to check overflow

D. The function should return a value

Solution

1. Step 1: Understand overflow condition

   Array indices go from 0 to size-1, so top can be max size-1.

2. Step 2: Check condition in code

   Condition 'top == size' is wrong; it should be 'top == size - 1' to prevent overflow.

3. Final Answer:

   The condition should be 'top == size - 1' to check overflow -> Option C

4. Quick Check:

   Overflow check uses top == size - 1 [OK]

Hint: Array max index = size - 1 for overflow check [OK]

Common Mistakes:

• Checking top == size instead of size - 1
• Incrementing top incorrectly
• Ignoring overflow condition

5. Given a stack implemented using an array of size 4, what will be the state of the stack after these operations?

push(5); push(10); pop(); push(15); push(20); push(25); pop();

Assume stack is initially empty and top = -1. Choose the correct stack content from bottom to top.

hard

A. 5 -> 15 -> 20 -> null

B. 5 -> 10 -> 15 -> 20 -> null

C. 5 -> 15 -> 20 -> 25 -> null

D. 10 -> 15 -> 20 -> null

Solution

1. Step 1: Execute operations step-by-step

   Start: top = -1, stack empty.
   push(5): top=0, stack[0]=5
   push(10): top=1, stack[1]=10
   pop(): removes 10, top=0
   push(15): top=1, stack[1]=15
   push(20): top=2, stack[2]=20
   push(25): top=3, stack[3]=25 (stack full)
   pop(): removes 25, top=2

2. Step 2: Final stack content

   Stack from bottom to top: 5 (index 0), 15 (index 1), 20 (index 2). So output is 5 -> 15 -> 20 -> null.

3. Final Answer:

   5 -> 15 -> 20 -> null -> Option A

4. Quick Check:

   Track push/pop changes carefully [OK]

Hint: Write each push/pop step to track stack state [OK]

Common Mistakes:

• Ignoring pop effects on top
• Assuming stack grows beyond size
• Confusing order of elements