Majority element in a linked list

Given a linked list, find majority element. An element is called Majority element if it appears more than or equal to n/2 times where n is total number of nodes in the linked list.

Examples:

Input  : 1->2->3->4->5->1->1->1->NULL
Output : 1
Explanation  1 occurs 4 times 
Input :10->23->11->9->54->NULL
Output :NO majority element

Method 1(simple)
Run two loops starting from head and count frequency of each element iteratively. Print the element whose frequency is greater than or equal to n/2. In this approach time complexity will be O(n*n) where n is the number of nodes in the linked list.



C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to find majority element in 
// a linked list
#include <bits/stdc++.h>
using namespace std;
  
/* Link list node */
struct Node {
    int data;
    struct Node* next;
};
  
/* Function to get the nth node from the 
last of a linked list*/
int majority(struct Node* head)
{
    struct Node* p = head;
      
    int total_count = 0, max_count = 0, res = -1;
    while (p != NULL) {
  
        // Count all occurrences of p->data
        int count = 1;
        struct Node* q = p->next;
        while (q != NULL) {
            if (p->data == q->data)             
               count++;              
            q = q->next;
        }
  
        // Update max_count and res if count
        // is more than max_count
        if (count > max_count)
        {
            max_count = count;
            res = p->data;
        }
  
        p = p->next;
        total_count++;
    }
  
    if (max_count >= total_count/2)
        return res;
  
    // if we reach here it means no
    // majority element is present.
    // and we assume that all the
    // element are positive
    return -1;
}
  
void push(struct Node** head_ref, int new_data)
{
    struct Node* new_node =
       (struct Node*)malloc(sizeof(struct Node));
    new_node->data = new_data;
    new_node->next = (*head_ref);
    (*head_ref) = new_node;
}
  
/* Driver program to test above function*/
int main()
{
    /* Start with the empty list */
    struct Node* head = NULL;
  
    // create linked
    push(&head, 1);
    push(&head, 1);
    push(&head, 1);
    push(&head, 5);
    push(&head, 4);
    push(&head, 3);
    push(&head, 2);
    push(&head, 1);
  
    int res = majority(head);
  
    if (res != (-1))
        cout << "Majority element is " << res;
    else
        cout << "No majority element";
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to find majority element in 
// a linked list
import java.util.*;
  
class GFG
{
static Node head;
  
/* Link list node */
static class Node 
{
    int data;
    Node next;
};
  
/* Function to get the nth node from 
the last of a linked list*/
static int majority(Node head)
{
    Node p = head;
      
    int total_count = 0
        max_count = 0, res = -1;
    while (p != null
    {
  
        // Count all occurrences of p->data
        int count = 1;
        Node q = p.next;
        while (q != null)
        {
            if (p.data == q.data)             
                count++;             
            q = q.next;
        }
  
        // Update max_count and res if count
        // is more than max_count
        if (count > max_count)
        {
            max_count = count;
            res = p.data;
        }
  
        p = p.next;
        total_count++;
    }
  
    if (max_count >= total_count / 2)
        return res;
  
    // if we reach here it means no
    // majority element is present.
    // and we assume that all the
    // element are positive
    return -1;
}
  
static void push(Node head_ref,     
                 int new_data)
{
    Node new_node = new Node();
    new_node.data = new_data;
    new_node.next = head_ref;
    head_ref = new_node;
    head = head_ref;
}
  
// Driver Code
public static void main(String[] args) 
  
{
  
    /* Start with the empty list */
    head = null;
  
    // create linked
    push(head, 1);
    push(head, 1);
    push(head, 1);
    push(head, 5);
    push(head, 4);
    push(head, 3);
    push(head, 2);
    push(head, 1);
  
    int res = majority(head);
  
    if (res != (-1))
        System.out.println("Majority element is " + res);
    else
        System.out.println("No majority element");
    }
}
  
// This code is contributed by Princi Singh

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to find majority element in 
// a linked list
using System;
      
class GFG
{
    static Node head;
      
    /* Link list node */
    public class Node 
    {
        public int data;
        public Node next;
    };
      
    /* Function to get the nth node from 
    the last of a linked list*/
    static int majority(Node head)
    {
        Node p = head;
          
        int total_count = 0, 
            max_count = 0, res = -1;
        while (p != null
        {
      
            // Count all occurrences of p->data
            int count = 1;
            Node q = p.next;
            while (q != null)
            {
                if (p.data == q.data)             
                    count++;             
                q = q.next;
            }
      
            // Update max_count and res if count
            // is more than max_count
            if (count > max_count)
            {
                max_count = count;
                res = p.data;
            }
      
            p = p.next;
            total_count++;
        }
      
        if (max_count >= total_count / 2)
            return res;
      
        // if we reach here it means no
        // majority element is present.
        // and we assume that all the
        // element are positive
        return -1;
    }
      
    static void push(Node head_ref,     
                     int new_data)
    {
        Node new_node = new Node();
        new_node.data = new_data;
        new_node.next = head_ref;
        head_ref = new_node;
        head = head_ref;
    }
  
// Driver Code
public static void Main(String[] args) 
{
  
    /* Start with the empty list */
    head = null;
  
    // create linked
    push(head, 1);
    push(head, 1);
    push(head, 1);
    push(head, 5);
    push(head, 4);
    push(head, 3);
    push(head, 2);
    push(head, 1);
  
    int res = majority(head);
  
    if (res != (-1))
        Console.WriteLine("Majority element is " + res);
    else
        Console.WriteLine("No majority element");
    }
}
  
// This code is contributed by PrinciRaj1992 

chevron_right



Time Complexity O(n*n)

Method 2 Use hashing technique. We count frequency of each element and then we print the element whose frequency is ≥ n/2;

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to find majority element
// in the linked list using hashing
#include <bits/stdc++.h>
using namespace std;
  
/* Link list node */
struct Node {
    int data;
    struct Node* next;
};
  
/* Function to get the nth node from the last
 of a linked list*/
int majority(struct Node* head)
{
    struct Node* p = head;
  
    // Storing elements and their frequencies
    // in a hash table.
    unordered_map<int, int> hash; 
      
    int total_count = 0;
    while (p != NULL) {
  
        // increase every element
        // frequency by 1
        hash[p->data]++;
  
        p = p->next;
  
        total_count++;
    }
  
    // Check if frequency of any element
    // is more than or equal to total_count/2
    for (auto x : hash)
       if (x.second >= total_count/2)
           return x.first;
  
    // If we reach here means no majority element
    // is present. We assume that all the element 
    // are positive
    return -1;
}
  
void push(struct Node** head_ref, int new_data)
{
    struct Node* new_node = 
       (struct Node*)malloc(sizeof(struct Node));
    new_node->data = new_data;
    new_node->next = (*head_ref);
    (*head_ref) = new_node;
}
  
// Driver program to test above function
int main()
{
  
    /* Start with the empty list */
    struct Node* head = NULL;
    push(&head, 1);
    push(&head, 1);
    push(&head, 1);
    push(&head, 5);
    push(&head, 4);
    push(&head, 3);
    push(&head, 2);
    push(&head, 1);
  
    int res = majority(head);
  
    if (res != (-1))
        cout << "majority element is " << res;
    else
        cout << "NO majority elemenet";
    return 0;
}

chevron_right



Time Complexity O(n)

majority element is 1


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.





Article Tags :
Practice Tags :


Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.