Push Operation on Stack in DSA C# - Execution Trace

Concept Flow - Push Operation on Stack

Create new node with value

↓

Check if stack is empty?

No→Set new node.next to current top

↓

Update top to new node

↓

Set top to new node

↓

Done

Shows how a new element is added on top of the stack by linking it to the previous top and updating the top pointer.

Execution Sample

DSA C#

Stack<int> stack = new Stack<int>();
stack.Push(10);
stack.Push(20);
stack.Push(30);

Push three integers onto the stack one by one, updating the top each time.

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 points to 30	30 -> 20 -> 10 -> null

💡 All push operations completed, stack top updated each time.

Variable Tracker

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

Key Moments - 3 Insights

Why does the new node's next pointer point to the current top?

Because the new node must link to the previous top to keep the stack order intact, as shown in execution_table step 2 and 3 where new node.next points to the old top.

What happens if the stack is empty before push?

The new node becomes the top with its next pointer as null, as seen in execution_table step 1 where top points to Node(10) and no next node exists.

Why do we update the top pointer after setting new node.next?

We first link the new node to the old top, then update top to the new node to maintain correct stack order, demonstrated in execution_table steps 2 and 3.

Visual Quiz - 3 Questions

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

A Node(20)

B Node(30)

C Node(10)

D null

💡 Hint

Check the Pointer Changes column in step 2 of execution_table.

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

A After 1

B After 2

C After 3

D Final

💡 Hint

Look at the stack size row in variable_tracker.

If we push a new value 40 after step 3, what will be the new top node?

A Node(10)

B Node(40)

C Node(30)

D Node(20)

💡 Hint

New pushes always update the top pointer to the new node as shown in execution_table.

Concept Snapshot

Push Operation on Stack:
- Create new node with value
- If stack empty, top = new node
- Else new node.next = top
- Update top to new node
- Stack grows by adding on top
- Visual: top -> new -> old -> ... -> 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, this new node becomes the top with no next node. If not empty, the new node's next pointer links to the current top node. Then, the top pointer updates to the new node. This keeps the stack order intact with the newest element on top. The execution table shows each push step updating the top and linking nodes. The variable tracker shows how the top pointer and stack size change after each push. Key moments clarify why the new node links to the old top and why the top pointer updates last. The visual quiz tests understanding of top pointer changes and stack size growth. This operation is fundamental to stack behavior, adding elements in last-in-first-out order.

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. Returns the bottom element 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, 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 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 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 integer value 10 onto a stack named stack in C#?

easy

A. stack.Insert(10);

B. stack.Add(10);

C. stack.Push(10);

D. stack.Push = 10;

Solution

1. Step 1: Recall Stack method for adding elements

   In C#, the Stack class uses the method Push() to add elements.

2. Step 2: Check syntax correctness

   The correct syntax is calling Push with the value inside parentheses: stack.Push(10);

3. Final Answer:

   stack.Push(10); -> Option C

4. Quick Check:

   Push method call syntax = stack.Push(value) [OK]

Hint: Use stack.Push(value) to add elements [OK]

Common Mistakes:

• Using Add or Insert which are not stack methods
• Assigning value directly to Push
• Missing parentheses in method call

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

Stack<int> stack = new Stack<int>();
stack.Push(5);
stack.Push(10);
stack.Push(15);
Console.WriteLine(string.Join(", ", stack));

medium

A. 5, 10, 15

B. 15, 10, 5

C. 10, 15, 5

D. 15, 5, 10

Solution

1. Step 1: Understand push order and stack iteration

   Elements pushed are 5, then 10, then 15. Stack stores last pushed on top.

2. Step 2: Determine iteration order when printing

   Stack enumerates from top to bottom, so output order is 15, 10, 5.

3. Final Answer:

   15, 10, 5 -> Option B

4. Quick Check:

   Stack top to bottom = 15, 10, 5 [OK]

Hint: Stack prints top element first [OK]

Common Mistakes:

• Assuming stack prints in push order
• Confusing stack with queue order
• Forgetting stack is LIFO

4. Identify the error in the following C# code that tries to push elements onto a stack:

Stack<string> stack = new Stack<string>();
stack.Push "hello";
stack.Push("world");

medium

A. Push method does not exist

B. Stack cannot hold strings

C. Missing semicolon after second Push

D. Missing parentheses in first Push call

Solution

1. Step 1: Check syntax of Push calls

   The first Push call is written as stack.Push "hello"; missing parentheses.

2. Step 2: Confirm correct method usage

   Push requires parentheses around argument: stack.Push("hello");

3. Final Answer:

   Missing parentheses in first Push call -> Option D

4. Quick Check:

   Method calls need parentheses [OK]

Hint: Always use parentheses with method calls [OK]

Common Mistakes:

• Ignoring parentheses syntax
• Thinking stack can't hold strings
• Assuming missing semicolon causes error here

5. Given a stack initially empty, what will be the content of the stack after executing the following code?

Stack<int> stack = new Stack<int>();
for (int i = 1; i <= 3; i++)
{
    stack.Push(i * 2);
}
stack.Push(10);
stack.Push(stack.Pop() + 5);

hard

A. 15, 6, 4, 2

B. 10, 8, 4, 2

C. 15, 10, 6, 4, 2

D. 10, 15, 6, 4, 2

Solution

1. Step 1: Trace the for loop pushing values

   Loop pushes 2, 4, 6 in order. Stack top is 6, bottom is 2.

2. Step 2: Push 10, then pop top and push pop+5

   Push 10: stack top to bottom 10, 6, 4, 2. Pop removes 10, 10 + 5 = 15, push 15: top to bottom 15, 6, 4, 2.

3. Final Answer:

   15, 6, 4, 2 -> Option A

4. Quick Check:

   Stack after operations = 15, 6, 4, 2 [OK]

Hint: Track push/pop stepwise to find final stack [OK]

Common Mistakes:

• Confusing pop value used for new push
• Forgetting pop removes top element
• Assuming push adds without removing