Moore majority vote algorithm(摩爾投票算法)

Boyer-Moore majority vote algorithm(摩爾投票算法)

簡介

Boyer-Moore majority vote algorithm(摩爾投票算法)是一種在線性時間O(n)和空間復雜度的情況下，在一個元素序列中查找包含最多的元素。它是以Robert S.Boyer和J Strother Moore命名的，1981年發明的，是一種典型的流算法(streaming algorithm)。

在它最簡單的形式就是，查找最多的元素，也就是在輸入中重復出現超過一半以上(n/2)的元素。如果序列中沒有最多的元素，算法不能檢測到正確結果，將輸出其中的一個元素之一。

當元素重復的次數比較小的時候，對於流算法不能在小於線性空間的情況下查找頻率最高的元素。

算法描述

算法在局部變量中定義一個序列元素(m)和一個計數器(i)，初始化的情況下計數器為0. 算法依次掃描序列中的元素，當處理元素x的時候，如果計數器為0，那么將x賦值給m，然后將計數器(i)設置為1，如果計數器不為0，那么將序列元素m和x比較，如果相等，那么計數器加1，如果不等，那么計數器減1。處理之后，最后存儲的序列元素(m)，就是這個序列中最多的元素。

如果不確定是否存儲的元素m是最多的元素，還可以進行第二遍掃描判斷是否為最多的元素。

perudocode

• Initialize an element m and a counter i with i = 0
• For each element x of the input sequence:
  • if i = 0, then assign m = x and i = 1
  • else if m = x, then assign i = i + 1
  • else assign i = i − 1
• Return m

算法舉例

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.

實現代碼

class Solution {
public:
    // moore majority vote algorithm
    int majorityElement(vector<int>& nums) {
        int m;
        int count = 0;
        for (int i = 0; i < nums.size(); i++) {
            if (count == 0) {
                m = nums[i];
                count++;
            } else if (nums[i] == m) {
                count++;
            } else
                count--;
        }
        return m;
    }
};

還有一個類似的算法題，就是判斷一個序列中，某個元素的個數是否超過n/2，其中一種解法就是利用分治算法。還可以用上面找到的摩爾投票算法，第一遍掃描輸出一個存儲的元素，然后還需要進行第二遍掃描來判斷元素在序列中是否確實超過n/2了。 因為一個元素超過一半，最后肯定會留下，但是最后留下的不一定超過一半，所以要掃描第二遍。

代碼實現

#include <iostream>
#include <vector>
#include <cmath>

using namespace std;

class Solution {
public:
    // divide and conquer
    int majorityElement(vector<int>& nums, int majority) {
        if (nums.size() <= 2) {
            int num = 0;
            for (int i = 0; i < nums.size(); i++) {
                if (nums[i] == majority)
                    num++;
            }
            return num;
        }
        int middle = floor(nums.size() / 2);
        vector<int> left(nums.begin(), nums.begin() + middle);
        vector<int> right(nums.begin() + middle, nums.end());
        int left_num = majorityElement(left, majority);
        int right_num = majorityElement(right, majority);
        return left_num + right_num;
    }
    // moore majority vote algorithm
    // 判斷majority 是否大於一般以上,不含等於。
    int moore_majority_vote_algorithm(vector<int>& nums, int majority) {
        int m;
        int counter = 0;
        // 第一輪掃描
        for (int i = 0; i < nums.size(); i++) {
            if (counter == 0) {
                counter = 1;
                m = nums[i];
            } else if (m != nums[i]) {
                counter--;
            } else
                counter++;
        }
        if (m != majority)
            return -1;
        int new_counter = 0;
        // 第二輪掃描
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] == m)
                new_counter++;
        }
        return new_counter;
    }
};


int main() {
    int num[] = {2, 2, 1, 1, 1, 2};
    vector<int> vec(num, num + 6);
    Solution* solution = new Solution();
    int counter;
    cout << (counter = solution->majorityElement(vec, 2)) << endl;
    //cout << (counter = solution->moore_majority_vote_algorithm(vec, 2)) << endl;
    if (counter > floor(vec.size() / 2)) {
        cout << "Yes" << endl;
    } else
        cout << "No" << endl;
    return 0;
}