Doubly Linked List Structure and Node Design in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare the previous node pointer in a doubly linked list node.

DSA Java

class Node {
    int data;
    Node next;
    Node [1];

    Node(int data) {
        this.data = data;
        next = null;
        prev = null;
    }
}

Drag options to blanks, or click blank then click option'

ApreviousNode

Bprev

Clast

Dprior

Attempts:

3 left

💡 Hint

Common Mistakes

Using non-standard or longer names like 'previousNode' instead of 'prev'.

Confusing 'next' and 'prev' pointers.

The standard name for the pointer to the previous node in a doubly linked list is 'prev'.

2fill in blank

medium

Complete the constructor to initialize the data field of the node.

DSA Java

class Node {
    int data;
    Node next;
    Node prev;

    Node(int [1]) {
        this.data = data;
        next = null;
        prev = null;
    }
}

Drag options to blanks, or click blank then click option'

Adata

BnodeData

Citem

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different parameter name and causing confusion in assignment.

Forgetting to initialize the data field.

The constructor parameter should match the variable used to initialize the data field, which is 'data'.

3fill in blank

hard

Fix the error in the method to set the previous node pointer.

DSA Java

public void setPrev(Node [1]) {
    this.prev = prevNode;
}

Drag options to blanks, or click blank then click option'

AnodePrev

Bprev

Cprevious

DprevNode

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for the parameter and the variable inside the method.

Causing a compilation error due to undefined variable.

The parameter name must match the variable used in the method body. Here, 'prevNode' is used, so the parameter must be named 'prevNode'.

4fill in blank

hard

Fill both blanks to complete the method that returns the next node.

DSA Java

public Node [1]() {
    return [2];
}

Drag options to blanks, or click blank then click option'

AgetNext

Bnext

CgetPrev

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up 'prev' and 'next' pointers.

Naming the method incorrectly.

The method to get the next node is named 'getNext' and it returns the 'next' pointer.

5fill in blank

hard

Fill all three blanks to complete the method that inserts a new node after the current node.

DSA Java

public void insertAfter(Node [1]) {
    [1].prev = this;
    [1].[3] = this.[3];
    if (this.[3] != null) {
        this.[3].prev = [1];
    }
    [2] = [1];
}

Drag options to blanks, or click blank then click option'

AnewNode

Bnext

Cthis.next

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Confusing 'next' and 'prev' pointers during insertion.

Forgetting to update the previous pointer of the next node.

The new node parameter is 'newNode'. We set 'this.next' to 'newNode' and use 'next' to check and update the next node's prev pointer.

Practice

1. What is the main difference between a doubly linked list node and a singly linked list node?

easy

A. A doubly linked list node does not store any data.

B. A doubly linked list node stores data in a different format.

C. A doubly linked list node can only point to the next node.

D. A doubly linked list node has pointers to both the previous and next nodes.

Solution

1. Step 1: Understand node pointers in singly linked list

   A singly linked list node has only one pointer to the next node.

2. Step 2: Understand node pointers in doubly linked list

   A doubly linked list node has two pointers: one to the previous node and one to the next node.

3. Final Answer:

   A doubly linked list node has pointers to both the previous and next nodes. -> Option D

4. Quick Check:

   Doubly linked list nodes have two pointers = D [OK]

Hint: Remember: doubly means two pointers [OK]

Common Mistakes:

• Thinking doubly linked list nodes only point forward
• Confusing data storage with pointer structure
• Assuming doubly linked list nodes have no data

2. Which of the following is the correct Java declaration for a doubly linked list node class with integer data?

easy

A. class Node { int data; Node next; }

B. class Node { int data; Node previous; }

C. class Node { int data; Node prev; Node next; }

D. class Node { int data; Node left; Node right; }

Solution

1. Step 1: Check for both previous and next pointers

   A doubly linked list node must have pointers named prev and next to link both directions.

2. Step 2: Verify data type and pointer names

   class Node { int data; Node prev; Node next; } declares int data and Node prev and Node next, which matches the doubly linked list node structure.

3. Final Answer:

   class Node { int data; Node prev; Node next; } -> Option C

