Create and Initialize Doubly Linked List in DSA C# - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a doubly linked list?

A doubly linked list is a chain of nodes where each node has three parts: data, a link to the next node, and a link to the previous node. This allows moving forward and backward through the list.

beginner

What are the main parts of a node in a doubly linked list?

Each node has: 1) Data (the value stored), 2) Next pointer (link to the next node), 3) Previous pointer (link to the previous node).

beginner

How do you create an empty doubly linked list in C#?

You create a class for the list with a head pointer set to null. This means the list has no nodes yet.

beginner

Why do we need both next and previous pointers in a doubly linked list?

Next pointer lets us move forward, previous pointer lets us move backward. This makes it easy to traverse the list in both directions.

beginner

What is the first step to add a node to an empty doubly linked list?

Create a new node with data, set its next and previous pointers to null, then set the list's head to this new node.

What does the 'previous' pointer in a doubly linked list node point to?

A The node after the current node

B The node before the current node

C The first node in the list

D The last node in the list

The 'previous' pointer points to the node before the current node, allowing backward traversal.

When initializing an empty doubly linked list, what is the value of the head pointer?

A null

B 0

C A new node

D The last node

The head pointer is set to null to indicate the list is empty.

Which of these is NOT a part of a doubly linked list node?

A Data

B Next pointer

C Previous pointer

D Child pointer

A doubly linked list node does not have a child pointer; it has data, next, and previous pointers.

What happens to the previous pointer of the new node when adding it at the beginning of a doubly linked list?

A It points to null

B It points to the old head

C It points to the last node

D It points to itself

The previous pointer of the new head node points to null because there is no node before it.

In C#, which keyword is used to define a class for a doubly linked list node?

A struct

B enum

C class

D interface

The 'class' keyword is used to define a node with data and pointers.

Explain how to create and initialize an empty doubly linked list in C#.

Think about the structure of nodes and the starting point of the list.

Describe the role of next and previous pointers in a doubly linked list node.

Consider how you move forward and backward in a list.

Practice

1. What is the main purpose of a doubly linked list in data structures?

easy

A. To allow traversal in both forward and backward directions

B. To store data in a fixed-size array

C. To sort data automatically

D. To store data only at the beginning

Solution

1. Step 1: Understand doubly linked list structure

   A doubly linked list has nodes with pointers to both next and previous nodes.

2. Step 2: Identify traversal capability

   This structure allows moving forward and backward through the list easily.

3. Final Answer:

   To allow traversal in both forward and backward directions -> Option A

4. Quick Check:

   Doubly linked list = bidirectional traversal [OK]

Hint: Remember: doubly means two directions [OK]

Common Mistakes:

• Confusing doubly linked list with arrays
• Thinking it sorts data automatically
• Assuming it only allows forward traversal

2. Which of the following is the correct way to declare a node class for a doubly linked list in C#?

easy

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

B. public class Node { int data; int next; int prev; }

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

D. public class Node { public int data; public Node next; private Node previous; }

Solution

1. Step 1: Check node fields for doubly linked list

   Node must have data, next pointer, and previous pointer of type Node.

2. Step 2: Verify correct syntax and access modifiers

   public class Node { public int data; public Node next; public Node prev; } declares public int data, and public Node next and prev correctly.

3. Final Answer:

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

4. Quick Check:

   Node class with data, next, prev = public class Node { public int data; public Node next; public Node prev; } [OK]

Hint: Node needs next and prev as Node types [OK]

Common Mistakes:

• Using int for next and prev instead of Node
• Missing prev pointer for doubly linked list
• Incorrect access modifiers

3. What will be the output of the following C# code that creates a doubly linked list with nodes 10, 20, 30 and prints forward traversal?

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

public class DoublyLinkedList {
    public Node head;
    public void AddLast(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
            return;
        }
        Node temp = head;
        while (temp.next != null) temp = temp.next;
        temp.next = newNode;
        newNode.prev = temp;
    }
    public void PrintForward() {
        Node temp = head;
        while (temp != null) {
            Console.Write(temp.data + " -> ");
            temp = temp.next;
        }
        Console.WriteLine("null");
    }
}

