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 list of tasks. Each task has a number and you want to store them in a doubly linked list so you can move forward and backward easily.

🎯 Goal: Create a doubly linked list with three nodes containing the values 10, 20, and 30. Initialize the list so that each node points correctly to the previous and next nodes.

📋 What You'll Learn

Define a struct called Node with an integer data and two pointers: prev and next

Create three nodes dynamically with values 10, 20, and 30

Link the nodes so that prev and next pointers are set correctly

Create a pointer called head that points to the first node

💡 Why This Matters

🌍 Real World

Doubly linked lists are used in real-world applications like browser history navigation, music playlists, and undo-redo features where moving forward and backward is needed.

💼 Career

Understanding doubly linked lists is important for software developers working on systems that require efficient bidirectional data traversal and dynamic data management.

1

Define the Node structure and create three nodes

Define a struct called Node with an integer data and two pointers prev and next. Then create three nodes called node1, node2, and node3 using malloc. Assign the values 10, 20, and 30 to node1->data, node2->data, and node3->data respectively.

DSA C

#include 
#include 

int main() {

    // Define struct Node and create three nodes with values 10, 20, 30
    // Your code here

    return 0;
}

Hint

Start by defining the Node struct with data, prev, and next. Then use malloc to create three nodes and assign their data values.

2

Create a head pointer and initialize it

Create a pointer called head of type Node* and set it to point to node1.

DSA C

#include 
#include 

typedef struct Node {
    int data;
    struct Node* prev;
    struct Node* next;
} Node;

int main() {
    Node* node1 = (Node*)malloc(sizeof(Node));
    Node* node2 = (Node*)malloc(sizeof(Node));
    Node* node3 = (Node*)malloc(sizeof(Node));

    node1->data = 10;
    node2->data = 20;
    node3->data = 30;

    // Create head pointer and set it to node1
    // Your code here

    return 0;
}

Hint

Declare head as a pointer to Node and assign it to node1.

3

Link the nodes with prev and next pointers

Set node1->prev to NULL, node1->next to node2. Set node2->prev to node1, node2->next to node3. Set node3->prev to node2, and node3->next to NULL.

DSA C

#include 
#include 

typedef struct Node {
    int data;
    struct Node* prev;
    struct Node* next;
} Node;

int main() {
    Node* node1 = (Node*)malloc(sizeof(Node));
    Node* node2 = (Node*)malloc(sizeof(Node));
    Node* node3 = (Node*)malloc(sizeof(Node));

    node1->data = 10;
    node2->data = 20;
    node3->data = 30;

    Node* head = node1;

    // Link nodes with prev and next pointers
    // Your code here

    return 0;
}

Hint

Remember the first node's prev is NULL and the last node's next is NULL. Link the middle node's pointers to the nodes before and after it.

4

Print the doubly linked list forward

Use a Node* pointer called current to traverse the list from head. Print each node's data followed by ->. After the last node, print NULL.

DSA C

#include 
#include 

typedef struct Node {
    int data;
    struct Node* prev;
    struct Node* next;
} Node;

int main() {
    Node* node1 = (Node*)malloc(sizeof(Node));
    Node* node2 = (Node*)malloc(sizeof(Node));
    Node* node3 = (Node*)malloc(sizeof(Node));

    node1->data = 10;
    node2->data = 20;
    node3->data = 30;

    Node* head = node1;

    node1->prev = NULL;
    node1->next = node2;

    node2->prev = node1;
    node2->next = node3;

    node3->prev = node2;
    node3->next = NULL;

    // Traverse and print the list forward
    // Your code here

    return 0;
}

Hint

Use a while loop to move current from head to the end, printing each data value followed by ->. After the loop, print NULL.

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 in one direction

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 singly linked list
• Thinking it sorts data automatically
• Assuming it uses arrays internally

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

easy

A. struct Node { int data; struct Node* next; };

B. struct Node { int data; struct Node* prev; struct Node* next; };

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

D. struct Node { int data; struct Node next; struct Node prev; };

Solution

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

   Each node must have data, a pointer to next node, and a pointer to previous node.

2. Step 2: Identify correct syntax

   struct Node { int data; struct Node* prev; struct Node* next; }; correctly declares pointers to next and prev nodes using struct Node*.

3. Final Answer:

   struct Node { int data; struct Node* prev; struct Node* next; }; -> Option B

4. Quick Check:

   Node has data + prev pointer + next pointer [OK]

Hint: Pointers to prev and next must be struct Node* [OK]

Common Mistakes:

• Using int instead of pointer for next/prev
• Missing prev pointer in node
• Declaring next/prev as struct Node instead of pointer

3. What will be the output of the following C code snippet that creates a doubly linked list with two nodes and prints their data?

