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?

↓

Set new node as top

↓

Update top pointer to new node

↓

Done

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

Execution Sample

DSA C

struct Node {
  int data;
  struct Node* next;
};

void push(struct Node** top, int val) {
  struct Node* newNode = malloc(sizeof(struct Node));
  newNode->data = val;
  newNode->next = *top;
  *top = newNode;
}

This code adds a new element to the top of the stack by creating a new node and updating pointers.

Execution Table

Step	Operation	Nodes in Stack	Pointer Changes	Visual State
1	Start with empty stack	None	top = NULL	top -> NULL
2	Create new node with value 10	Node(10)	newNode created	top -> NULL, newNode(10)
3	Set newNode.next to top (NULL)	Node(10)	newNode->next = NULL	top -> NULL, newNode(10)->NULL
4	Update top to newNode	Node(10)	top = newNode	top -> Node(10) -> NULL
5	Create new node with value 20	Node(20), Node(10)	newNode created	top -> Node(10) -> NULL, newNode(20)
6	Set newNode.next to top (Node(10))	Node(20), Node(10)	newNode->next = top	top -> Node(10) -> NULL, newNode(20) -> Node(10) -> NULL
7	Update top to newNode	Node(20), Node(10)	top = newNode	top -> Node(20) -> Node(10) -> NULL
8	Create new node with value 30	Node(30), Node(20), Node(10)	newNode created	top -> Node(20) -> Node(10) -> NULL, newNode(30)
9	Set newNode.next to top (Node(20))	Node(30), Node(20), Node(10)	newNode->next = top	top -> Node(20) -> Node(10) -> NULL, newNode(30) -> Node(20) -> Node(10) -> NULL
10	Update top to newNode	Node(30), Node(20), Node(10)	top = newNode	top -> Node(30) -> Node(20) -> Node(10) -> NULL
11	End of push operations	Node(30), Node(20), Node(10)	top points to Node(30)	top -> Node(30) -> Node(20) -> Node(10) -> NULL

💡 All push operations completed, stack top updated accordingly.

Variable Tracker

Variable	Start	After Step 2	After Step 5	After Step 8	Final
top	NULL	Node(10)	Node(20)	Node(30)	Node(30)
newNode	N/A	Node(10)	Node(20)	Node(30)	Node(30)

Key Moments - 3 Insights

Why do we set newNode->next to the current top before updating top?

Because newNode must point to the previous top node to keep the stack linked. This is shown in steps 3, 6, and 9 where newNode->next is assigned before top is updated in steps 4, 7, and 10.

What happens if the stack is empty before push?

If the stack is empty (top is NULL), newNode->next is set to NULL (step 3), and then top is updated to newNode (step 4), making the new node the only element.

How does the visual state show the stack growing?

The visual state shows the top pointer moving to the new node each time, with the new node pointing to the previous top, forming a chain that grows at the front (steps 4, 7, 10).

Visual Quiz - 3 Questions

Look at the execution table at step 7, what does the top pointer point to?

A Node with value 10

B Node with value 30

C Node with value 20

D NULL

💡 Hint

Check the 'Pointer Changes' and 'Visual State' columns at step 7.

At which step does the stack first become non-empty?

A Step 2

B Step 4

C Step 1

D Step 3

💡 Hint

Look for when top changes from NULL to a node in the 'Pointer Changes' column.

If we push a new value 40 after step 10, what will newNode->next point to?

A Node with value 30

B NULL

C Node with value 20

D Node with value 10

💡 Hint

Refer to the pattern in steps 3, 6, and 9 where newNode->next points to the current top.

Concept Snapshot

Push Operation on Stack:
- Create a new node with the value.
- Set new node's next pointer to current top.
- Update top pointer to new node.
- Stack grows by adding nodes at the front.
- Works even if stack is empty (top is NULL).

Full Transcript

The push operation on a stack adds a new element at the top. First, a new node is created with the given value. If the stack is empty, the new node's next pointer is set to NULL. Otherwise, it points to the current top node. Then, the top pointer is updated to this new node, making it the new top of the stack. This process repeats for each push, growing the stack by linking new nodes at the front. The execution table shows each step, including pointer changes and the visual linked list state. The variable tracker follows the top pointer and newNode across steps. Key moments clarify why newNode->next is set before updating top, how empty stack is handled, and how the visual state reflects stack growth. The visual quiz tests understanding of pointer updates and stack state changes during push operations.