【面试题39：数组当中数字超过一半的数字】

   求数组当中元素个数超过一半的数字，例如一个长度为7的数组：{1,2,2,2,2,4,5}；其中元素2的个数为4，长度超过了一半；

我的做法是：（假设输入是vector<int> vec）构建一个map<int, int>；key对应vec当中元素，value对应vec当中元素出现次数。我们遍历vec_,然后直接执行map_[ele_]++。遍历完之后，再遍历map就很容易找出这个数。

int MoreThanHalfNum_Solution1(vector<int>& vec_)
{
    // 异常处理
    if (vec_.empty())
        return -1;

    map<int, int> map_;
    for (auto ele_ : vec_)
    {
        map_[ele_]++;
    }

    int half_num_ = vec_.size() / 2;
    for (auto ele_ : map_)
    {
        if (ele_.second > half_num_)
        {
            return ele_.first;
        }
    }
    // 可能不存在这样的数
    return -1;
}

这种做法的缺点是：我在这里利用了map这种关联容器。在插入新元素的时候，如果已经存在相同key的元素，这时候会插入失败。不管怎样，插入新元素的时候，都会遍历map一次。

改进做法：例如：对于数组{1，1,1,2,2,3,4,4,4,4}；遍历数组，设置times_ =  0；

1、如果 当前元素和上一个元素相同，则 times_ ++；

2、如果 当前元素和上一个元素不同，则 times_ --；

3、如果times_ = 0，则将上一个元素刷新为当前元素，times_ = 1;

//统计元素 result_ 在 vec_数组当中是否超过半数
bool CheckMoreHalf(vector<int>& vec_, int retsult_)
{
    if (vec_.empty())
        return -1;

    int count = 0;
    for (auto ele_:vec_)
    {
        if ( ele_ == retsult_)
        {
            count++;
        }
    }

    if (2*count >= vec_.size())
    {
        return true;
    }
    else
    {
        return false;
    }

}

int MoreThanHalfNum_Solution2(vector<int>& vec_)
{
    if (vec_.empty())
        return -1;

    int ret_ = vec_[0];
    int times_ = 1;
    for (auto ele_:vec_)
    {
        if (times_ == 0)
        {
            ret_ = ele_;
            times_ = 1;
        }
        else if (ele_ == ret_)
            times_++;
        else
            times_--;
    }
    if (!CheckMoreHalf(vec_, ret_))
    {
        ret_ = -1;
    }
    return ret_;
}

方法2的优点是时间复杂度明显是O（n）；其实方法1的时间复杂度表面上看是O（n）；由于每一次循环都会调用map底层排序（基于红黑树）。所以，方法一的复杂度远不止O（n）；有关几种常用排序算法，这里不作讨论了。

现在我们做实验，将数组size设置到20000+

#include<map>
#include<vector>
#include<iostream>

using namespace std;

#include<boost/timer.hpp>

int MoreThanHalfNum_Solution1(vector<int>& vec_)
{
    // 异常处理
    if (vec_.empty())
        return -1;

    map<int, int> map_;
    for (auto ele_ : vec_)
    {
        map_[ele_]++;
    }

    int half_num_ = vec_.size() / 2;
    for (auto ele_ : map_)
    {
        if (ele_.second > half_num_)
        {
            return ele_.first;
        }
    }
    // 可能不存在这样的数
    return -1;
}

//统计元素 result_ 在 vec_数组当中是否超过半数
bool CheckMoreHalf(vector<int>& vec_, int retsult_)
{
    if (vec_.empty())
        return -1;

    int count = 0;
    for (auto ele_:vec_)
    {
        if ( ele_ == retsult_)
        {
            count++;
        }
    }

    if (2*count >= vec_.size())
    {
        return true;
    }
    else
    {
        return false;
    }

}

int MoreThanHalfNum_Solution2(vector<int>& vec_)
{
    if (vec_.empty())
        return -1;

    int ret_ = vec_[0];
    int times_ = 1;
    for (auto ele_:vec_)
    {
        if (times_ == 0)
        {
            ret_ = ele_;
            times_ = 1;
        }
        else if (ele_ == ret_)
            times_++;
        else
            times_--;
    }
    if (!CheckMoreHalf(vec_, ret_))
    {
        ret_ = -1;
    }
    return ret_;
}

int main()
{
    vector<int> vec_{ 1,3,4,5,6,6,6,6,6,6,6,2,7 };
    for (int i = 0; i < 20000; i++)
    {
        vec_.push_back(8);
    }

    boost::timer timer1;
    cout << "MoreThanHalfNum_Solution1 : " << MoreThanHalfNum_Solution1(vec_) << endl;
    cout << "the cost of time is:" << timer1.elapsed() << endl;

    boost::timer timer2;
    cout << "MoreThanHalfNum_Solution2 : " << MoreThanHalfNum_Solution2(vec_) << endl;
    cout << "the cost of time is:" << timer2.elapsed() << endl;

    return 1;
}

Debug X64模式：

 

以上四次实验：从上往下，输入数组规模一次增大，分别为：2000、4000、20000、40000；

可以看到第二种算法速度总是第一种的5倍以上；所以，c++ STL虽然用起来舒服，但是还是要站在效率的角度上，适当使用STL，且要用对、用准相应容器类型。