Finding Median in a Sorted Linked List

01 Jul, 2022
Given A sorted linked list of elements. The task is to find the median in the given Sorted Linked List.We know that median in a sorted array is the middle element.
Procedure to find median of N sorted numbers:  
if N is odd:
    median is N/2th element
else
    median is N/2th element + (N/2+1)th element
Examples: 
Input : 1->2->3->4->5->NULL
Output : 3

Input : 1->2->3->4->5->6->NULL
Output : 3.5
Simple approach  
Traverse the linked list and count all elements.if count is odd then again traverse the linked list and find n/2th element.if count is even then again traverse the linked list and find: (n/2th element+ (n/2+1)th element)/2
Traverse the linked list and count all elements.
if count is odd then again traverse the linked list and find n/2th element.
if count is even then again traverse the linked list and find: (n/2th element+ (n/2+1)th element)/2
Note: The above solution traverse the linked list two times.
Efficient Approach: an efficient approach is to traverse the list using two pointers to find the number of elements. See method 2 of this post.We can use the above algorithm for finding the median of the linked list. Using this algorithm we won’t need to count the number of element: 
if the fast_ptr is Not NULL then it means linked list contain odd element we simply print the data of the slow_ptr.else if fast_ptr reach to NULL its means linked list contain even element we create backup of the previous node of slow_ptr and print (previous node of slow_ptr+ slow_ptr->data)/2
if the fast_ptr is Not NULL then it means linked list contain odd element we simply print the data of the slow_ptr.
else if fast_ptr reach to NULL its means linked list contain even element we create backup of the previous node of slow_ptr and print (previous node of slow_ptr+ slow_ptr->data)/2
Below is the implementation of the above approach:  
C++
Java
Python3
C#
Javascript
// C++ program to find median// of a linked list#include <bits/stdc++.h>using namespace std; // Link list nodestruct Node {    int data;    struct Node* next;}; /* Function to get the median of the linked list */void printMidean(Node* head){    Node* slow_ptr = head;    Node* fast_ptr = head;    Node* pre_of_slow = head;     if (head != NULL) {        while (fast_ptr != NULL && fast_ptr->next != NULL) {             fast_ptr = fast_ptr->next->next;             // previous of slow_ptr            pre_of_slow = slow_ptr;            slow_ptr = slow_ptr->next;        }         // if the below condition is true linked list        // contain odd Node        // simply return middle element        if (fast_ptr != NULL)            cout << "Median is : " << slow_ptr->data;         // else linked list contain even element        else            cout << "Median is : "                 << float(slow_ptr->data + pre_of_slow->data) / 2;    }} /* Given a reference (pointer to    pointer) to the head of a list    and an int, push a new node on    the front of the list. */void push(struct Node** head_ref, int new_data){    // allocate node    Node* new_node = new Node;     // put in the data    new_node->data = new_data;     // link the old list    // off the new node    new_node->next = (*head_ref);     // move the head to point    // to the new node    (*head_ref) = new_node;} // Driver Codeint main(){    // Start with the    // empty list    struct Node* head = NULL;     // Use push() to construct    // below list    // 1->2->3->4->5->6    push(&head, 6);    push(&head, 5);    push(&head, 4);    push(&head, 3);    push(&head, 2);    push(&head, 1);     // Check the count    // function    printMidean(head);     return 0;}
// Java program to find median// of a linked listclass GFG{     // Link list node    static class Node    {         int data;        Node next;    };     /* Function to get the median of the linked list */    static void printMidean(Node head)    {        Node slow_ptr = head;        Node fast_ptr = head;        Node pre_of_slow = head;         if (head != null)        {            while (fast_ptr != null && fast_ptr.next != null)            {                 fast_ptr = fast_ptr.next.next;                 // previous of slow_ptr                pre_of_slow = slow_ptr;                slow_ptr = slow_ptr.next;            }             // if the below condition is true linked list            // contain odd Node            // simply return middle element            if (fast_ptr != null)            {                System.out.print("Median is : " + slow_ptr.data);            }                         // else linked list contain even element            else            {                System.out.print("Median is : "                        + (float) (slow_ptr.data + pre_of_slow.data) / 2);            }        }    }     /* Given a reference (pointer to    pointer) to the head of a list    and an int, push a new node on    the front of the list. */    static Node push(Node head_ref, int new_data)    {        // allocate node        Node new_node = new Node();         // put in the data        new_node.data = new_data;         // link the old list        // off the new node        new_node.next = head_ref;         // move the head to point        // to the new node        head_ref = new_node;        return head_ref;    }     // Driver Code    public static void main(String[] args)    {        // Start with the        // empty list        Node head = null;         // Use push() to construct        // below list        // 1.2.3.4.5.6        head = push(head, 6);        head = push(head, 5);        head = push(head, 4);        head = push(head, 3);        head = push(head, 2);        head = push(head, 1);         // Check the count        // function        printMidean(head);    }} // This code is contributed by PrinciRaj1992
# Python3 program to find median# of a linked listclass Node:         def __init__(self, value):                 self.data = value        self.next = None     class LinkedList:     def __init__(self):                 self.head = None     # Create Node and make linked list    def push(self, new_data):                 new_node = Node(new_data)        new_node.next = self.head        self.head = new_node             # Function to get the median    # of the linked list       def printMedian(self):                 slow_ptr = self.head        fast_ptr = self.head        pre_of_show = self.head        count = 0                 while (fast_ptr != None and               fast_ptr.next != None):            fast_ptr = fast_ptr.next.next                         # Previous of slow_ptr            pre_of_slow = slow_ptr            slow_ptr = slow_ptr.next        # If the below condition is true        # linked list contain odd Node        # simply return middle element           if (fast_ptr):            print("Median is :", (slow_ptr.data))                     # Else linked list contain even element        else:            print("Median is :", (slow_ptr.data +                                  pre_of_slow.data) / 2)                                   # Driver codellist = LinkedList() # Use push() to construct# below list# 1->2->3->4->5->6llist.push(6)llist.push(5)llist.push(4)llist.push(3)llist.push(2)llist.push(1) # Check the count# functionllist.printMedian() # This code is contributed by grand_master
// C# program to find median// of a linked listusing System; class GFG{     // Link list node    class Node    {         public int data;        public Node next;    };     /* Function to get the median    of the linked list */    static void printMidean(Node head)    {        Node slow_ptr = head;        Node fast_ptr = head;        Node pre_of_slow = head;         if (head != null)        {            while (fast_ptr != null &&                   fast_ptr.next != null)            {                fast_ptr = fast_ptr.next.next;                 // previous of slow_ptr                pre_of_slow = slow_ptr;                slow_ptr = slow_ptr.next;            }             // if the below condition is true linked list            // contain odd Node            // simply return middle element            if (fast_ptr != null)            {                Console.Write("Median is : " +                               slow_ptr.data);            }                         // else linked list contain even element            else            {                Console.Write("Median is : " +                       (float)(slow_ptr.data +                               pre_of_slow.data) / 2);            }        }    }     /* Given a reference (pointer to    pointer) to the head of a list    and an int, push a new node on    the front of the list. */    static Node push(Node head_ref, int new_data)    {        // allocate node        Node new_node = new Node();         // put in the data        new_node.data = new_data;         // link the old list        // off the new node        new_node.next = head_ref;         // move the head to point        // to the new node        head_ref = new_node;        return head_ref;    }     // Driver Code    public static void Main(String[] args)    {        // Start with the        // empty list        Node head = null;         // Use push() to construct        // below list        // 1->2->3->4->5->6        head = push(head, 6);        head = push(head, 5);        head = push(head, 4);        head = push(head, 3);        head = push(head, 2);        head = push(head, 1);         // Check the count        // function        printMidean(head);    }} // This code is contributed by Rajput-Ji
<script> // Javascript program to find median// of a linked list // A linked list nodeclass Node {        constructor() {                this.data = 0;                this.next = null;             }        }             /* Function to get the median of the linked list */    function printMidean( head)    {        var slow_ptr = head;        var fast_ptr = head;        var pre_of_slow = head;         if (head != null)        {            while (fast_ptr != null && fast_ptr.next != null)            {                 fast_ptr = fast_ptr.next.next;                 // previous of slow_ptr                pre_of_slow = slow_ptr;                slow_ptr = slow_ptr.next;            }             // if the below condition is true linked list            // contain odd Node            // simply return middle element            if (fast_ptr != null)            {                document.write("Median is : " + slow_ptr.data);            }                         // else linked list contain even element            else            {                document.write("Median is : "                        +  (slow_ptr.data + pre_of_slow.data) / 2);            }        }    }     /* Given a reference (pointer to    pointer) to the head of a list    and an int, push a new node on    the front of the list. */    function push( head_ref,  new_data)    {        // allocate node        var new_node = new Node();         // put in the data        new_node.data = new_data;         // link the old list        // off the new node        new_node.next = head_ref;         // move the head to point        // to the new node        head_ref = new_node;        return head_ref;    }  // Driver Code // Start with the// empty listvar head = null; // Use push() to construct// below list// 1.2.3.4.5.6head = push(head, 6);head = push(head, 5);head = push(head, 4);head = push(head, 3);head = push(head, 2);head = push(head, 1); // Check the count// functionprintMidean(head); // This code is contributed by jana_sayantan.</script>
Median is : 3.5
 
princiraj1992
Rajput-Ji
grand_master
jana_sayantan
simmytarika5
median-finding
Tortoise-Hare-Approach
Linked List
Linked List
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.