Note: The algorithm should run in linear time and in O(1) space.

Example 1:

Input: [3,2,3]
Output: [3]

Example 2:

Input: [1,1,1,3,3,2,2,2]
Output: [1,2]

Solution: Boyer–Moore Voting Algorithm

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  vector<int> majorityElement(vector<int>& nums) {
    int n1 = 0;
    int c1 = 0;
    int n2 = 1;
    int c2 = 0;
    for (int num : nums) {
      if (num == n1) {
        ++c1;
      } else if (num == n2) {
        ++c2;
      } else if (c1 == 0) {
        n1 = num;
        c1 = 1;
      } else if (c2 == 0) {
        n2 = num;
        c2 = 1;
      } else {
        --c1;
        --c2;
      }
    }
    
    c1 = c2 = 0;
    for (int num : nums) {
      if (num == n1) ++c1;
      else if (num == n2) ++c2;
    }
    
    const int c = nums.size() / 3;
    vector<int> ans;
    if (c1 > c) ans.push_back(n1);
    if (c2 > c) ans.push_back(n2);
    return ans;
  }
};

# Author: Huahua
class Solution:
  def majorityElement(self, nums: List[int]) -> List[int]:
    n1, c1, n2, c2 = 0, 0, 1, 0
    for num in nums:
      if num == n1: c1 += 1
      elif num == n2: c2 += 1
      elif c1 == 0: n1, c1 = num, 1
      elif c2 == 0: n2, c2 = num, 1
      else: c1, c2 = c1 - 1, c2 -1
    
    c1, c2 = 0, 0
    for num in nums:
      if num == n1: c1 += 1
      elif num == n2: c2 += 1
    
    ans = []
    if c1 > len(nums) // 3: ans.append(n1)
    if c2 > len(nums) // 3: ans.append(n2)
    return ans

Related Problem

• https://zxi.mytechroad.com/blog/divide-and-conquer/leetcode-169-majority-element/

The post 花花酱 LeetCode 229. Majority Element II appeared first on Huahua's Tech Road.

题目大意：给你一个数组，其中一个数出现超过n/2次，问你出现次数最多的那个数是什么？

Problem:

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.

Ideas:

Solution 1:

Hash table O(n) / O(n)

// Author: Huahua
// Runtime : 23 ms
class Solution {
public:
    int majorityElement(vector<int>& nums) {
        unordered_map<int, int> count;
        const int n = nums.size();
        for (const int num : nums)
            if (++count[num] > n / 2) return num;
        return -1;
    }
};

Solution 2:

BST O(nlogk) / O(n)

// Author: Huahua
// Runtime : 19 ms
class Solution {
public:
    int majorityElement(vector<int>& nums) {
        map<int, int> count;
        const int n = nums.size();
        for (const int num : nums)
            if (++count[num] > n / 2) return num;
        return -1;
    }
};

Solution 3:

Randomization O(n) / O(1)

// Author: Huahua
// Runtime: 19 ms
class Solution {
public:
    int majorityElement(vector<int>& nums) {
        srand(time(nullptr));
        const int n = nums.size();
        while (true) {
            const int index = rand() % n;
            const int majority = nums[index];
            int count = 0;
            for (const int num : nums)
                if (num == majority && ++count > n/2) return num;
        }
        return -1;
    }
};

Solution 4:

Bit voting O(n) / O(1)

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        const int n = nums.size();
        int majority = 0;        
        for (int i = 0; i < 32; ++i) {
            int mask = 1 << i;
            int count = 0;
            for (const int num : nums)
                if ((num & mask) && (++count > n /2)) {
                    majority |= mask;
                    break;
                }
        }
        return majority;
    }
};

Solution 5:

Moore Voting O(n) / O(1)

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        int majority = nums.front();
        int count = 0;
        
        for (const int num : nums) {
            if (num == majority) ++count;
            else if (--count == 0) {
                count = 1;
                majority = num;
            }
        }
        
        return majority;
    }
};

Solution 6:

Full sorting O(nlogn) / O(1)

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        std::sort(nums.begin(), nums.end());
        return nums[nums.size()/2];
    }
};

Solution 7:

Partial sorting O(n) / O(1)

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        nth_element(nums.begin(), nums.begin() + nums.size() / 2, nums.end());
        return nums[nums.size() / 2];
    }
};

Solution 8:

Divide and conquer O(nlogn) / O(logn)

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        return majorityElement(nums, 0, nums.size() - 1);
    }
private:
    int majorityElement(const vector<int>& nums, int l, int r) {
        if (l == r) return nums[l];
        const int m = l + (r - l) / 2;
        const int ml = majorityElement(nums, l, m);
        const int mr = majorityElement(nums, m + 1, r);
        if (ml == mr) return ml;
        return count(nums.begin() + l, nums.begin() + r + 1, ml) >
               count(nums.begin() + l, nums.begin() + r + 1, mr)
               ? ml : mr;
    }
};

Divide and conquer O(nlogn) / O(logn)

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        return majorityElement(nums, 0, nums.size() - 1).first;
    }
private:
    pair<int, int> majorityElement(const vector<int>& nums, int l, int r) {
        if (l == r) return {nums[l], 1};
        int mid = l + (r - l) / 2;
        auto ml = majorityElement(nums, l, mid);
        auto mr = majorityElement(nums, mid + 1, r);
        if (ml.first == mr.first) return { ml.first, ml.second + mr.second };
        if (ml.second > mr.second)
            return { ml.first, ml.second + count(nums.begin() + mid + 1, nums.begin() + r + 1, ml.first) };
        else
            return { mr.first, mr.second + count(nums.begin() + l, nums.begin() + mid + 1, mr.first) };
    }
};

The post 花花酱 LeetCode 169. Majority Element appeared first on Huahua's Tech Road.