How to Find the Middle Node in a Doubly Linked List: A Comprehensive Guide

Finding the middle node in a doubly linked list can be a bit tricky, as it involves considering the data structure's unique nature. Let's explore how to determine the middle node, focusing on the differences between a doubly linked list and a singly linked list.

Understanding the Problem

The term 'middle node' may have multiple interpretations depending on the length of the list:

No middle node: An empty list or a list with a single node does not have a well-defined middle node. One middle node: A list with an odd number of nodes will have a single middle node. Two middle nodes: A list with an even number of nodes can have two middle nodes that might be considered the middle node.

Programming Solution in Plain English

A straightforward algorithm to find the middle node in a doubly linked list involves traversing from both ends simultaneously. Here's how you can do it in plain English:

Start with two pointers, A at the head and B at the tail. Move A forward one node at a time and B backward one node at a time. Stop when A and B meet, which means they have crossed each other in a circular manner or are now at the middle node(s). Return the node where A points when A ! B.

Here's a pseudo-code representation of the algorithm:

Node middleList L{   if  L  NULL  L-next  NULL   return L   Node A  L-head   Node B  L-tail   Node mid  NULL   while A ! B   {      A  A-next      if A  B break      B  B-prev   }   mid  A   return mid}

Efficiency in a Doubly Linked List

A doubly linked list has both a forward (next) and backward (prev) link, which allows for a more efficient approach to finding the middle node:

Point p1 to the head. Point p2 to the tail. Check if p1 equals p2, if yes, we've found the middle node. Move p1 forward. Check if p1 equals p2, if yes, we've found the middle node. Move p2 backward. Check if p1 equals p2, if yes, we've found the middle node. Repeat steps 4-7.

You can also swap the steps for forward and backward movement to achieve the same goal.

Comparison with Singly Linked List

In comparison to a singly linked list, finding the middle node in a doubly linked list is more efficient because:

You have two references (forward and backward). You can iterate from both ends simultaneously, avoiding complications with null or single-node lists. The algorithm is more intuitive and easier to implement.

Implementation in Code

The following code examples demonstrate how to implement the algorithm in C and Java:

C Code

struct ListNode {  int val;  struct ListNode *next;  struct ListNode *prev;};struct ListNode* findMiddleNode(struct ListNode* head) {  if (head  NULL || head->next  NULL)     return head;  struct ListNode* slow  head;  struct ListNode* fast  head;  while (fast ! NULL  fast->next ! NULL) {    slow  slow->next;    fast  fast->next->next;  }  return slow;}

Java Code

class ListNode {  int val;  ListNode next;  ListNode prev;  ListNode(int x) {    val  x;  }}class Solution {  public ListNode findMiddleNode(ListNode head) {    if (head  null ||   null)       return head;    ListNode slow  head;    ListNode fast  head;    while (fast ! null   ! null) {      slow  ;      fast  ;    }    return slow;  }}

Conclusion

Understanding and implementing the algorithm for finding the middle node in a doubly linked list is crucial for efficient data structure operations. By leveraging the dual nature of the doubly linked list, you can easily identify the middle node(s) without the need for additional space, making it a powerful technique in algorithm design.

References:

GeeksforGeeks: Find Middle of Given Linked List Programiz: Finding the Middle Node in a Doubly Linked List