Push Operation on Stack in DSA Go - Execution Trace

Concept Flow - Push Operation on Stack

Create new element

↓

Check if stack is empty?

No→Set new element.next = current top

↓

Update top pointer to new element

↓

Set top pointer to new element

↓

Done

The push operation creates a new element, links it to the current top if any, then updates the top pointer to the new element.

Execution Sample

DSA Go

stack := NewStack()
stack.Push(10)
stack.Push(20)
stack.Push(30)

This code creates a stack and pushes three values onto it, one by one.

Execution Table

Step	Operation	Nodes in Stack	Pointer Changes	Visual State
1	Push 10	10	top -> 10	10 -> null
2	Push 20	20 -> 10	new node.next = 10, top -> 20	20 -> 10 -> null
3	Push 30	30 -> 20 -> 10	new node.next = 20, top -> 30	30 -> 20 -> 10 -> null
4	End	30 -> 20 -> 10	top -> 30	30 -> 20 -> 10 -> null

💡 All push operations completed; stack top points to last pushed element.

Variable Tracker

Variable	Start	After 1	After 2	After 3	Final
top	null	10	20	30	30
stack size	0	1	2	3	3

Key Moments - 2 Insights

Why does the new element point to the old top instead of the other way around?

Because the stack grows by adding new elements on top, the new element must link to the previous top to keep the order. See execution_table step 2 and 3 where new node.next points to the old top.

What happens if the stack is empty before pushing?

If empty, the new element's next is null and top points directly to it. This is shown in execution_table step 1 where top moves from null to 10.

Visual Quiz - 3 Questions

Look at the execution_table, what is the top pointer after step 2?

A Points to node with value 30

B Points to node with value 10

C Points to node with value 20

D Null

💡 Hint

Check the 'Pointer Changes' column in execution_table row for step 2.

At which step does the stack size become 3 according to variable_tracker?

A After 1

B After 3

C After 2

D Final

💡 Hint

Look at the 'stack size' row in variable_tracker and find when it reaches 3.

If we push a new element with value 40 after step 3, what will be the new visual state?

A 40 -> 30 -> 20 -> 10 -> null

B 30 -> 20 -> 10 -> 40 -> null

C 10 -> 20 -> 30 -> 40 -> null

D 40 -> 10 -> 20 -> 30 -> null

💡 Hint

Recall that new elements are added on top, see execution_table visual states for previous pushes.

Concept Snapshot

Push Operation on Stack:
- Create new node with value
- If stack empty, top points to new node
- Else new node.next = current top
- Update top to new node
- Stack grows by adding on top
- Visual: new node -> old top -> ... -> null

Full Transcript

The push operation on a stack adds a new element on top. First, a new node is created with the value to push. If the stack is empty, the top pointer is set to this new node. Otherwise, the new node's next pointer links to the current top node. Then the top pointer updates to the new node. This way, the stack grows by adding new elements on top, maintaining last-in-first-out order. The execution table shows each push step updating the top pointer and the linked nodes. The variable tracker shows how the top pointer and stack size change after each push. Key moments clarify why the new node points to the old top and what happens when the stack is empty. The visual quiz tests understanding of pointer updates and stack state after pushes.

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