typedef struct Node {
  int data;
  struct Node* prev;
  struct Node* next;
} Node;

int main() {
  Node* head = (Node*)malloc(sizeof(Node));
  Node* second = (Node*)malloc(sizeof(Node));

  head->data = 10;
  head->prev = NULL;
  head->next = second;

  second->data = 20;
  second->prev = head;
  second->next = NULL;

  printf("%d -> %d -> NULL", head->data, second->data);
  return 0;
}

medium

A. Compilation error

B. 20 -> 10 -> NULL

C. 10 -> 20 -> NULL

D. 10 -> NULL

Solution

1. Step 1: Analyze node creation and linking

   Two nodes are created: head with data 10, second with data 20. head->next points to second, second->prev points to head.

2. Step 2: Understand print statement

   Prints head->data (10), then second->data (20), then "-> NULL".

3. Final Answer:

   10 -> 20 -> NULL -> Option C

4. Quick Check:

   Prints data in order: 10 then 20 [OK]

Hint: Follow pointers to print nodes in order [OK]

Common Mistakes:

• Confusing order of nodes
• Forgetting to set next or prev pointers
• Assuming print shows backward traversal

4. Identify the error in the following code snippet that attempts to initialize a doubly linked list node:

struct Node {
  int data;
  struct Node* prev;
  struct Node* next;
};

int main() {
  struct Node* node = malloc(sizeof(struct Node));
  node->data = 5;
  node->prev = NULL;
  node->next = NULL;
  free(node);
  printf("%d", node->data);
  return 0;
}

medium

A. Accessing freed memory after free(node)

B. Missing #include

C. Incorrect struct declaration

D. No error, code runs fine

Solution

1. Step 1: Review memory allocation and freeing

   Memory is allocated for node, initialized, then freed with free(node).

2. Step 2: Identify invalid access

   After freeing, code tries to print node->data, which accesses freed memory causing undefined behavior.

3. Final Answer:

   Accessing freed memory after free(node) -> Option A

4. Quick Check:

   Using pointer after free = error [OK]

Hint: Never use pointer after free() [OK]

Common Mistakes:

• Ignoring use-after-free errors
• Forgetting to include stdlib.h (but not main error here)
• Assuming free deletes pointer variable

5. You want to create a doubly linked list with nodes containing values 1, 2, and 3 in that order. Which code snippet correctly initializes this list with proper prev and next pointers?

hard

A. Node* n1 = malloc(sizeof(Node)); n1->data=1; n1->prev=NULL; n1->next=NULL;
Node* n2 = malloc(sizeof(Node)); n2->data=2; n2->prev=NULL; n2->next=NULL;
n1->next=n2;
Node* n3 = malloc(sizeof(Node)); n3->data=3; n3->prev=NULL; n3->next=NULL;
n2->next=n3;

B. Node* n1 = malloc(sizeof(Node)); n1->data=1; n1->prev=NULL; n1->next=NULL;
Node* n2 = malloc(sizeof(Node)); n2->data=2; n2->prev=n1; n2->next=NULL;
n1->next=n2;
Node* n3 = malloc(sizeof(Node)); n3->data=3; n3->prev=n2; n3->next=n1;
n2->next=n3;

C. Node* n1 = malloc(sizeof(Node)); n1->data=1; n1->prev=NULL; n1->next=NULL;
Node* n2 = malloc(sizeof(Node)); n2->data=2; n2->prev=n1; n2->next=NULL;
n1->next=n2;
Node* n3 = malloc(sizeof(Node)); n3->data=3; n3->prev=NULL; n3->next=NULL;
n2->next=n3;

D. Node* n1 = malloc(sizeof(Node)); n1->data=1; n1->prev=NULL; n1->next=NULL;
Node* n2 = malloc(sizeof(Node)); n2->data=2; n2->prev=n1; n2->next=NULL;
n1->next=n2;
Node* n3 = malloc(sizeof(Node)); n3->data=3; n3->prev=n2; n3->next=NULL;
n2->next=n3;

Solution

1. Step 1: Check initialization of first node

   n1 has data=1, prev=NULL, next=NULL initially.

2. Step 2: Link second node correctly

   n2 has data=2, prev=n1, next=NULL; n1->next points to n2.

3. Step 3: Link third node correctly

   n3 has data=3, prev=n2, next=NULL; n2->next points to n3.

4. Final Answer:

   Code snippet B correctly sets prev and next pointers for all nodes -> Option D

5. Quick Check:

   Each node's prev and next link neighbors properly [OK]

Hint: Prev of first is NULL; next of last is NULL [OK]

Common Mistakes:

• Not setting prev pointers for nodes after first
• Setting next pointers incorrectly
• Making circular links unintentionally