The Votul Boyer-Moore algoritmul este unul dintre algoritmii optimi populari care este folosit pentru a găsi elementul majoritar dintre elementele date care au mai mult de N/2 apariții. Acest lucru funcționează perfect pentru găsirea elementului majoritar care are 2 traversări peste elementele date, care funcționează în complexitatea timpului O(N) și complexitatea spațiului O(1).

Să vedem algoritmul și intuiția din spatele funcționării sale, luând un exemplu -

 Input : {1,1,1,1,2,3,5} Output : 1 Explanation : 1 occurs more than 3 times. Input : {1,2,3} Output : -1>

Acest algoritm funcționează pe baza faptului că, dacă un element apare de mai mult de N/2 ori, înseamnă că elementele rămase, altele decât aceasta, ar fi cu siguranță mai mici de N/2. Deci, haideți să verificăm derularea algoritmului.

• Mai întâi, alegeți un candidat din setul dat de elemente dacă este același cu elementul candidat, măriți voturile. În caz contrar, reduceți voturile dacă voturile devin 0, selectați un alt element nou ca nou candidat.

Intuiția din spatele muncii:
Când elementele sunt aceleași cu elementul candidat, voturile sunt incrementate, în timp ce atunci când se găsește un alt element (care nu este egal cu elementul candidat), am scăzut numărul. Acest lucru înseamnă de fapt că scădem prioritatea capacității de câștig a candidatului selectat, deoarece știm că, dacă candidatul este majoritar, apare de mai mult de N/2 ori, iar elementele rămase sunt mai mici de N/2. Continuăm să scădem voturile, deoarece am găsit un(e) element(e) diferit(e) decât elementul candidat. Când voturile devin 0, aceasta înseamnă de fapt că există un număr egal de voturi pentru diferite elemente, ceea ce nu ar trebui să fie cazul pentru ca elementul să fie elementul majoritar. Deci elementul candidat nu poate fi majoritar și, prin urmare, alegem elementul prezent drept candidat și continuăm la fel până când toate elementele sunt terminate. Candidatul final ar fi elementul nostru majoritar. Verificăm folosind a doua traversare pentru a vedea dacă numărul său este mai mare decât N/2. Dacă este adevărat, îl considerăm elementul majoritar.

Pași pentru implementarea algoritmului:
Pasul 1 - Găsiți un candidat cu majoritatea -

Câte orașe din Statele Unite ale Americii

• Inițializați o variabilă spune i ,voturi = 0, candidat =-1
• Traversați prin matrice folosind bucla for
• Dacă voturi = 0, alege candidat = arr[i] , face voturi=1 .
• altfel, dacă elementul curent este același cu voturile de increment al candidatului
• altfel decrementează voturile.

Pasul 2 - Verificați dacă candidatul are mai mult de N/2 voturi –

• Inițializați un număr de variabile =0 și creșteți numărul dacă este același cu candidatul.
• Dacă numărul este> N/2, returnați candidatul.
• altfel returnează -1.

 Dry run for the above example:  Given : arr[]= 1 1 1 1 2 3 5 votes =0 1 2 3 4 3 2 1 candidate = -1 1 1 1 1 1 1 1 candidate = 1 after first traversal 1 1 1 1 2 3 5 count =0 1 2 3 4 4 4 4 candidate = 1 Hence count>7/2 =3 Deci 1 este elementul majoritar.>

C++

>

>

Java

> 
    
   
 
     
  
 
    
 
     
     
    
 
Android poate juca gamepigeon
 
 
 
 
 # Python implementation for the above approach> # Function to find majority element> def> findMajority(arr, n):> >candidate>=> ->1> >votes>=> 0> > ># Finding majority candidate> >for> i>in> range> (n):> >if> (votes>=>=> 0>):> >candidate>=> arr[i]> >votes>=> 1> >else>:> >if> (arr[i]>=>=> candidate):> >votes>+>=> 1> >else>:> >votes>->=> 1> >count>=> 0> > ># Checking if majority candidate occurs more than n/2> ># times> >for> i>in> range> (n):> >if> (arr[i]>=>=> candidate):> >count>+>=> 1> > >if> (count>n>>>/> 2>):> >return> candidate> >else>:> >return> ->1> # Driver Code> arr>=> [>1>,>1>,>1>,>1>,>2>,>3>,>4> ]> n>=> len>(arr)> majority>=> findMajority(arr, n)> print>(>' The majority element is :'> ,majority)> > # This code is contributed by shivanisinghss2110> 
 
 
 
 
    
 
>
 
    
 
>
 
 
C#
    
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 using> System;> class> GFG> {> >// Function to find majority element> >public> static> int> findMajority(>int>[] nums)> >{> >int> count = 0, candidate = -1;> >// Finding majority candidate> >for> (>int> index = 0; index   if (count == 0) {  candidate = nums[index];  count = 1;  }  else {  if (nums[index] == candidate)  count++;  else  count--;  }  }  // Checking if majority candidate occurs more than  // n/2 times  count = 0;  for (int index = 0; index   if (nums[index] == candidate)  count++;  }  if (count>(nums.Length / 2)) returnează candidat;  întoarcere -1;  // Ultima buclă for și pasul instrucțiunii if pot // fi omis dacă un element majoritar este confirmat pentru // să fie prezent într-o matrice, doar returnează candidat // în acest caz } // Cod driver public static void Main(String[ ] args) { int []arr = { 1, 1, 1, 1, 2, 3, 4};  int majoritate = findMajority(arr);  Console.Write(' Elementul majoritar este : ' + majoritate);  } } // Acest cod este contribuit de shivanisinghss2110>>>
 
 
 
 
    
 
> 
    
   
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 > // Function to find majority element> function> findMajority(nums)> >{> >var> count = 0, candidate = -1;> >// Finding majority candidate> >for> (>var> index = 0; index   if (count == 0) {  candidate = nums[index];  count = 1;  }  else {  if (nums[index] == candidate)  count++;  else  count--;  }  }  // Checking if majority candidate occurs more than  // n/2 times  count = 0;  for (var index = 0; index   if (nums[index] == candidate)  count++;  }  if (count>(nums.length / 2)) returnează candidat;  întoarcere -1;  // Ultima buclă for și pasul instrucțiunii if pot // fi omis dacă un element majoritar este confirmat pentru // să fie prezent într-o matrice, doar returnează candidat // în acest caz } // Cod driver var arr = [ 1, 1 , 1, 1, 2, 3, 4 ];  var majoritate = findMajority(arr);  document.write(' Elementul majoritar este : ' + majoritate);   // Acest cod este contribuit de shivanisinghss2110.>>>
 
 
 
 
    
 
> 
    
  The majority element is : 1>
 
  Complexitatea timpului: O(n) (Pentru două treceri peste matrice) 
  Complexitatea spațiului: O(1)