Delete from Beginning of Doubly Linked List in DSA Javascript - Build from Scratch

Delete from Beginning of Doubly Linked List

📖 Scenario: You are managing a playlist of songs using a doubly linked list. Each song is a node with a title and pointers to the previous and next songs. You want to remove the first song from the playlist when you start playing the next one.

🎯 Goal: Build a doubly linked list with three songs, then delete the first song from the list, and finally print the updated playlist from start to end.

📋 What You'll Learn

Create a doubly linked list with three nodes having titles: 'Song A', 'Song B', 'Song C'.

Create a variable called head pointing to the first node.

Create a function called deleteFromBeginning that removes the first node from the list and updates head.

Print the titles of the songs in the list from beginning to end after deletion.

💡 Why This Matters

🌍 Real World

Doubly linked lists are used in music players, browsers, and other apps to move forward and backward through items efficiently.

💼 Career

Understanding linked list operations like deletion is essential for software development roles involving data structures and memory management.

1

Create the Doubly Linked List with Three Songs

Create three nodes called node1, node2, and node3 representing songs with titles 'Song A', 'Song B', and 'Song C'. Link them to form a doubly linked list. Create a variable called head that points to node1.

DSA Javascript

# Your code here to create nodes and link them

Hint

Define a Node class with title, prev, and next. Create three nodes and link them so that node1 points to node2 and node2 points to node3. Set head to node1.

2

Create a Function to Delete from Beginning

Create a function called deleteFromBeginning that updates the head to the second node and sets the new head.prev to null if the list is not empty.

DSA Javascript

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

const node1 = new Node('Song A');
const node2 = new Node('Song B');
const node3 = new Node('Song C');

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

let head = node1;

// Your code here to create deleteFromBeginning function

Hint

Inside deleteFromBeginning, check if head is not null. Then move head to head.next. If the new head is not null, set its prev to null.

3

Call the Delete Function

Call the function deleteFromBeginning() to remove the first song from the doubly linked list.

DSA Javascript

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

const node1 = new Node('Song A');
const node2 = new Node('Song B');
const node3 = new Node('Song C');

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

let head = node1;

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

// Your code here to call deleteFromBeginning

Hint

Simply call deleteFromBeginning() to remove the first node.

4

Print the Updated Playlist

Use a while loop with a variable current starting at head to print the titles of the songs in the doubly linked list separated by -> . End with null.

DSA Javascript

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

const node1 = new Node('Song A');
const node2 = new Node('Song B');
const node3 = new Node('Song C');

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

let head = node1;

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

deleteFromBeginning();

// Your code here to print the list

Hint

Start from head and keep moving to next nodes. Add each title to a string with -> between them. After the loop, add null and print the string.

Practice

1. What happens to the head pointer when you delete the first node from a doubly linked list?

easy

A. It remains unchanged

B. It moves to the second node in the list

C. It points to the last node

D. It becomes null immediately

Solution

1. Step 1: Understand the head pointer role

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

2. Step 2: Effect of deleting the first node

   When the first node is deleted, the head pointer must move to the next node, which becomes the new first node.

3. Final Answer:

   It moves to the second node in the list -> Option B

4. Quick Check:

   Head points to new first node after deletion [OK]

Hint: Head always points to the first node after deletion [OK]

Common Mistakes:

• Assuming head becomes null without checking list length
• Not updating head pointer after deletion
• Pointing head to last node mistakenly

2. Which of the following is the correct syntax to delete the first node from a doubly linked list in JavaScript?

easy

A. head.prev = null; head = head.next;

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

C. head.next = null; head = head.prev;

D. head = head.next; head.prev = null;

Solution

1. Step 1: Move head to next node

   Assign head to head.next to remove the first node reference.

2. Step 2: Update new head's prev pointer

   Set head.prev to null to disconnect backward link from old first node.

3. Final Answer:

   head = head.next; head.prev = null; -> Option D

4. Quick Check:

   Correct syntax updates head and prev pointer [OK]

Hint: Update head first, then set new head.prev to null [OK]

Common Mistakes:

• Setting head.prev before moving head
• Setting head.next to null incorrectly
• Nullifying head before updating pointers

3. Consider the doubly linked list: 10 <-> 20 <-> 30 <-> null. After deleting the first node, what will be the new list?

medium

A. 30 <-> null

B. 10 <-> 30 <-> null

C. 20 <-> 30 <-> null

D. null

Solution

1. Step 1: Identify the first node

   The first node is 10, which will be removed.

2. Step 2: Update head to second node

   Head moves to 20, and 20.prev is set to null.

3. Final Answer:

   20 <-> 30 <-> null -> Option C

4. Quick Check:

   First node removed, list starts at 20 [OK]

Hint: After deletion, list starts from second node [OK]

Common Mistakes:

• Leaving old head in list
• Not updating prev pointer of new head
• Removing wrong node

4. Given this code snippet to delete the first node, what is the error?

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

medium

A. head.prev assignment causes error if list has one node

B. No error, code works fine

C. head.next should be assigned to null before head update

D. head should be set to null before updating prev

Solution

1. Step 1: Check list with one node

   If list has one node, head.next is null after head = head.next.

2. Step 2: Accessing head.prev causes error

   head is now null, so head.prev causes runtime error (cannot read property 'prev' of null).

3. Final Answer:

   head.prev assignment causes error if list has one node -> Option A

4. Quick Check:

   Null head causes error on prev access [OK]

Hint: Check if head is null before accessing head.prev [OK]

Common Mistakes:

• Not handling single-node list case
• Accessing properties of null head
• Assuming list always has multiple nodes

5. You have a doubly linked list with nodes: 5 <-> 15 <-> 25 <-> 35 <-> null. Write a function to delete the first node and return the updated list head. What will be the list after deletion?

hard

A. 15 <-> 25 <-> 35 <-> null

B. 5 <-> 25 <-> 35 <-> null

C. 25 <-> 35 <-> null

D. null

Solution

1. Step 1: Move head to next node

   Head moves from 5 to 15, the second node.

2. Step 2: Set new head's prev to null

   Set 15.prev = null to disconnect from old first node.

3. Step 3: Return updated head

   Return the new head pointing to 15.

4. Final Answer:

   15 <-> 25 <-> 35 <-> null -> Option A

5. Quick Check:

   First node removed, list starts at 15 [OK]

Hint: Update head and set new head.prev to null [OK]

Common Mistakes:

• Not updating prev pointer of new head
• Returning old head instead of new head
• Deleting wrong node or skipping nodes