Create and Initialize Doubly Linked List in DSA C# - Build from Scratch

Create and Initialize Doubly Linked List

📖 Scenario: You are building a simple program to manage a playlist of songs. Each song can link to the previous and next song, so you can move forward or backward through the list.

🎯 Goal: Create a doubly linked list with three songs: "Song A", "Song B", and "Song C". Initialize the list so each song points to the next and previous songs correctly.

📋 What You'll Learn

Create a Node class with string Data, Node Next, and Node Prev properties.

Create three nodes with data "Song A", "Song B", and "Song C".

Link the nodes so that Song A points to Song B as next, Song B points back to Song A as previous, and so on.

Create a head variable pointing to the first node.

Print the list forward from head showing all song names separated by arrows.

💡 Why This Matters

🌍 Real World

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

💼 Career

Understanding linked lists is fundamental for software developers working with data structures, memory management, and building efficient navigation systems.

1

Create Node class and three nodes

Create a class called Node with public properties string Data, Node Next, and Node Prev. Then create three Node objects named node1, node2, and node3 with data "Song A", "Song B", and "Song C" respectively.

DSA C#

// Define Node class
// Create node1, node2, node3 with data "Song A", "Song B", "Song C"

Hint

Define the Node class with a constructor that sets the Data. Then create three nodes with the given song names.

2

Link nodes to form doubly linked list

Link the nodes so that node1.Next is node2, node2.Prev is node1, node2.Next is node3, and node3.Prev is node2. Then create a variable head and set it to node1.

DSA C#

public class Node
{
    public string Data;
    public Node Next;
    public Node Prev;

    public Node(string data)
    {
        Data = data;
        Next = null;
        Prev = null;
    }
}

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

// Link nodes and set head

Hint

Set the Next and Prev properties to link the nodes forward and backward. Then assign head to the first node.

3

Traverse and collect song names forward

Create a Node variable called current and set it to head. Create a string variable called result and set it to empty string. Use a while loop to traverse the list forward until current is null. Inside the loop, add current.Data to result. If current.Next is not null, add " -> " after the data. Then move current to current.Next.

DSA C#

public class Node
{
    public string Data;
    public Node Next;
    public Node Prev;

    public Node(string data)
    {
        Data = data;
        Next = null;
        Prev = null;
    }
}

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

node1.Next = node2;
node2.Prev = node1;
node2.Next = node3;
node3.Prev = node2;

Node head = node1;

// Traverse list forward and build result string

Hint

Use a while loop to move through the list from head. Add each song's data to result with arrows between.

4

Print the doubly linked list forward

Write a Console.WriteLine statement to print the result string.

DSA C#

public class Node
{
    public string Data;
    public Node Next;
    public Node Prev;

    public Node(string data)
    {
        Data = data;
        Next = null;
        Prev = null;
    }
}

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

node1.Next = node2;
node2.Prev = node1;
node2.Next = node3;
node3.Prev = node2;

Node head = node1;

Node current = head;
string result = "";
while (current != null)
{
    result += current.Data;
    if (current.Next != null)
    {
        result += " -> ";
    }
    current = current.Next;
}

// Print the result string

Hint

Use Console.WriteLine(result); to display the linked list forward.

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