169. Majority Element

题目169. 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.

采用四种方法. 排序,然后取中间的数; 利用Hash表存储每个元素的个数,然后得到大于[n/2]的; 利用Moore vote算法; 利用位操作

1,排序

  public int majorityElement(int[] nums) {
        Arrays.sort(nums);
        return nums[nums.length/2];
  }

时间复杂度O(nlogn)
空间复杂度O(1)

2,Hash表

 public int majorityElement(int[] nums) {
        HashMap times = new HashMap();
        int conditionNum = nums.length / 2;
        for(int num : nums){
            if(times.containsKey(num)){
                times.put(num,times.get(num)+1);
            }else{
                times.put(num,1);
            }
            
            if(times.get(num) > conditionNum){
                return num;
            } 
        }
        
        return 0;
    }
 时间复杂度O(n)
空间复杂度O(n)

3,使用Moore vote算法

对于Moore vote算法求解是一个很巧妙的思路
关于Moore vote详细的介绍参考Moore vote Algorithm,包含有详细的推理证明,以及步骤分析

//Moore vote
     public int majorityElement(int[] nums) {
        int elem = 0;
        int count = 0;
        for(int num : nums){
            if(count == 0){
                elem = num;
                count++;
            }else if(num == elem){
                count++;
            }else{
                count--;
            }
        }
        return elem;
     }
时间复杂度O(n)
空间复杂度O(1)

4,利用位操作

思路:定义一个32个元素的整形数组,用来存放所有元素二进制0到31位上1的个数. 然后遍历这个数组,0到31上大于[len/2]次数就是这个major elment对应的位

public int majorityElement(int[] nums) {
        int[] bits = new int[32];
        for(int num : nums){
            for(int i=0; i<32; i++){
                if((num >>i & 1) == 1){
                    bits[i]++;
                }
            }
        }
        
        int conditionNum = nums.length / 2;
        int result = 0;
        for(int i=0; i<32; i++){
            if(bits[i] > conditionNum){
                result += (1 << i);
            }
        }
        return result;
    }
时间复杂度O(n)
空间复杂度O(1)