Delete Node at Beginning in DSA Typescript - Build from Scratch

Delete Node at Beginning in a Singly Linked List

📖 Scenario: Imagine you have a line of people waiting to buy tickets. Sometimes, the first person in line leaves. We want to update the line to show who is now first.

🎯 Goal: You will create a simple singly linked list, then remove the first person (node) from the list, and finally show the updated line.

📋 What You'll Learn

Create a singly linked list with exactly three nodes containing values 10, 20, and 30 in that order

Create a variable called head that points to the first node

Write code to delete the first node by updating head

Print the linked list values from head to the end after deletion

💡 Why This Matters

🌍 Real World

Linked lists are used in many programs to manage ordered data where items can be added or removed easily, like managing playlists or undo history.

💼 Career

Understanding linked lists and how to manipulate them is a key skill for software developers, especially for roles involving data structures and algorithms.

1

Create the Singly Linked List

Create three nodes with values 10, 20, and 30. Link them so that node1 points to node2, and node2 points to node3. Create a variable called head that points to node1.

DSA Typescript

// Create nodes and link them
// Your code here

Hint

Define a Node class with value and next. Create three nodes and link them. Set head to the first node.

2

Prepare to Delete the First Node

Create a variable called temp and set it equal to head. This will help us keep track of the node we want to delete.

DSA Typescript

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

const node1 = new Node(10);
const node2 = new Node(20);
const node3 = new Node(30);

node1.next = node2;
node2.next = node3;

let head = node1;

// Create a variable temp and set it to head
// Your code here

Hint

Use let temp = head; to keep a reference to the first node before deleting it.

3

Delete the First Node

Update the head variable to point to the second node in the list. This effectively removes the first node from the list.

DSA Typescript

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

const node1 = new Node(10);
const node2 = new Node(20);
const node3 = new Node(30);

node1.next = node2;
node2.next = node3;

let head = node1;

let temp = head;

// Update head to point to the second node
// Your code here

Hint

Set head = head.next; to remove the first node from the list.

4

Print the Updated Linked List

Write a while loop to print the values of the linked list starting from head. Print each value followed by ->. After the last node, print null.

DSA Typescript

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

const node1 = new Node(10);
const node2 = new Node(20);
const node3 = new Node(30);

node1.next = node2;
node2.next = node3;

let head = node1;

let temp = head;

head = head.next;

// Print the linked list values from head
// Your code here

Hint

Use a while loop to go through each node starting at head. Add each value and an arrow to a string. After the loop, add null and print the string.

Practice

1. What happens when you delete the first node in a singly linked list?

easy

A. The head pointer moves to the second node

B. The last node is deleted

C. The list becomes empty immediately

D. The middle node is removed

Solution

1. Step 1: Understand the head pointer role

   The head pointer points to the first node in the list.

2. Step 2: Delete the first node by moving head

   Deleting the first node means moving the head pointer to the next node.

3. Final Answer:

   The head pointer moves to the second node -> Option A

4. Quick Check:

   Delete first node = move head to next [OK]

Hint: Deleting first node means moving head to next node [OK]

Common Mistakes:

• Thinking the last node is deleted
• Assuming list becomes empty always
• Deleting a middle node instead

2. Which of the following is the correct TypeScript syntax to delete the first node in a singly linked list with head pointer head?

easy

A. head = head.next;

B. head.next = head;

C. delete head;

D. head = null.next;

Solution

1. Step 1: Understand head and next pointers

   head points to first node; head.next points to second node.

2. Step 2: Assign head to head.next to delete first node

   Setting head = head.next moves head to second node, effectively deleting first.

3. Final Answer:

   head = head.next; -> Option A

4. Quick Check:

   Correct syntax to delete first node = head = head.next; [OK]

Hint: Use head = head.next to delete first node [OK]

Common Mistakes:

• Using delete keyword incorrectly
• Assigning head.next to head
• Accessing null.next causing error

3. Given the linked list: 1 -> 2 -> 3 -> null and the code snippet:

head = head.next;

What is the resulting linked list?

medium

A. 1 -> 2 -> 3 -> null

B. 2 -> 3 -> null

C. 3 -> null

D. null

Solution

1. Step 1: Initial list and head pointer

   Head points to node with value 1, list is 1 -> 2 -> 3 -> null.

2. Step 2: Move head to head.next

   head = head.next moves head to node with value 2, removing first node.

3. Final Answer:

   2 -> 3 -> null -> Option B

4. Quick Check:

   After deletion, list starts at 2 [OK]

Hint: After head = head.next, list starts from second node [OK]

Common Mistakes:

• Assuming list remains unchanged
• Thinking last node is deleted
• Confusing node values after deletion

4. Consider this TypeScript code to delete the first node:

if (head !== null) {
  head = head.next;
}

What error does this fix compared to just head = head.next;?

medium

A. Prevents deleting the last node

B. Prevents memory leak

C. Prevents runtime error if list is empty

D. Prevents deleting middle node

Solution

1. Step 1: Understand head could be null

   If list is empty, head is null and head.next causes error.

2. Step 2: Check head before accessing next

   Condition ensures head is not null before moving to head.next, avoiding runtime error.

3. Final Answer:

   Prevents runtime error if list is empty -> Option C

4. Quick Check:

   Check head != null before head.next avoids error [OK]

Hint: Check head not null before deleting first node [OK]

Common Mistakes:

• Ignoring null head causing crash
• Thinking it prevents memory leaks
• Confusing node positions deleted

5. You have a singly linked list with nodes: 10 -> 20 -> 30 -> 40 -> null. You want to delete the first two nodes safely. Which code snippet correctly does this?

hard

A. head = null;

B. head = head.next; head = head.next;

C. head.next = head.next.next;

D. if (head && head.next) { head = head.next.next; }

Solution

1. Step 1: Understand deleting two nodes means moving head twice

   Deleting first two nodes means head should point to third node.

2. Step 2: Check head and head.next exist before moving head twice

   Condition ensures no runtime error when accessing head.next.next.

3. Final Answer:

   if (head && head.next) { head = head.next.next; } -> Option D

4. Quick Check:

   Check head and head.next before double move [OK]

Hint: Check head and head.next before skipping two nodes [OK]

Common Mistakes:

• Not checking head.next causing error
• Assigning head.next instead of head
• Setting head to null deletes entire list