在排序链表中查找中位数

给定一个排序的链表$N$元素。任务是在给定的有序链表中找到中位数。
我们知道排序数组中的中位数是中间元素。

查找 N 个排序数字的中位数的过程：

if N is odd:
    median is N/2th element
else
    median is N/2th element + (N/2+1)th element

例子：

Input : 1->2->3->4->5->NULL
Output : 3

Input : 1->2->3->4->5->6->NULL
Output : 3.5

简单的方法

1. 遍历链表并统计所有元素。
2. 如果计数为奇数，则再次遍历链表并找到第 n/2 个元素。
3. 如果 count 是偶数，则再次遍历链表并找到：
   (n/2th element+ (n/2+1)th element)/2

注意：上述解决方案遍历链表两次。

高效的方法：一种有效的方法是使用两个指针遍历列表以查找元素的数量。请参阅本文的方法 2。
我们可以使用上面的算法来寻找链表的中值。使用这个算法，我们不需要计算元素的数量：

1. 如果fast_ptr不是 NULL 则意味着链表包含奇数元素，我们只需打印slow_ptr的数据。
2. 否则，如果fast_ptr达到 NULL，则意味着链表包含偶数元素，我们创建了slow_ptr前一个节点的备份并打印（slow_ptr 的前一个节点+slow_ptr->data）/2

下面是上述方法的实现：

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

 
// Javascript program to find median
// of a linked list
 
// A linked list node
class 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 list
var 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 jana_sayantan.

输出：

Median is : 3.5

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。