Push Using Linked List Node in DSA Javascript - Build from Scratch

Push Using Linked List Node

📖 Scenario: Imagine you are managing a simple list of tasks. You want to add new tasks to the front of the list so that the most recent task is always first.

🎯 Goal: Build a linked list and add new nodes to the front using the push operation.

📋 What You'll Learn

Create a Node class with value and next properties

Create a LinkedList class with a head property

Add a push method to add a new node at the front

Print the linked list values in order after pushing nodes

💡 Why This Matters

🌍 Real World

Linked lists are used in many applications like task scheduling, undo functionality, and managing playlists where order and quick insertions matter.

💼 Career

Understanding linked lists and how to manipulate nodes is fundamental for software developers working with data structures, improving problem-solving and coding skills.

1

Create Node and LinkedList classes

Create a class called Node with a constructor that takes a parameter value and sets this.value to it and this.next to null. Also create a class called LinkedList with a constructor that sets this.head to null.

DSA Javascript

// Your code here

Hint

Think of Node as a box holding a value and a pointer to the next box. The LinkedList starts empty with head as null.

2

Add push method to LinkedList

Inside the LinkedList class, add a method called push that takes a parameter value. Inside this method, create a new Node with the given value.

DSA Javascript

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

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

    // Add push method that creates a new Node with value
    // Your code here
}

Hint

Use new Node(value) to create a new node inside the push method.

3

Link new node at the front

Complete the push method by setting newNode.next to the current head of the list, then update head to newNode.

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);
        // Link newNode to current head and update head
        // Your code here
    }
}

Hint

Make the new node point to the old first node, then update the list's head to the new node.

4

Print the linked list values

Create a variable list as a new LinkedList. Use push to add values 10, 20, and 30 in that order. Then write a printList function that prints the linked list values separated by -> and ending with null. Finally, call printList(list).

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);
        newNode.next = this.head;
        this.head = newNode;
    }
}

// Create list, push values, and print list
// Your code here

Hint

Remember, pushing adds to the front, so the last pushed value appears first.

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