Push Using Linked List Node in DSA C - Execution Trace

Concept Flow - Push Using Linked List Node

Create new node

↓

Set new node's next to current head

↓

Update head to new node

↓

Done

This flow shows how a new node is created and added at the start of the linked list by adjusting pointers.

Execution Sample

DSA C

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

void push(struct Node** head_ref, int new_data) {
    struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));
    new_node->data = new_data;
    new_node->next = *head_ref;
    *head_ref = new_node;
}

This code creates a new node with given data and inserts it at the beginning of the linked list.

Execution Table

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

💡 All nodes pushed; head points to last inserted node; list is 30 -> 20 -> 10 -> NULL

Variable Tracker

Variable	Start	After Step 2	After Step 5	After Step 8	Final
head	NULL	NULL	Node(10)	Node(20)	Node(30)
new_node	N/A	Node(10)	Node(20)	Node(30)	N/A
new_node->next	N/A	NULL	Node(10)	Node(20)	N/A

Key Moments - 3 Insights

Why do we set new_node->next to head before updating head?

Because new_node->next must point to the current first node to keep the list connected. See execution_table rows 3, 6, and 9 where new_node->next is set before head changes.

What happens if the list is empty when we push a node?

The new node's next points to NULL (empty list), and head updates to new node. See execution_table rows 1 to 4 showing empty list to one node.

Why does head point to the last inserted node after push?

Because push inserts at the front, so head always updates to the new node. See execution_table rows 4, 7, and 10.

Visual Quiz - 3 Questions

Look at the execution_table at step 6, what does new_node->next point to?

A Node with data 10

B NULL

C Node with data 20

D Head pointer

💡 Hint

Check 'Pointer Changes' column at step 6 in execution_table

At which step does the head pointer first point to a node with data 20?

A Step 5

B Step 7

C Step 4

D Step 10

💡 Hint

Look at 'Pointer Changes' and 'Nodes in List' columns in execution_table

If we skip setting new_node->next to head, what will happen to the list?

A List will be empty

B Head will not update

C New node will point to NULL, breaking the chain

D List will have duplicate nodes

💡 Hint

Refer to key_moments explanation about new_node->next pointer

Concept Snapshot

Push Using Linked List Node:
- Create new node
- Set new_node->next to current head
- Update head to new_node
- New node becomes first element
- List grows at front
- Head always points to newest node

Full Transcript

This concept shows how to add a new node at the start of a linked list. We create a new node, set its next pointer to the current head, then update the head to this new node. This way, the new node becomes the first element. The execution table traces each step, showing how nodes and pointers change. Key moments clarify why pointer updates happen in this order and what occurs when the list is empty. The visual quiz tests understanding of pointer assignments and list structure after pushes.

Practice

1. What does the push operation do in a linked list when using nodes?

easy

A. Searches for a node with a specific value

B. Adds a new node at the beginning of the list

C. Removes the last node from the list

D. Deletes the entire linked list

Solution

1. Step 1: Understand the push operation

   The push operation adds a new element to the linked list.

2. Step 2: Identify where the new node is added

   In a linked list, push adds the new node at the start (head) of the list.

3. Final Answer:

   Adds a new node at the beginning of the list -> Option B

4. Quick Check:

   Push = Add at head [OK]

Hint: Push always adds at the start of the linked list [OK]

Common Mistakes:

• Thinking push adds at the end
• Confusing push with pop
• Assuming push deletes nodes

2. Which of the following is the correct syntax to create a new node and push it onto the linked list in C?

easy

A. newNode = malloc(sizeof(Node)); newNode->prev = head; head = newNode;

B. newNode = malloc(Node); newNode->next = head; head = newNode;

C. newNode = malloc(sizeof(Node)); newNode->next = head; head = newNode;

D. newNode = malloc(sizeof(Node)); head = newNode->next; newNode = head;

Solution

1. Step 1: Allocate memory correctly for new node

   Use malloc(sizeof(Node)) to allocate memory for the new node.

2. Step 2: Link new node to current head and update head

   Set newNode->next to current head, then update head to newNode.

