Push Using Linked List Node in DSA Typescript - Execution Trace

Concept Flow - Push Using Linked List Node

Create new node with value

↓

Set new node.next to current head

↓

Update head to new node

↓

Done

Push operation adds a new node at the start by linking it to the current head and then updating head to this new node.

Execution Sample

DSA Typescript

class Node {
  value: number;
  next: Node | null;
  constructor(value: number) {
    this.value = value;
    this.next = null;
  }
}

class LinkedList {
  head: Node | null = null;
  push(value: number) {
    const newNode = new Node(value);
    newNode.next = this.head;
    this.head = newNode;
  }
}

const list = new LinkedList();
list.push(10);
list.push(20);
list.push(30);

This code creates a linked list and pushes three nodes with values 10, 20, and 30 at the front.

Execution Table

Step	Operation	Nodes in List	Pointer Changes	Visual State
1	Push 10	10	newNode.next = null (head was null), head = newNode	10 -> null
2	Push 20	20 -> 10	newNode.next = head (10), head = newNode	20 -> 10 -> null
3	Push 30	30 -> 20 -> 10	newNode.next = head (20), head = newNode	30 -> 20 -> 10 -> null

💡 All push operations complete; head points to last pushed node (30).

Variable Tracker

Variable	Start	After Push 10	After Push 20	After Push 30
head	null	Node(10)	Node(20)	Node(30)
newNode.value	-	10	20	30
newNode.next	-	null	Node(10)	Node(20)

Key Moments - 3 Insights

Why does newNode.next point to the current head before updating head?

Because newNode.next must link to the existing list to keep nodes connected. See execution_table step 2 and 3 where newNode.next points to previous head before head updates.

What happens if the list is empty before push?

The head is null, so newNode.next is set to null. This is shown in execution_table step 1 where head was null before push.

Why does head update after setting newNode.next?

Updating head last ensures the new node points to the old list first, then head points to new node, preserving list integrity. Refer to pointer changes column in execution_table.

Visual Quiz - 3 Questions

Look at the execution_table at step 2, what does newNode.next point to?

A null

B Node with value 10

C Node with value 20

D Node with value 30

💡 Hint

Check the Pointer Changes column at step 2 in execution_table.

At which step does the head first point to a non-null node?

A Step 2

B Step 3

C Step 1

D Start

💡 Hint

Look at the head variable in variable_tracker after each push.

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

A 40

B 20

C 30

D 10

💡 Hint

New nodes become the new head as shown in variable_tracker and execution_table.

Concept Snapshot

Push Using Linked List Node:
- Create new node with value
- Set newNode.next to current head
- Update head to newNode
- New node becomes list start
- List grows at front with each push

Full Transcript

Push operation in a linked list adds a new node at the front. First, a new node is created with the given value. Then, this new node's next pointer is set to the current head of the list. Finally, the head pointer is updated to point to this new node. This way, the new node becomes the first node, and the list grows by adding nodes at the front. The execution table shows each push step, the pointer changes, and the resulting list state. The variable tracker follows how head and newNode pointers change after each push. Key moments clarify why newNode.next is set before updating head and what happens when the list is initially empty.

Practice

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

easy

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

B. Removes the last node from the list

C. Searches for a node with a specific value

D. Deletes the first node of the list

Solution

1. Step 1: Understand push operation in linked list

   The push operation adds a new node to the start (head) of the linked list.

2. Step 2: Effect of push on linked list

   The new node becomes the new head, pointing to the previous first node.

3. Final Answer:

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

4. Quick Check:

   Push means add at head = D [OK]

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

Common Mistakes:

• Confusing push with pop (removal)
• Thinking push adds at the end
• Mixing push with search or delete

2. Which of the following is the correct TypeScript syntax to create a new node and push it to the front of a singly linked list?

easy

A. newNode = new Node(value); head = newNode.next;

B. const newNode = Node(value); head.next = newNode; head = newNode;

C. const newNode = new Node(value); newNode.next = head; head = newNode;

D. head = new Node(value); head.next = null;

Solution

1. Step 1: Create a new node with given value

   Use new Node(value) to create a node instance.

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

   Set newNode.next = head and then head = newNode to push at front.

3. Final Answer:

   const newNode = new Node(value); newNode.next = head; head = newNode; -> Option C

4. Quick Check:

   New node points to old head, head updated = A [OK]

Hint: New node next points to head, then head updated [OK]

Common Mistakes:

• Forgetting to link new node's next to old head
• Assigning head.next instead of newNode.next
• Not updating head to new node

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

class Node {
  value: number;
  next: Node | null = null;
  constructor(value: number) { this.value = value; }
}

let head: Node | null = null;

function push(value: number) {
  const newNode = new Node(value);
  newNode.next = head;
  head = newNode;
}

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

medium

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

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

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

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

Solution

1. Step 1: Push 10 to empty list

   Head becomes node with value 10, next is null.

2. Step 2: Push 20 and then 30

   Each new node points to previous head, so order is 30 -> 20 -> 10 -> null.

3. Final Answer:

   30 -> 20 -> 10 -> null -> Option D

4. Quick Check:

   Last pushed is head = A [OK]

Hint: Last pushed node is always new head [OK]

Common Mistakes:

• Assuming push adds at tail
• Reading list in wrong order
• Confusing next pointers

4. Identify the error in this push function for a singly linked list:

function push(value: number) {
  const newNode = new Node(value);
  head.next = newNode;
  head = newNode;
}

medium

A. head might be null causing runtime error

B. head.next = newNode is missing

C. head is assigned before linking newNode

D. Node constructor is called incorrectly

Solution

1. Step 1: Check head usage before assignment

   The code uses head.next without checking if head is null.

2. Step 2: Consequence of head being null

   If list is empty (head null), accessing head.next causes runtime error.

3. Final Answer:

   head might be null causing runtime error -> Option A

4. Quick Check:

   Accessing head.next without null check = B [OK]

Hint: Always check if head is null before accessing head.next [OK]

Common Mistakes:

• Not checking for empty list before push
• Forgetting to set newNode.next
• Assigning head incorrectly

5. Given a linked list with nodes containing values [5, 15, 25] (5 is head), what will be the list after pushing 35 and then 45 using the push function?
Also, explain how the head changes after each push.

hard

A. 35 -> 45 -> 5 -> 15 -> 25 -> null; head moves to 35 then 45

B. 45 -> 35 -> 5 -> 15 -> 25 -> null; head moves to newest node each push

C. 5 -> 15 -> 25 -> 35 -> 45 -> null; head stays at 5

D. null; list is cleared after push

Solution

1. Step 1: Initial list and push 35

   Original head is 5. Push 35 creates new node 35 pointing to 5. Head updates to 35.

2. Step 2: Push 45 and update head

   Push 45 creates new node 45 pointing to 35. Head updates to 45. Final list: 45 -> 35 -> 5 -> 15 -> 25 -> null.

3. Final Answer:

   45 -> 35 -> 5 -> 15 -> 25 -> null; head moves to newest node each push -> Option B

4. Quick Check:

   Push adds at front, head updates = C [OK]

Hint: Head always points to last pushed node [OK]

Common Mistakes:

• Assuming push adds at tail
• Not updating head after push
• Confusing node order after pushes