Question

是否有单线程（或简单的无环路）解决方案通过偶数和奇数索引对矢量进行排序？例如：

long entries[] = {0,1,2,10,11}; // indices 0 1 2 3 4
std::vector<long> vExample(entries, entries + sizeof(entries) / sizeof(long) );

vExample.sortEvenOdd(vExample.begin(),vExample.end()); // magic one liner I wish existed...

for (int i = 0; i < vExample.size(); i++)
{
    std::cout << vExample[i] << " ";
}

现在我希望得到以下输出：

0 2 11 1 10 // corresponding to indices 0 2 4 1 3

Answer 1

我尝试做一个真正的一个班轮：

  std::stable_partition(std::begin(input), std::end(input),
                        [&input](int const& a){return 0==((&a-&input[0])%2);});

这是完整的程序：

#include <algorithm>
#include <iostream>
#include <vector>

int main() {
  std::vector<int> input {0,1,2,10,11};

  std::stable_partition(std::begin(input), std::end(input),
                        [&input](int const& a){return 0==((&a-&input[0])%2);});

  for (auto v : input)
    std::cout << v << " ";
}

好的，我知道，它的作用唯一的原因是矢量使用了连续的一系列物品而且整个东西都很脏...但是对于那个“OP”要求的一个衬里并且它没有＆＃39;需要任何额外的东西，比如加强......

Answer 2

这不是一个班轮，但非常接近：

long entries[] = {0,1,2,10,11}; // indices 0 1 2 3 4
std::vector<long> vExample;
for( bool flag : { true, false } ) {
    auto cond = [&flag]( long ) { flag = !flag; return !flag; };
    std::copy_if( std::begin( entries ), std::end( entries ), std::back_inserter( vExample ), cond );
}

Answer 3

如果您可以使用Boost，这非常简洁：

#include <boost/range/adaptor/strided.hpp>
#include <boost/range/adaptor/sliced.hpp>
#include <boost/range/algorithm_ext/push_back.hpp>
#include <iostream>
#include <vector>

int main() {
    using namespace boost::adaptors;

    std::vector<int> input {0,1,2,10,11};
    std::vector<int> partitioned;

    boost::push_back(partitioned, input | strided(2));
    boost::push_back(partitioned, input | sliced(1, input.size()) | strided(2));

    for (auto v : partitioned)
        std::cout << v << " ";
}

当然，您可以将其包装在函数中，以便在调用代码中获得一个内联。 Live

Answer 4

我不喜欢摆弄@fjardon接受的答案所建议的地址。 @Slava的建议要好得多，并且与OP的代码结合使用，可以使效果很好：

int main() {
   std::vector<int> vals {0,2,3,-3,8,-5,7,8};
  bool flag = true;
    std::stable_partition(begin(vals), end(vals), [&flag] (auto el) mutable
                          {
                            // toggle flag, return previous value
                            flag = !flag; return !flag;
                          });
    for (auto v : vals)
        std::cout << v << " ";
} 

Output: 0 3 8 7 2 -3 -5 8

Answer 5

您需要的是stable_partition。定义一个谓词，检查索引是否使用模2，你就可以了。

按偶数和奇数索引对矢量进行排序。 C ++

5 个答案: