Push Operation on Stack in DSA Go

Mental Model

A stack is like a pile where you add new items only on top. Push 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 of the stack.

Top
 ↑
[ ] -> null
(empty stack)

Dry Run Walkthrough

Input: stack: empty, push values 5, then 10, then 15

Goal: Add values one by one on top of the stack and show the stack after each push

Step 1: push 5 onto empty stack

Top -> [5] -> null

Why: First item becomes the top of the stack

Step 2: push 10 onto stack

Top -> [10] -> [5] -> null

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

Step 3: push 15 onto stack

Top -> [15] -> [10] -> [5] -> null

Why: Always add new item on top, keep order below

Result:

Top -> [15] -> [10] -> [5] -> null

Annotated Code

DSA Go

package main

import "fmt"

type Node struct {
    value int
    next  *Node
}

type Stack struct {
    top *Node
}

func (s *Stack) Push(val int) {
    newNode := &Node{value: val, next: s.top} // create new node pointing to current top
    s.top = newNode                          // update top to new node
}

func (s *Stack) Print() {
    curr := s.top
    for curr != nil {
        fmt.Printf("%d -> ", curr.value) // print current node value
        curr = curr.next                  // move to next node
    }
    fmt.Println("null")
}

func main() {
    stack := &Stack{}
    stack.Push(5)
    stack.Print()
    stack.Push(10)
    stack.Print()
    stack.Push(15)
    stack.Print()
}

newNode := &Node{value: val, next: s.top} // create new node pointing to current top

create new node with value and link it to current top

s.top = newNode // update top to new node

update stack top pointer to new node

Output

5 -> null

10 -> 5 -> null

15 -> 10 -> 5 -> 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, making it always O(1)

Edge Cases

empty stack

push creates the first node and sets it as top

DSA Go

s.top = newNode                          // update top to new node

When to Use This Pattern

When you need to add an item to the top of a collection with last-in-first-out order, use the push operation on a stack.

Common Mistakes

Mistake: Not linking the new node to the current top, losing the rest of the stack
Fix: Set newNode.next = s.top before updating s.top to newNode

Summary

Push adds a new item on top of the stack.

Use push when you want to add elements in last-in-first-out order.

The key is to link the new node to the current top before updating the top pointer.

Practice

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

easy

A. Returns the bottom element of the stack

B. Removes the top element from the stack

C. Adds an element to the top of the stack

D. Checks if the stack is empty

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.

3. Final Answer:

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

4. Quick Check:

   Push = Add top [OK]

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

Common Mistakes:

• Confusing push with pop operation
• Thinking push removes elements
• Assuming push accesses bottom element

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

easy

A. s.push(5)

B. s.Push(5)

C. push(s, 5)

D. s = append(s, 5)

Solution

1. Step 1: Understand Go slice as stack

   In Go, stacks are often implemented using slices. To push, append adds element at the end.

2. Step 2: Identify correct syntax

   Using append(s, 5) adds 5 to the slice s, simulating push.

3. Final Answer:

   s = append(s, 5) -> Option D

4. Quick Check:

   Go push = append slice [OK]

Hint: Use append to push in Go slices [OK]

Common Mistakes:

• Using lowercase push method which doesn't exist
• Calling push as a function without method
• Ignoring that slices need reassignment after append

3. What will be the output after executing this Go code?

stack := []int{1, 2, 3}
stack = append(stack, 4)
fmt.Println(stack)

medium

A. [1 2 3 4]

B. [4 1 2 3]

C. [1 2 3]

D. runtime error

Solution

1. Step 1: Initial stack state

   Stack slice starts as [1 2 3].

2. Step 2: Append 4 to stack

   Append adds 4 at the end, so stack becomes [1 2 3 4].

3. Final Answer:

   [1 2 3 4] -> Option A

4. Quick Check:

   Append adds at end [OK]

Hint: Append adds element at slice end [OK]

Common Mistakes:

• Expecting append to add at start
• Confusing append with insert
• Thinking append causes error without reassignment

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

var stack []int
stack.push(10)

medium

A. Stack is not initialized

B. push method does not exist for slices

C. Missing import for stack package

D. Cannot push integer 10

Solution

1. Step 1: Check stack type and methods

   Stack is a slice of int. Slices do not have a push method in Go.

2. Step 2: Identify correct push approach

   To push, use append function instead of push method.

3. Final Answer:

   push method does not exist for slices -> Option B

4. Quick Check:

   Slices lack push method [OK]

Hint: Slices use append, no push method [OK]

Common Mistakes:

• Assuming push is built-in method for slices
• Thinking stack must be initialized first
• Believing import fixes method absence

5. Given a stack implemented as a slice in Go, how would you push multiple elements 7, 8, 9 in one operation?

hard

A. stack = append(stack, []int{7, 8, 9}...)

B. stack.push(7); stack.push(8); stack.push(9)

C. append(stack, 7, 8, 9)

D. stack = append(stack, []int{7, 8, 9})

Solution

1. Step 1: Understand appending multiple elements

   To add multiple elements from a slice, use the ... operator to unpack them.

2. Step 2: Identify correct append syntax

   Using append(stack, []int{7, 8, 9}...) adds all three elements individually.

3. Final Answer:

   stack = append(stack, []int{7, 8, 9}...) -> Option A

4. Quick Check:

   Use ... to unpack slice in append [OK]

Hint: Use ... to append multiple elements at once [OK]

Common Mistakes:

• Forgetting to assign the result of append back to stack
• Using non-existent push method multiple times
• Appending slice without unpacking elements