Push Operation on Stack in DSA Java

Mental Model

A stack adds new items on top, like stacking plates one on another.

Analogy: Imagine a stack of plates: you always put a new plate on the top, never in the middle or bottom.

Top -> null
Stack: null

Dry Run Walkthrough

Input: stack: empty, push values 10, then 20

Goal: Add values to the top of the stack in order

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 with 10

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

Why: New item goes on top, previous top moves down

Result:

Top -> 20 -> 10 -> null

Annotated Code

DSA Java

public class Stack {
    private static class Node {
        int value;
        Node next;
        Node(int value) { this.value = value; this.next = null; }
    }

    private Node top;

    public Stack() {
        top = null;
    }

    public void push(int value) {
        Node newNode = new Node(value); // create new node with value
        newNode.next = top; // link new node to current top
        top = newNode; // update top to new node
    }

    public void printStack() {
        Node current = top;
        while (current != null) {
            System.out.print(current.value + " -> ");
            current = current.next;
        }
        System.out.println("null");
    }

    public static void main(String[] args) {
        Stack stack = new Stack();
        stack.push(10);
        stack.push(20);
        stack.printStack();
    }
}

Node newNode = new Node(value); // 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

20 -> 10 -> null

Complexity Analysis

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

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

vs Alternative: Compared to array-based stack, linked list push avoids resizing and shifting elements

Edge Cases

pushing onto an empty stack

top becomes the new node with no next node

DSA Java

newNode.next = top; // link new node to current top

When to Use This Pattern

When you need to add items in last-in-first-out order, use push operation on stack to add on top efficiently.

Common Mistakes

Mistake: Not updating the top pointer to the new node after push
Fix: Assign top = newNode after linking newNode.next to old top

Summary

Adds a new item 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 previous top, then becomes the new top.

Practice

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

easy

A. Adds an element to the top of the stack

B. Removes the top element from the stack

C. Checks if the stack is empty

D. Returns the bottom element of the stack

Solution

1. Step 1: Understand stack behavior

   A stack follows Last In First Out (LIFO) principle, so new elements are added on top.

2. Step 2: Define push operation

   The push operation adds a new element to the top of the stack, increasing its size by one.

3. Final Answer:

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

4. Quick Check:

   Push = Add top element [OK]

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

Common Mistakes:

• Confusing push with pop
• Thinking push removes element
• Assuming push adds at bottom

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

easy

A. stack.add(10);

B. stack.push(10);

C. stack.insert(10);

D. stack.put(10);

Solution

1. Step 1: Recall Java Stack API

   Java's Stack class uses the method push() to add elements.

2. Step 2: Match correct method

   Among options, only push() is the correct method to add elements to a stack.

3. Final Answer:

   stack.push(10); -> Option B

4. Quick Check:

   Java stack push method = push() [OK]

Hint: Use push() method to add elements in Java stack [OK]

Common Mistakes:

• Using add() which is for lists
• Using insert() which doesn't exist
• Using put() which is for maps

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

Stack<Integer> stack = new Stack<>();
stack.push(5);
stack.push(10);
stack.push(15);
System.out.println(stack);

medium

A. [5, 15, 10]

B. [15, 10, 5]

C. [10, 15, 5]

D. [5, 10, 15]

Solution

1. Step 1: Trace push operations

   Elements 5, 10, and 15 are pushed in order, so stack stores them as [5, 10, 15].

2. Step 2: Understand Stack's toString()

   Java's Stack prints elements from bottom to top in list format, so output is [5, 10, 15].

3. Final Answer:

   [5, 10, 15] -> Option D

4. Quick Check:

   Stack print shows bottom to top [OK]

Hint: Stack prints bottom to top in Java [OK]

Common Mistakes:

• Assuming print shows top element first
• Confusing stack with queue order
• Expecting reversed list output

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

Stack<String> stack = new Stack<>();
stack.push("Hello");
stack.push(100);

medium

A. Stack must be initialized with size

B. Stack class does not have push method

C. Cannot push integer 100 into a Stack of Strings

D. Missing semicolon after push statements

Solution

1. Step 1: Check stack type and pushed elements

   The stack is declared to hold Strings only, but 100 is an integer.

2. Step 2: Identify type mismatch error

   Pushing an integer into a String stack causes a compile-time type error.

3. Final Answer:

   Cannot push integer 100 into a Stack of Strings -> Option C

4. Quick Check:

   Type mismatch error = pushing wrong data type [OK]

Hint: Stack type must match pushed element type [OK]

Common Mistakes:

• Ignoring generic type mismatch
• Thinking push method missing
• Assuming size needed at init

5. Given an empty stack, which sequence of push operations will result in the stack containing elements in this order from bottom to top: 3 -> 7 -> 5 -> null?

hard

A. push(3), push(7), push(5)

B. push(5), push(7), push(3)

C. push(7), push(3), push(5)

D. push(5), push(3), push(7)

Solution

1. Step 1: Understand stack order after pushes

   Elements pushed first are at bottom, last pushed at top.

2. Step 2: Match push order to desired stack

   To get 3 at bottom, then 7, then 5 on top, push in order: 3, then 7, then 5.

3. Final Answer:

   push(3), push(7), push(5) -> Option A

4. Quick Check:

   Push order = bottom to top [OK]

Hint: Push elements in bottom-to-top order [OK]

Common Mistakes:

• Reversing push order
• Confusing push with pop order
• Assuming stack inserts at bottom