Push Operation on Stack in DSA C++

Mental Model

A stack is like a pile where you add new 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 put it on the top, not at the bottom or middle.

Top -> null
Stack: null

Dry Run Walkthrough

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

Goal: Show how the stack grows by adding new items 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, previous top moves down

Step 3: Push 30 onto stack

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

Why: Always add new item on top, keeping order

Result:

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

Annotated Code

DSA C++

#include <iostream>
using namespace std;

class Node {
public:
    int data;
    Node* next;
    Node(int val) : data(val), next(nullptr) {}
};

class Stack {
private:
    Node* top;
public:
    Stack() : top(nullptr) {}

    void push(int val) {
        Node* newNode = new Node(val); // create new node with value
        newNode->next = top;           // link new node to current top
        top = newNode;                 // update top to new node
    }

    void print() {
        Node* curr = top;
        while (curr != nullptr) {
            cout << curr->data << " -> ";
            curr = curr->next;
        }
        cout << "null" << endl;
    }
};

int main() {
    Stack s;
    s.push(10);
    s.push(20);
    s.push(30);
    s.print();
    return 0;
}

Node* newNode = new Node(val); // create new node with value

create a new node to hold the pushed value

newNode->next = top; // link new node to current top

point new node's next to current top to keep stack order

top = newNode; // update top to new node

update top pointer to new node, making it the new top

Output

30 -> 20 -> 10 -> null

Complexity Analysis

Time: O(1) because push adds one item on top without traversing

Space: O(1) extra space for the new node created during push

vs Alternative: Compared to arrays where resizing may be needed, 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 = newNode;                 // 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 items on top efficiently.

Common Mistakes

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

Summary

Adds a new item on top of the stack.

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

The new item always points to the previous 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. Removes the top element from the stack

C. Returns the bottom element of the stack

D. Adds an element to the top of the stack

Solution

1. Step 1: Understand stack behavior

   A stack follows Last In First Out (LIFO) principle, where elements are added or removed from the top.

2. Step 2: Define push operation

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

3. Final Answer:

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

4. Quick Check:

   Push = Add top element [OK]

Hint: Push means add element on top of stack [OK]

Common Mistakes:

• Confusing push with pop operation
• Thinking push removes elements
• Assuming push checks stack emptiness

2. Which of the following is the correct syntax to push an integer 10 onto a stack named stk in C++ STL?

easy

A. stk.push(10);

B. stk.add(10);

C. stk.insert(10);

D. stk.append(10);

Solution

1. Step 1: Recall C++ STL stack methods

   The standard method to add an element to a stack is push().

2. Step 2: Match correct syntax

   Using stk.push(10); correctly pushes 10 onto the stack.

3. Final Answer:

   stk.push(10); -> Option A

4. Quick Check:

   push() is the correct method [OK]

Hint: Use push() to add elements in C++ stack [OK]

Common Mistakes:

• Using add(), insert(), or append() which are not stack methods
• Forgetting parentheses after push
• Confusing vector methods with stack

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

std::stack<int> stk;
stk.push(5);
stk.push(10);
stk.push(15);
int topElement = stk.top();

What is the value of topElement?

medium

A. 15

B. 10

C. 0

D. 5

Solution

1. Step 1: Trace push operations

   Elements pushed in order: 5, then 10, then 15. Stack top is last pushed element.

2. Step 2: Identify top element

   The top element after pushes is 15, as it was pushed last.

3. Final Answer:

   15 -> Option A

4. Quick Check:

   Last pushed = top element = 15 [OK]

Hint: Top element is last pushed value [OK]

Common Mistakes:

• Choosing first pushed element as top
• Confusing top() with pop()
• Assuming stack is empty initially

4. Identify the error in the following code snippet that tries to push an element onto a stack:

std::stack<int> stk;
stk.push 20;

medium

A. Using wrong data type for stack

B. Stack not declared properly

C. Missing parentheses in push call

D. No error in the code

Solution

1. Step 1: Check push syntax

   The push method requires parentheses around the argument, like push(20).

2. Step 2: Identify syntax error

   Code uses stk.push 20; missing parentheses, causing a syntax error.

3. Final Answer:

   Missing parentheses in push call -> Option C

4. Quick Check:

   push() needs parentheses [OK]

Hint: Always use parentheses with push() [OK]

Common Mistakes:

• Omitting parentheses after push
• Confusing push with pop syntax
• Assuming stack declaration is wrong

5. Given an empty stack, what will be the state of the stack after executing the following code?

std::stack<int> stk;
stk.push(1);
stk.push(2);
stk.push(3);
stk.pop();
stk.push(4);

Choose the correct sequence of elements from top to bottom.

hard

A. 3 -> 2 -> 1 -> null

B. 4 -> 2 -> 1 -> null

C. 1 -> 2 -> 4 -> null

D. 2 -> 4 -> 1 -> null

Solution

1. Step 1: Trace push and pop operations

   Push 1, stack: 1
   Push 2, stack: 2 -> 1
   Push 3, stack: 3 -> 2 -> 1
   Pop removes top (3), stack: 2 -> 1
   Push 4, stack: 4 -> 2 -> 1

2. Step 2: Write final stack state

   Top to bottom: 4 -> 2 -> 1 -> null

3. Final Answer:

   4 -> 2 -> 1 -> null -> Option B

4. Quick Check:

   Push/pop order = 4,2,1 [OK]

Hint: Pop removes top; next push adds new top [OK]

Common Mistakes:

• Ignoring pop effect on stack
• Assuming push adds at bottom
• Mixing order of elements after pop