vector删除偶数算法。

电话面试遇到一个题目，删除所有的偶数。

 

先上代码。

#include <vector>
#include <iostream>
#include <algorithm>
#include <stdlib.h>

#define IS_EVEN(a) (0 == (a) % 2)
#define IS_ODD(a) (0 != (a) % 2)

bool isEven(unsigned int a)
{
    return !(a % 2);
}

int main(int argc, char** argv)

{
    if (argc < 3)
    {
        std::cout << "\n==================================================="
                  << "\n" << argv[0] << "        [size][alog][y/n])]"
                  << "\n size:         acount of numbers"
                  << "\n alog:        algorithm 1.common loop 2. exchange and move if not delete from end  3. exchange and never move"
                  << "\n numberstput:    \'y\' to numberstput result"
                  << "\n===================================================\n";
    }
    int VEC_SIZE = atoi(argv[1]);
    int head = 0, tail = VEC_SIZE - 1;

    // init data
    std::vector<int> numbers(VEC_SIZE);
    for (int i = 0; i < VEC_SIZE; i++)
    {
        numbers.at(i) = (int)(rand() % (VEC_SIZE * 10));
    }

    if (argc > 3 && 'y' == *argv[3])
    {
        std::cout << "\n============================= before ===========================\n";
        tail = numbers.size() ;
        for (int i = 0; i < tail; i++)
                std::cout <<  numbers.at(i) << " ";
    }

    if ('1' == *argv[2])
    {    
        // algo 1: loop common.  stable.
        for (int i = 0; i < numbers.size();)
        {
            if (numbers[i] % 2 == 0)
                numbers.erase(numbers.begin() + i);
            else
                ++i;
        }
    }


    else if ('2' == *argv[2])
    {
        // will trigger memory movement if no delete from end. not stable
        for(; head <= tail;)
        {
            // odd - even
            if (IS_ODD(numbers[head]) && IS_EVEN(numbers[tail]))
            {
                numbers.erase(numbers.begin() + tail);
                --tail;
                ++head;
            }
            // even - odd
            else if (IS_EVEN(numbers[head]) && IS_ODD(numbers[tail]))
            {
                numbers[head] = numbers[tail];
                numbers.erase(numbers.begin() + tail);
                ++head;
                --tail;
            }
            // odd - odd
            else if (IS_ODD(numbers[head]) && IS_ODD(numbers[tail]))
            {
                ++head;
                --tail;
            }
            // even-even
            else if (IS_EVEN(numbers[head]) && IS_EVEN(numbers[tail]))
            {
                numbers.erase(numbers.begin() + tail);
                --tail;
            }
        }
    }

    else if ('3' == *argv[2])
    {
        // always delete from end, never trigger memory movement. not stable
        for(; head <= tail;)
        {
            // odd - even
            if (IS_ODD(numbers[head]) && IS_EVEN(numbers[tail]))
            {
                numbers[tail] = *numbers.rbegin();
                numbers.pop_back();
                
                --tail;
                ++head;
            }
            // even - odd
            else if (IS_EVEN(numbers[head]) && IS_ODD(numbers[tail]))
            {
                numbers[head] = *numbers.rbegin();
                numbers.pop_back();

                ++head;
                --tail;
            }
            // odd - odd
            else if (IS_ODD(numbers[head]) && IS_ODD(numbers[tail]))
            {
                ++head;
                --tail;
            }
            // even - even
            else if (IS_EVEN(numbers[head]) && IS_EVEN(numbers[tail]))
            {
                numbers[tail] = *numbers.rbegin();
                numbers.pop_back();
                --tail;
            }
        }
    }

    else if ('4' == *argv[2])
    {
        // always overide even with a adjacent odd. stable
        head = 0, tail = 1;
        for(;tail < VEC_SIZE;)
        {
            if (IS_EVEN(numbers[head]) && IS_ODD(numbers[tail]))
            {
                numbers[head] = numbers[tail];
                numbers[tail] = 0; // make it as a EVEN.
                ++head;
                ++tail;
            }
            else if (IS_ODD(numbers[head]) && IS_EVEN(numbers[tail]))
            {                
                ++head;
                ++tail;
            }
            else if (IS_EVEN(numbers[head]) && IS_EVEN(numbers[tail]))
            {
                ++tail;
            }
            else if (IS_ODD(numbers[head]) && IS_ODD(numbers[tail]))
            {
                head+=2;
                tail+=2;
            }
        }
        // erase all the unused number from head.
        numbers.erase(numbers.begin()+head, numbers.end());
    }

    else if ('5' == *argv[2])
    {
        //call remove_if
        std::vector<int>::iterator tail = remove_if(numbers.begin(), numbers.end(), isEven);
        numbers.erase(tail, numbers.end());
    }

    if (argc > 3 && 'y' == *argv[3])
    {
        std::cout << "\n============================= after ===========================\n";
        tail = numbers.size() ;
        for (int i = 0; i < tail; i++)
                std::cout <<  numbers.at(i) << " ";
    }
}

 

测试环境：i7-6600U 8G RAM 

分支1： 菜鸡强撸，数据量10w 大约60秒+， 100w好久都跑不出结果

分支2,两端向中间扫描，奇数替换偶数，不从末尾删除会导致memory move。非稳定算法，删除后，item顺序乱掉。

分支3,同2，不同在于一直从末尾删除，不触发memory move。非稳定算法，删除后，item顺序乱掉。

分支4,从开头扫描每次扫描两个item，奇数替换偶数，不触发memory move。 稳定算法。

分支5,调用STL 算法

 

事实证明STL的remove_if的原理和分支4一致。

同样开启-O3优化选项。

1billion数据量，处理时间均在1.6 second左右。

为了最大限度模拟生产环境，数据初始化用了随机数。 此种情况下，分支4和STL 速度一致。

如果用下标初始化每个item。STL在1.4秒左右处理 1billion。  比分支4快15%左右。maybe此种情况下编译器有特殊优化。不得而知。