Push Using Linked List Node in DSA Javascript

Mental Model

Adding a new item to the start of a linked list means making the new item point to the current first item, then updating the start to the new item.

Analogy: Imagine a line of people holding hands. To add a new person at the front, the new person grabs the hand of the first person, then becomes the new front of the line.

head -> 1 -> 2 -> 3 -> null

Dry Run Walkthrough

Input: list: 1 -> 2 -> 3 -> null, push value 0

Goal: Add a new node with value 0 at the start of the list

Step 1: Create new node with value 0

newNode(0) -> null
head -> 1 -> 2 -> 3 -> null

Why: We need a new node to add to the list

Step 2: Set new node's next to current head (node 1)

newNode(0) -> 1 -> 2 -> 3 -> null
head -> 1 -> 2 -> 3 -> null

Why: New node must point to the old first node to keep the list connected

Step 3: Update head to new node

head -> 0 -> 1 -> 2 -> 3 -> null

Why: Head must point to the new first node

Result:

head -> 0 -> 1 -> 2 -> 3 -> null

Annotated Code

DSA Javascript

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

class LinkedList {
  constructor() {
    this.head = null;
  }

  push(value) {
    const newNode = new Node(value); // create new node
    newNode.next = this.head; // link new node to current head
    this.head = newNode; // update head to new node
  }

  printList() {
    let curr = this.head;
    let result = '';
    while (curr) {
      result += curr.value + ' -> ';
      curr = curr.next;
    }
    result += 'null';
    console.log(result);
  }
}

// Driver code
const list = new LinkedList();
list.push(3);
list.push(2);
list.push(1);
list.printList(); // prints 1 -> 2 -> 3 -> null

list.push(0); // push 0 at start
list.printList(); // prints 0 -> 1 -> 2 -> 3 -> null

const newNode = new Node(value); // create new node

create a new node with the given value

newNode.next = this.head; // link new node to current head

point new node's next to current head to keep list connected

this.head = newNode; // update head to new node

update head pointer to new node to make it first

Output

1 -> 2 -> 3 -> null

0 -> 1 -> 2 -> 3 -> null

Complexity Analysis

Time: O(1) because we only change a few pointers without traversing the list

Space: O(1) because we only create one new node regardless of list size

vs Alternative: Compared to adding at the end which takes O(n) to find the tail, pushing at the start is faster and simpler

Edge Cases

empty list

new node becomes the head and points to null

DSA Javascript

newNode.next = this.head; // link new node to current head

single element list

new node points to the single existing node, becomes new head

DSA Javascript

this.head = newNode; // update head to new node

When to Use This Pattern

When you need to add an item quickly at the start of a linked list, use the push pattern to update the head pointer efficiently.

Common Mistakes

Mistake: Forgetting to update the head pointer to the new node
Fix: Always assign the head to the new node after linking its next

Mistake: Setting new node's next to null instead of current head
Fix: Set newNode.next = this.head to keep the list connected

Summary

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

Use when you want to insert quickly at the start without traversing.

The new node points to the old head, then head updates to new node.

Practice

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

easy

A. Removes the last node from the list

B. Adds a new node at the beginning of 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: Compare with other operations

   Removing or searching nodes are different operations, not push.

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 node at the start of the list [OK]

Common Mistakes:

• Confusing push with pop or delete
• Thinking push adds at the end
• Mixing push with search operation

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

easy

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

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

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

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

Solution

1. Step 1: Create new node and link it to current head

   We create a new node, set its next to current head, then update head to new node.

2. Step 2: Check each option

   let newNode = new Node(value); newNode.next = head; head = newNode; correctly does this. Others either reverse assignments or miss new keyword.

3. Final Answer:

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

4. Quick Check:

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

Hint: New node's next points to old head, then update head [OK]

Common Mistakes:

• Forgetting to use 'new' keyword
• Assigning head before setting newNode.next
• Mixing order of assignments

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

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

let head = null;

function push(value) {
  let newNode = new Node(value);
  newNode.next = head;
  head = newNode;
}

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

medium

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

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

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

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

Solution

1. Step 1: Trace push calls and list updates

   First push(10): head = 10 -> null
   Second push(20): head = 20 -> 10 -> null
   Third push(30): head = 30 -> 20 -> 10 -> null

2. Step 2: Confirm final linked list order

   New nodes are added at front, so list is 30 -> 20 -> 10 -> null.

3. Final Answer:

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

4. Quick Check:

   Last pushed is first in list [OK]

Hint: Last pushed node becomes new head [OK]

Common Mistakes:

• Assuming push adds at end
• Confusing order of nodes
• Ignoring that head updates each push

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

function push(value) {
  let newNode = Node(value);
  newNode.next = head;
  head = newNode;
}

medium

A. Missing 'new' keyword when creating newNode

B. Incorrect assignment of newNode.next

C. head should be assigned before newNode.next

D. Function should return the new head

Solution

1. Step 1: Check node creation syntax

   Node is a class; must use 'new' keyword to create instance. Missing here.

2. Step 2: Verify other assignments

   newNode.next = head and head = newNode are correct order and assignments.

3. Final Answer:

   Missing 'new' keyword when creating newNode -> Option A

4. Quick Check:

   Use 'new' to create class instance [OK]

Hint: Always use 'new' with class constructors [OK]

Common Mistakes:

• Forgetting 'new' causes runtime error
• Swapping assignment order
• Expecting push to return head

5. Given a linked list with nodes 5 -> 15 -> 25 -> null, what will be the list after pushing a new node with value 10 using the push function?

function push(value) {
  let newNode = new Node(value);
  newNode.next = head;
  head = newNode;
}

Assume head points to the first node (5).

medium

A. 10 -> 5 -> 15 -> 25 -> null

B. 5 -> 15 -> 25 -> 10 -> null

C. 5 -> 10 -> 15 -> 25 -> null

D. 25 -> 15 -> 5 -> 10 -> null

Solution

1. Step 1: Understand push adds node at front

   Push creates new node with value 10, sets its next to current head (5), then updates head to new node.

2. Step 2: Visualize new list order

   New head is 10, followed by old list 5 -> 15 -> 25 -> null, so final list is 10 -> 5 -> 15 -> 25 -> null.

3. Final Answer:

   10 -> 5 -> 15 -> 25 -> null -> Option A

4. Quick Check:

   Push adds new node at front [OK]

Hint: Push inserts new node before current head [OK]

Common Mistakes:

• Appending new node at end instead of front
• Not updating head pointer
• Mixing node order after push