Push Operation on Stack in DSA C

Mental Model

A stack is like a pile where you add items only on top. Pushing means putting a new item on the top of this pile.

Analogy: Imagine a stack of plates. When you add a new plate, you always place it on the top of the stack.

Top -> null
Stack: null

Dry Run Walkthrough

Input: Start with empty stack, push values 10, then 20, then 30

Goal: Add each new value on top of the stack so the last pushed is on top

Step 1: Push 10 onto empty stack

Top -> [10] -> null

Why: First item becomes the top of the stack

Step 2: Push 20 onto stack

Top -> [20] -> [10] -> null

Why: New item goes on top, points to previous top

Step 3: Push 30 onto stack

Top -> [30] -> [20] -> [10] -> null

Why: Keep adding new items on top, linking to old top

Result:

Top -> [30] -> [20] -> [10] -> null

Annotated Code

DSA C

#include <stdio.h>
#include <stdlib.h>

// Node structure for stack
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// Push function to add element on top
void push(Node** top_ref, int value) {
    Node* new_node = (Node*)malloc(sizeof(Node));
    new_node->data = value;
    new_node->next = *top_ref; // link new node to current top
    *top_ref = new_node;       // update top to new node
}

// Print stack from top to bottom
void printStack(Node* top) {
    Node* current = top;
    while (current != NULL) {
        printf("%d -> ", current->data);
        current = current->next;
    }
    printf("null\n");
}

int main() {
    Node* stackTop = NULL; // empty stack

    push(&stackTop, 10);
    push(&stackTop, 20);
    push(&stackTop, 30);

    printStack(stackTop);
    return 0;
}

new_node->next = *top_ref; // link new node to current top

link new node to current top to keep stack order

*top_ref = new_node; // update top to new node

update top pointer to new node to make it the new top

Output

30 -> 20 -> 10 -> null

Complexity Analysis

Time: O(1) because push adds one node at the top without traversing

Space: O(1) because only one new node is created per push

vs Alternative: Compared to array push which may require resizing, linked list push is always O(1) without shifting

Edge Cases

Empty stack

Push creates first node and sets it as top

DSA C

*top_ref = new_node;       // update top to new node

When to Use This Pattern

When you see a problem needing last-in-first-out order, reach for stack push because it adds elements on top efficiently.

Common Mistakes

Mistake: Not linking new node's next to current top before updating top
Fix: Always set new_node->next = *top_ref before changing *top_ref

Summary

Adds a new element on top of the stack.

Use when you want to store items in last-in-first-out order.

The new item always points to the old top, then becomes the new top.

Practice

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

easy

A. Checks if the stack is empty

B. Adds an element to the top of the stack

C. Removes the top element from the stack

D. Returns the bottom element of the stack

Solution

1. Step 1: Understand stack operations

   A stack is a data structure where elements are added or removed from the top only.

2. Step 2: Define push operation

   The push operation adds a new element on top of the existing elements in the stack.

3. Final Answer:

   Adds an element to the top of the stack -> Option B

4. Quick Check:

   Push means add on top = C [OK]

Hint: Push always adds on top of stack [OK]

Common Mistakes:

• Confusing push with pop operation
• Thinking push removes elements
• Mixing stack with queue operations

2. Which of the following is the correct syntax to push an element 5 onto a stack named s in C?

easy

A. s.push = 5;

B. s.push(5);

C. push(5, s);

D. push(s, 5);

Solution

1. Step 1: Understand typical C stack push syntax

   In C, stack operations are usually functions where the stack is passed as the first argument.

2. Step 2: Match syntax with parameters

   The correct function call to push 5 onto stack s is push(s, 5);.

3. Final Answer:

   push(s, 5); -> Option D

4. Quick Check:

   Function push(stack, value) = A [OK]

Hint: In C, function push(stack, value) is standard [OK]

Common Mistakes:

• Using object.method syntax (not C style)
• Swapping argument order
• Assigning value instead of calling function

3. What will be the content of the stack after executing the following code?

int stack[5];
int top = -1;
// Push function
void push(int val) {
  if(top < 4) {
    top++;
    stack[top] = val;
  }
}

push(10);
push(20);
push(30);

medium

A. [10, 20, 30]

B. [30, 20, 10]

C. [10, 20]

D. Empty stack

Solution

1. Step 1: Trace each push call

   Initially, top = -1. After push(10), top=0, stack[0]=10. After push(20), top=1, stack[1]=20. After push(30), top=2, stack[2]=30.

2. Step 2: List stack content from bottom to top

   Stack elements from index 0 to top (2) are [10, 20, 30].

3. Final Answer:

   [10, 20, 30] -> Option A

4. Quick Check:

   Push adds at top increasing index = B [OK]

Hint: Stack stores pushed elements in order at increasing top index [OK]

Common Mistakes:

• Reversing order of elements
• Confusing top index with element values
• Assuming stack is empty after pushes

4. Identify the error in the following push function for a stack of size 3:

int stack[3];
int top = 0;
void push(int val) {
  if(top <= 3) {
    stack[top] = val;
    top++;
  }
}

medium

A. Condition should be top < 3, not top <= 3

B. top should be incremented before assignment

C. stack array size should be 4

D. top should start at -1, not 0

Solution

1. Step 1: Analyze top and condition

   top starts at 0, which is valid for empty stack at index 0. The condition allows top to be 3, which is out of bounds for stack[3] (indices 0 to 2).

2. Step 2: Correct the condition

   Change condition to top < 3 to prevent overflow and invalid access.

3. Final Answer:

   Condition should be top < 3, not top <= 3 -> Option A

4. Quick Check:

   Stack max index 2 means top < 3 [OK]

Hint: Check array bounds: top must be less than size [OK]

Common Mistakes:

• Allowing top to equal array size causing overflow
• Starting top at -1 but not adjusting code
• Incrementing top before assignment causing skip

5. Given a stack implemented with an array of size 4 and top = 2 currently, what will happen if we try to push two more elements without popping?
Choose the correct behavior.

hard

A. Both pushes fail immediately due to full stack

B. Both pushes succeed, stack size automatically increases

C. First push succeeds, second push causes stack overflow

D. First push causes overflow, second push is not attempted

Solution

1. Step 1: Understand current stack state

   Array size is 4, so valid indices are 0 to 3. top=2 means top element is at index 2, so one slot remains at index 3.

2. Step 2: Push two elements

   First push increments top to 3 and stores element at index 3 (valid). Second push tries to increment top to 4, which is out of bounds, causing overflow.

3. Final Answer:

   First push succeeds, second push causes stack overflow -> Option C

4. Quick Check:

   Array size 4, top max index 3, overflow after that [OK]

Hint: Stack size fixed; overflow after last index [OK]

Common Mistakes:

• Assuming stack auto-expands
• Thinking both pushes fail immediately
• Confusing top index with count