Leetcode169: Majority Element

Leetcode169：Majority Element

Given an array of size n, find the majority element. The majority element is the element that appears more than ⌊n/2⌋ times.
You may assume that the array is non-empty and the majority element always exist in the array.
题意：
寻找一个规模为n的数组里面的众数。
解答①：
利用分治算法的原理来解这一道题。可以这样分析，将原来的数组平均分成两部分，寻找前一部分的众数a，寻找后一部分的众数b，因为众数要出现n/2次，所以要求的数组的众数肯定是a和b其中之一。如果a=b的话，那么众数就是a，不然的话，只需要遍历一下原先数组，数出a和b各出现了多少次，出现次数多的那个就是众数啦。当然，要是数组规模只有1的话，那个唯一的元素就是众数。
代码： [cpp]   view plain

1. class Solution {  
2. public:  
3.     int majorityElement(vector<int>& nums) {  
4.         vector<int> va,vb;  
5.         int len=nums.size();  
6.         if(len==1) return nums[0]; //规模为1，唯一的元素就是众数  
7.         //把数组分成两部分  
8.         for(int i=0;i<len/2;i++) va.push_back(nums[i]);  
9.         for(int i=len/2;i<len;i++) vb.push_back(nums[i]);  
10.         //寻找前后部分各自的众数  
11.         int a=majorityElement(va);  
12.         int b=majorityElement(vb);  
13.         //a=b说明找到了众数  
14.         if(a==b) return a;  
15.         else{  
16.             int numa=0,numb=0;  
17.             //数出a,b出现的次数  
18.             for(int i=0;i<len;i++){  
19.                 if(nums[i]==a) numa++;  
20.                 if(nums[i]==b) numb++;  
21.             }  
22.             if(numa>numb) return a;  
23.             return b;  
24.         }  
25.     }  
26. };  

复杂度：

T(n)=2T(n/2)+2n，2T(n/2)是寻找前后两个部分所需要的时间复杂度，2n的话是将数组分成两个部分以及a!=b的时候计算出现次数遍历数组所需要的时间复杂度~ 根据主项定理，可以知道上式的时间复杂度是 O(nlogn)。

解答②：
对于这一题，新学了一种算法，叫做：Moore's voting algorithm。
利用这个算法，可以求出一个数组中超过半数以上的元素。遍历数组，每次出现一对不一样的元素，就将其从数组中删除掉，直到数组遍历完毕，剩下的元素就是要找的超过半数的元素。
这个是我参考的算法的网页：http://www.cs.utexas.edu/~moore/best-ideas/mjrty/example.html，依据这个网页上对于算法实现的解释，很容易就可以写出这道题目的代码。
代码： [cpp]   view plain

1. class Solution {  
2. public:  
3.     int majorityElement(vector<int>& nums) {  
4.         int e=nums[0];  
5.         int count=1;  
6.         int len=nums.size();  
7.         for(int i=1;i<len;i++){  
8.             if(count==0){  
9.                 e=nums[i];  
10.                 count=1;  
11.             }  
12.             else{  
13.                 if(e==nums[i]) count++;  
14.                 else count--;  
15.             }  
16.         }  
17.         return e;  
18.     }  
19. };  

复杂度：

该算法只是遍历了一遍数组，也没有真正地删除元素，所以时间复杂度为O(n)。