Push Using Linked List Node in DSA Typescript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the 'push' operation do in a linked list?

It adds a new node at the beginning (head) of the linked list, making it the new first element.

beginner

In a singly linked list, what pointer does the new node's 'next' field point to after a push?

It points to the current head node before the push, linking the new node to the rest of the list.

intermediate

Why is pushing a node at the head of a linked list efficient?

Because it only requires changing a few pointers without traversing the list, so it runs in constant time O(1).

beginner

TypeScript code snippet: What does this line do?
const newNode = new Node(data);

It creates a new linked list node object holding the given data, ready to be linked into the list.

beginner

What must be updated after linking the new node's 'next' to the current head in a push operation?

The head pointer of the linked list must be updated to point to the new node, making it the new first node.

What is the time complexity of pushing a node at the head of a singly linked list?

A O(n)

B O(1)

C O(log n)

D O(n^2)

Pushing at the head only changes pointers and does not require traversal, so it runs in constant time O(1).

After pushing a new node, what does the linked list's head point to?

A The second node

B The old tail node

C Null

D The new node

The head pointer is updated to the new node after push, making it the first node in the list.

In TypeScript, which keyword is used to create a new linked list node?

A init

B create

C new

D make

The 'new' keyword creates a new instance of a class, such as a linked list node.

What does the 'next' pointer of a new node point to after a push?

A The previous head node

B Null

C The tail node

D Itself

The new node's 'next' points to the old head node to link the list correctly.

Which of these is NOT a step in pushing a node to a linked list head?

A Traverse to the tail node

B Set new node's next to current head

C Create new node

D Update head to new node

Pushing at head does not require traversal; it only updates pointers at the front.

Explain step-by-step how to push a new node at the head of a singly linked list.

Think about how the new node connects to the old list and becomes the first node.

Why is pushing a node at the head of a linked list faster than adding at the tail?

Consider how many nodes you must visit for each operation.

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