class Program {
    static void Main() {
        DoublyLinkedList list = new DoublyLinkedList();
        list.AddLast(10);
        list.AddLast(20);
        list.AddLast(30);
        list.PrintForward();
    }
}

medium

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

B. null

C. 10 -> 20 -> null

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

Solution

1. Step 1: Understand AddLast method behavior

   AddLast adds nodes at the end, so nodes are 10, then 20, then 30 in order.

2. Step 2: Trace PrintForward output

   PrintForward prints from head to last node: 10 -> 20 -> 30 -> null.

3. Final Answer:

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

4. Quick Check:

   Forward print = 10 -> 20 -> 30 -> null [OK]

Hint: AddLast appends; PrintForward prints from head [OK]

Common Mistakes:

• Confusing forward and backward traversal
• Missing last node in output
• Printing in reverse order

4. Identify the error in the following code snippet that tries to add a node at the end of a doubly linked list:

public void AddLast(int data) {
    Node newNode = new Node(data);
    if (head == null) {
        head = newNode;
        return;
    }
    Node temp = head;
    while (temp.next != null) {
        temp = temp.next;
    }
    temp.next = newNode;
    // Missing line here
}

medium

A. Missing setting newNode.prev = temp

B. Missing setting head = newNode

C. Missing while loop to find last node

D. Missing creating newNode instance

Solution

1. Step 1: Review AddLast logic

   After finding last node, newNode is linked as next of temp.

2. Step 2: Check doubly linked list pointer updates

   For doubly linked list, newNode.prev must point back to temp to maintain backward link.

3. Final Answer:

   Missing setting newNode.prev = temp -> Option A

4. Quick Check:

   Set newNode.prev to temp for backward link [OK]

Hint: Always set newNode.prev when adding at end [OK]

Common Mistakes:

• Forgetting to set newNode.prev
• Reassigning head incorrectly
• Skipping loop to find last node

5. You want to create a doubly linked list from an array of integers {1, 2, 3, 4} such that the list is 1 -> 2 -> 3 -> 4 (head points to 1), and then reverse print the list (4 -> 3 -> 2 -> 1 -> null) using backward traversal. Which approach correctly initializes the list and prints it backward?

int[] arr = {1, 2, 3, 4};
DoublyLinkedList list = new DoublyLinkedList();
// Step 1: Add all elements from arr to list
// Step 2: Print list backward

// Which code snippet correctly does this?

hard

A. for (int i = arr.Length - 1; i >= 0; i--) list.AddLast(arr[i]);
Node temp = list.head;
while (temp != null) { Console.Write(temp.data + " -> "); temp = temp.next; }
Console.WriteLine("null");

B. foreach (int val in arr) list.AddLast(val);
Node temp = list.head;
while (temp.next != null) temp = temp.next;
while (temp != null) { Console.Write(temp.data + " -> "); temp = temp.prev; }
Console.WriteLine("null");

C. foreach (int val in arr) list.AddFirst(val);
Node temp = list.head;
while (temp != null) { Console.Write(temp.data + " -> "); temp = temp.next; }
Console.WriteLine("null");

D. for (int i = 0; i < arr.Length; i++) list.AddLast(arr[i]);
Node temp = list.head;
while (temp != null) { Console.Write(temp.data + " -> "); temp = temp.next; }
Console.WriteLine("null");

Solution

1. Step 1: Add elements in order using AddLast

   Use foreach (int val in arr) list.AddLast(val); to build the list as 1 -> 2 -> 3 -> 4, preserving array order.

2. Step 2: Traverse to last node and print backward

   Node temp = list.head; while (temp.next != null) temp = temp.next; then while (temp != null) { Console.Write(temp.data + " -> "); temp = temp.prev; } Console.WriteLine("null"); to print 4 -> 3 -> 2 -> 1 -> null.

3. Final Answer:

   foreach (int val in arr) list.AddLast(val); Node temp = list.head; while (temp.next != null) temp = temp.next; while (temp != null) { Console.Write(temp.data + " -> "); temp = temp.prev; } Console.WriteLine("null"); -> Option B

4. Quick Check:

   Build forward list + backward traversal from tail [OK]

Hint: Add in order, then move to tail to print backward [OK]

Common Mistakes:

• Adding elements in reverse order
• Printing forward instead of backward
• Using AddFirst which reverses order