How to Create a Doubly Linked List in C?

Last Updated : 02 Sep, 2024

A doubly linked list is a type of linked list in which each node contains a pointer to both the next node and the previous node. This allows traversal in both forward and backward directions. Each node in a doubly linked list stores data, a pointer to the next node, and a pointer to the previous node.

In this article, we will learn how to create/implement a doubly linked list in C.

Example

Input: Create Doubly Linked List with 1 2 3 4
Output: head = [1] <-> [2] <-> [3] <-> [4] <-> NULL
Explanation: The doubly linked list is created with nodes containing values 1, 2, 3, and 4.
Input: Create Doubly Linked List with 10 20 30
Output: head = [10] <-> [20] <-> [30] <-> NULL
Explanation: The doubly linked list is created with nodes containing values 10, 20, and 30.

Create a Doubly Linked List in C

In C, we can represent a doubly linked list node using the struct type, which allows grouping multiple data types in a single variable. Each node in a doubly linked list should have pointers to both the next node and the previous node along with the data field. We can then use a pointer to the head node to manage the entire list.

Representation of Doubly Linked List Node in C

Below is an example structure that represents a doubly linked list node:

struct Node {        // Data field     int data;      // Pointer to the next node     struct Node* next;      // Pointer to the previous node     struct Node* prev; };

Creating a Node of Doubly Linked List

We can create a doubly linked list node using dynamic memory allocation and structure pointers. Dynamic allocation is preferred to utilize the full flexibility of the doubly linked list.

struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));

Shortening the Node Declaration

If you prefer to avoid repeatedly writing struct Node*, you can use typedef to define an alias:

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

Then we can create the node as:

Node* node2 = (Node*)malloc(sizeof(Node));

Chaining/Linking the Nodes of the Doubly Linked List

After creating nodes, link them by setting the next and prev pointers accordingly. The prev pointer of each node should point to its previous node, and the next pointer should point to the next node in the list. The first node's prev pointer and the last node's next pointer should be set to NULL.

// Assigning data node1->data = valid_value;  // Assigning next and prev pointers node1->next = node2; node1->prev = NULL;  // Same for node 2 node2->data = valid_value; node2->next = node3; node2->prev = node1;  // Same for node 3 node3->data = valid_value; node3->next = NULL; node3->prev = node2;

We can also use a utility function like createNode() that creates and initialize the node members to either provided or default values. This will ease the process of creating and even linking node.

C Program to Create a Doubly Linked List

The following example implements the approach to create a doubly linked list in C:

// C Program to create a Doubly Linked List #include <stdio.h> #include <stdlib.h>  // Define the structure of Node typedef struct Node {      // Data field     int data;      // Pointer to the next node     struct Node *next;      // Pointer to the previous node     struct Node *prev; } Node;  Node *createNode(int data) {     Node *newNode = (Node *)malloc(sizeof(Node));     newNode->data = data;      // Initially assigning the next and prev pointers to NULL     newNode->next = NULL;     newNode->prev = NULL;      return newNode; }  int main() {      // Create and initialize nodes     Node *head = createNode(10);     Node *second = createNode(20);     Node *third = createNode(30);      // Linking the nodes     head->next = second; // This will create: 10 <-> 20     second->prev = head;     second->next = third; // This will create: 10 <-> 20 <-> 30     third->prev = second;      printf("Doubly Linked List: ");     Node *temp = head;     while (temp)     {         printf("%d ", temp->data);         temp = temp->next;     }      return 0; }

Output

Doubly Linked List: 10 20 30

Time Complexity: O(N) where N is the total number of nodes in the linked list.
Auxiliary Space: O(N)

Conclusion

In this article, we have discussed how to create a doubly linked list in C. We have covered the representation of the doubly linked list node, the process of creating nodes, linking them, and traversing the list. Doubly linked lists provide the flexibility to traverse in both directions, which can be particularly useful in various applications.

Feel free to modify the code according to your specific needs or requirements!

Introduction to Doubly Linked Lists in Java

rveerendra400

Improve

Article Tags :