4. Quick Check:

   Node with prev and next pointers = C [OK]

Hint: Look for both prev and next pointers in class [OK]

Common Mistakes:

• Missing prev pointer in node class
• Using incorrect pointer names like left/right
• Declaring only one pointer for next node

3. What will be the output of the following code snippet that creates a doubly linked list with nodes 10 and 20 and prints the data from head to tail?

class Node {
  int data;
  Node prev, next;
  Node(int d) { data = d; prev = next = null; }
}

public class TestDLL {
  public static void main(String[] args) {
    Node head = new Node(10);
    Node second = new Node(20);
    head.next = second;
    second.prev = head;
    Node current = head;
    while (current != null) {
      System.out.print(current.data + " ");
      current = current.next;
    }
  }
}

medium

A. 10 20

B. 20 10

C. 10

D. Compilation error

Solution

1. Step 1: Understand node linking

   Node head points to 10, second node is 20. head.next = second and second.prev = head links them correctly.

2. Step 2: Trace the while loop printing

   Starting at head (10), print 10, move to next (20), print 20, then next is null, loop ends.

3. Final Answer:

   10 20 -> Option A

4. Quick Check:

   Print from head to tail = 10 20 [OK]

Hint: Follow next pointers from head to print data [OK]

Common Mistakes:

• Printing in reverse order by mistake
• Forgetting to link prev pointer
• Assuming output includes null or extra spaces

4. Identify the error in the following doubly linked list node insertion code and select the correct fix:

Node newNode = new Node(30);
newNode.next = head;
head.prev = newNode;
head = newNode;

medium

A. head.prev = newNode; causes NullPointerException if head is null; fix by checking if head != null before assignment.

B. No error; code correctly inserts newNode at head.

C. newNode.next should be null; fix by setting newNode.next = null.

D. head = newNode; should be before setting pointers.

Solution

1. Step 1: Analyze pointer assignments

   newNode.next = head sets newNode's next to current head. Then head.prev = newNode sets head's prev to newNode.

2. Step 2: Check for null head case

   If head is null (empty list), head.prev causes NullPointerException. Need to check if head != null before assigning head.prev.

3. Final Answer:

   head.prev = newNode; causes NullPointerException if head is null; fix by checking if head != null before assignment. -> Option A

4. Quick Check:

   Check for null before head.prev assignment = B [OK]

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

Common Mistakes:

• Ignoring null check on head before setting prev
• Setting newNode.next to null incorrectly
• Changing head before linking nodes

5. You want to insert a new node with data 40 between two existing nodes in a doubly linked list: nodeA and nodeB, where nodeA.next = nodeB and nodeB.prev = nodeA. Which sequence of pointer updates correctly inserts the new node between nodeA and nodeB?

hard

A. newNode.next = nodeA; newNode.prev = nodeB; nodeA.prev = newNode; nodeB.next = newNode;

B. newNode.prev = nodeA; newNode.next = nodeB; nodeA.next = newNode; nodeB.prev = newNode;

C. nodeA.next = newNode; nodeB.prev = newNode; newNode.prev = nodeB; newNode.next = nodeA;

D. newNode.prev = nodeB; newNode.next = nodeA; nodeA.next = nodeB; nodeB.prev = nodeA;

Solution

1. Step 1: Set newNode pointers to link between nodeA and nodeB

   newNode.prev must point to nodeA and newNode.next must point to nodeB to place it between them.

2. Step 2: Update nodeA and nodeB pointers to include newNode

   nodeA.next should point to newNode and nodeB.prev should point to newNode to complete the insertion.

3. Final Answer:

   newNode.prev = nodeA; newNode.next = nodeB; nodeA.next = newNode; nodeB.prev = newNode; -> Option B

4. Quick Check:

   Link newNode between nodeA and nodeB correctly = A [OK]

Hint: Set newNode pointers first, then update neighbors [OK]

Common Mistakes:

• Swapping prev and next pointers incorrectly
• Updating neighbors before setting newNode pointers
• Not updating both nodeA.next and nodeB.prev