Stack Implementation Using Array in DSA C - Build from Scratch

Stack Implementation Using Array

📖 Scenario: You are building a simple stack data structure using an array in C. A stack works like a stack of plates: you add (push) plates on top and remove (pop) plates from the top only.This project will help you understand how to create a stack, keep track of its size, add items, and remove items using an array.

🎯 Goal: Build a stack using an array with basic operations: push and pop. You will create the array, set the stack size, add elements, and then remove elements, printing the stack state at the end.

📋 What You'll Learn

Create an integer array called stack with size 5

Create an integer variable called top and set it to -1 to track the top of the stack

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

Write a function pop that removes the top element from the stack if it is not empty

Push the numbers 10, 20, and 30 onto the stack

Pop one element from the stack

Print the current elements in the stack from bottom to top

💡 Why This Matters

🌍 Real World

Stacks are used in many places like undo features in apps, browser history, and managing function calls in programs.

💼 Career

Understanding stack implementation helps in software development, debugging, and working with low-level system programming.

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

# Create the stack array and top variable
// Your code here

Hint

Use int stack[5]; to create the array and int top = -1; to track the top.

2

Write the push function

Write a function called push that takes an integer value and adds it to stack if top is less than 4. Increase top by 1 and assign value to stack[top].

DSA C

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

// Write the push function below
// Your code here

Hint

Check if top is less than 4 before adding. Increase top then assign the value.

3

Write the pop function and push values

Write a function called pop that decreases top by 1 if top is not -1. Then, use push to add 10, 20, and 30 to the stack.

DSA C

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

void push(int value) {
    if (top < 4) {
        top++;
        stack[top] = value;
    }
}

// Write the pop function below
// Your code here

// Push 10, 20, 30 below
// Your code here

Hint

In pop, check if top is not -1 before decreasing it. Then call push three times with 10, 20, and 30.

4

Pop one element and print the stack

Call pop() once to remove the top element. Then use a for loop with i from 0 to top to print each element in stack[i] separated by spaces.

DSA C

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

void push(int value) {
    if (top < 4) {
        top++;
        stack[top] = value;
    }
}

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

int main() {
    push(10);
    push(20);
    push(30);
    
    // Pop one element
    // Your code here

    // Print stack elements
    // Your code here

    return 0;
}

Hint

Call pop() once. Then loop from 0 to top and print each stack[i] with a space.

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 in the stack

C. To automatically resize the stack when full

D. To sort elements in ascending order

Solution

1. Step 1: Understand stack storage

   A stack stores elements in a linear order where the last added element is accessed first.

2. Step 2: Role of array in stack

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

3. Final Answer:

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

4. Quick Check:

   Array = fixed-size linear storage [OK]

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

Common Mistakes:

• Thinking array allows automatic resizing
• Confusing stack with random access structures
• Assuming array sorts elements automatically

2. Which of the following is the correct way to declare a stack array of size 5 in C?

easy

A. int[5] stack;

B. int stack[5];

C. stack int[5];

D. array stack = int[5];

Solution

1. Step 1: Recall C array declaration syntax

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

2. Step 2: Match syntax with options

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

3. Final Answer:

   int stack[5]; -> Option B

4. Quick Check:

   C array declaration = int stack[5]; [OK]

Hint: C arrays declared as type name[size]; [OK]

Common Mistakes:

• Placing type after variable name
• Using incorrect keywords like 'array'
• Misplacing brackets in declaration

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

int stack[3];
int top = -1;
// Push 10
stack[++top] = 10;
// Push 20
stack[++top] = 20;
// Pop
int x = stack[top--];
printf("%d", stack[top]);

medium

A. Runtime error

B. 20

C. 10

D. Garbage value

Solution

1. Step 1: Trace push operations

   Initially top = -1.
   Push 10: top becomes 0, stack[0] = 10.
   Push 20: top becomes 1, stack[1] = 20.

2. Step 2: Trace pop and print

   Pop: x = stack[1] = 20, then top becomes 0.
   Print stack[top] = stack[0] = 10.

3. Final Answer:

   10 -> Option C

4. Quick Check:

   After pop, top points to 10 [OK]

Hint: Pop decreases top, print uses updated top [OK]

Common Mistakes:

• Printing popped element instead of current top
• Confusing pre-increment and post-decrement
• Assuming top points beyond last element

4. Identify the error in this stack push function and select the fix:

void push(int stack[], int *top, int size, int value) {
    if (*top == size) {
        printf("Stack Overflow\n");
        return;
    }
    stack[++(*top)] = value;
}

medium

A. No error, code is correct

B. Change condition to *top == size + 1

C. Change stack[++(*top)] to stack[(*top)++]

D. Change condition to *top == size - 1

Solution

1. Step 1: Understand top indexing in stack

   Top starts at -1, max index is size - 1.
   When top == size - 1, stack is full.

2. Step 2: Analyze overflow condition

   Condition *top == size is wrong; it should be *top == size - 1 to detect full stack.

3. Final Answer:

   Change condition to *top == size - 1 -> Option D

4. Quick Check:

   Overflow when top reaches size-1 [OK]

Hint: Top max index is size-1, not size [OK]

Common Mistakes:

• Checking top == size instead of size-1
• Misusing increment operators in array indexing
• Ignoring zero-based indexing

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

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

Assume top starts at -1 and push/pop update top accordingly. Choose the correct final stack content from bottom to top.

hard

A. 5 -> 15 -> 25 -> null

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

C. 10 -> 15 -> 25 -> null

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

Solution

1. Step 1: Trace each operation 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
   pop(): removes 20, top=1
   push(25): top=2, stack[2]=25

2. Step 2: Final stack content

   Stack from bottom (index 0) to top (index 2): 5, 15, 25

3. Final Answer:

   5 -> 15 -> 25 -> null -> Option A

4. Quick Check:

   Push/pop update top correctly [OK]

Hint: Track top index after each push/pop [OK]

Common Mistakes:

• Forgetting to update top after pop
• Assuming pop removes bottom element
• Mixing order of elements after operations