Related Articles

# Finding Median in a Sorted Linked List

• Difficulty Level : Medium
• Last Updated : 08 Jun, 2021

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

1. Traverse the linked list and count all elements.
2. if count is odd then again traverse the linked list and find n/2th element.
3. 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:

1. if the fast_ptr is Not NULL then it means linked list contain odd element we simply print the data of the slow_ptr.
2. 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++

 `// C++ program to find median``// of a linked list``#include ``using` `namespace` `std;` `// Link list node``struct` `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 Code``int` `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

 `// Java program to find median``// of a linked list``class` `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

 `# Python3 program to find median``# of a linked list``class` `Node:``    ` `    ``def` `__init__(``self``, value):``        ` `        ``self``.data ``=` `value``        ``self``.``next` `=` `None``    ` `class` `LinkedList:` `    ``def` `__init__(``self``):``        ` `        ``self``.head ``=` `None` `    ``# Create Node and 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 code``llist ``=` `LinkedList()` `# Use push() to construct``# below list``# 1->2->3->4->5->6``llist.push(``6``)``llist.push(``5``)``llist.push(``4``)``llist.push(``3``)``llist.push(``2``)``llist.push(``1``)` `# Check the count``# function``llist.printMedian()` `# This code is contributed by grand_master`

## C#

 `// C# program to find median``// of a linked list``using` `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`

## Javascript

 ``
Output:
`Median is : 3.5`

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up