3. Final Answer:

   newNode = malloc(sizeof(Node)); newNode->next = head; head = newNode; -> Option C

4. Quick Check:

   Correct malloc and linking = newNode = malloc(sizeof(Node)); newNode->next = head; head = newNode; [OK]

Hint: Use sizeof(Node) with malloc and link newNode->next to head [OK]

Common Mistakes:

• Forgetting sizeof in malloc
• Assigning head before setting newNode->next
• Using prev pointer in singly linked list

3. What will be the linked list after executing the following code?

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

Node* head = NULL;

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

push(10);
push(20);
push(30);

medium

A. 30 -> 20 -> 10 -> null

B. 10 -> 20 -> 30 -> null

C. 20 -> 30 -> 10 -> null

D. 10 -> 30 -> 20 -> null

Solution

1. Step 1: Trace each push call

   push(10) adds 10 at head: 10 -> null; push(20) adds 20 at head: 20 -> 10 -> null; push(30) adds 30 at head: 30 -> 20 -> 10 -> null.

2. Step 2: Confirm final linked list order

   The last pushed value is at the head, so list is 30 -> 20 -> 10 -> null.

3. Final Answer:

   30 -> 20 -> 10 -> null -> Option A

4. Quick Check:

   Last pushed is head = 30 -> 20 -> 10 [OK]

Hint: Last pushed node is always at the head [OK]

Common Mistakes:

• Assuming push adds at tail
• Reading list in wrong order
• Confusing push with append

4. Identify the error in this push function and select the correct fix:

void push(int val) {
  Node* newNode;
  newNode->data = val;
  newNode->next = head;
  head = newNode;
}

medium

A. head should be assigned before newNode->next

B. newNode->data should be assigned after head update

C. newNode->next should be NULL instead of head

D. newNode is not allocated memory; fix by malloc(sizeof(Node))

Solution

1. Step 1: Check newNode initialization

   newNode is declared but not allocated memory with malloc, so it points to garbage.

2. Step 2: Fix by allocating memory

   Use newNode = malloc(sizeof(Node)) before accessing newNode->data or newNode->next.

3. Final Answer:

   newNode is not allocated memory; fix by malloc(sizeof(Node)) -> Option D

4. Quick Check:

   Always malloc before using newNode [OK]

Hint: Always allocate memory before using new node [OK]

Common Mistakes:

• Using uninitialized pointer
• Assigning data before allocation
• Changing head before linking newNode

5. You want to push multiple values 5, 15, 25 onto an empty linked list using the push function below. After pushing, you want to print the list from head to tail. Which code snippet correctly performs this and prints the list?

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

Node* head = NULL;

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

// Your code here to push and print

hard

A. push(5); push(15); push(25); Node* temp = head; while(temp) { printf("%d -> ", temp->data); temp = temp->next; } printf("null\n");

B. push(5); push(15); push(25); Node* temp = head; while(temp->next) { printf("%d -> ", temp->data); temp = temp->next; } printf("null\n");

C. push(25); push(15); push(5); Node* temp = head; while(temp) { printf("%d -> ", temp->data); temp = temp->next; } printf("null\n");

D. push(5); push(15); push(25); Node* temp = head; while(temp) { printf("%d ", temp->data); temp = temp->next; }

Solution

1. Step 1: Push values in correct order

   Push 5, then 15, then 25. Each push adds at head, so list is 25 -> 15 -> 5 -> null.

2. Step 2: Print all nodes correctly

   Use a loop while(temp) to print each node's data followed by '->', then print 'null' after loop.

3. Final Answer:

   push(5); push(15); push(25); Node* temp = head; while(temp) { printf("%d -> ", temp->data); temp = temp->next; } printf("null\n"); -> Option A

4. Quick Check:

   Push order + full print loop = push(5); push(15); push(25); Node* temp = head; while(temp) { printf("%d -> ", temp->data); temp = temp->next; } printf("null\n"); [OK]

Hint: Push in order, print with while(temp) loop ending with null [OK]

Common Mistakes:

• Pushing in reverse order
• Using while(temp->next) and missing last node
• Not printing 'null' at end