交换 std::list 中的相邻元素

Question

我想改变std::list中相邻元素的位置

列表和值的示例

A B C D E F G
3 2 1 2 1 3 2

排序后我期望收到的：

A B D C F E G
3 2 2 1 3 1 2

所以，简单的A > B = 无事可做，但C < D = 交换它们并转到E 比较。

我不知道如何交换相邻元素。

所以，我想前进 1 步 good 元素

Answer 1

您可以使用两个迭代器轻松做到这一点：

void biswap(std::list<int> &l)
{
    if (l.size() < 2)
        return;
    auto it2 = l.begin();
    auto it1 = it2++;
    auto e = l.end();
    for (;;)
    {
        if (*it1 < *it2)
            std::swap(*it1, *it2);
        it1 = it2++;
        if (it2 == e)
            return;
        it1 = it2++;
        if (it2 == e)
            return;
    }
}

Live example

注意：如果您不使用 C++11 并因此调用 size() 可能会产生很大的开销，您可以用它替换它（当然，用显式类型替换 auto 的所有用法）：

void biswap(std::list<int> &l)
{
    auto it2 = l.begin();
    auto e = l.end();
    if (it2 == e)
        return;
    auto it1 = it2++;
    if (it2 == e)
        return;
    for (;;)
    // ... the rest as before
}

Answer 2

您可以使用标准算法std::adjacent_find 找到第一个

例如

#include <iostream>
#include <algorithm>
#include <list>
#include <functional>
#include <iterator>

int main()
{
   std::list<int> l = { 3, 2, 1, 2, 1, 3, 2 };

   for ( int x : l ) std::cout << x << ' ';
   std::cout << std::endl;

   auto it = std::adjacent_find( l.begin(), l.end(), std::less<int>() );

   if ( it != l.end() ) std::swap( *it, *std::next( it ) );

   for ( int x : l ) std::cout << x << ' ';
   std::cout << std::endl;
} 

输出是

3 2 1 2 1 3 2 
3 2 2 1 1 3 2 

或者如果你想在第一个

#include <iostream>
#include <algorithm>
#include <list>
#include <functional>
#include <iterator>

int main()
{
    std::list<int> l = { 3, 2, 1, 2, 1, 3, 2 };

    for ( int x : l ) std::cout << x << ' ';
    std::cout << std::endl;

    std::list<int>::iterator it = l.begin();

    while ( ( it = std::adjacent_find( it, l.end(), std::less<int>() ) ) != l.end() )
    {
        std::swap( *it, *std::next( it ) );
    }

    for ( int x : l ) std::cout << x << ' ';
    std::cout << std::endl;
} 

输出是

3 2 1 2 1 3 2 
3 2 2 1 3 2 1

Answer 3

这给出了所需的结果，并完全按照您的要求切换了“好”元素的比较：

#include <list>
#include <iostream>

using namespace std;

template<typename Type>
void print(const list<Type> & l)
{
    for (auto element : l) cout << element << " ";
    cout << endl;
}

int main(int argc, const char *argv[])
{
    list<int> l = {3,2,1,2,1,3,2}; 

    print(l);

    auto it = l.begin(); 
    while(std::next(it) != l.end())
    {
        if (*it < *std::next(it))
        {
            std::swap(*it, *std::next(it)); 
            ++it; 
        }
        ++it; 
    } 

    print(l); 

    return 0;
}

执行结果：

3 2 1 2 1 3 2 
3 2 2 1 3 1 2

Answer 4

如果您没有 C++11 支持，使用 2 个迭代器的简单 C++03 解决方案可能是：

#include <iostream>
#include <algorithm>
#include <list>

void swapNeighbours(std::list<int>& l) {

    std::list<int>::iterator it = l.begin();
    std::list<int>::iterator prev = it++;
    while (prev != l.end() && it != l.end()) {

        // swap if needed:
        if (*prev < *it)
            std::swap(*prev, *it);

        // move 2 times forward:
        if (++it == l.end())
            break;
        prev = it++;
    }
}

然后（根据您的示例）如果您这样做：

void print(const std::list<int>& l) {
    std::list<int>::const_iterator i;
    for (i = l.begin(); i != l.end(); ++i) {
        std::cout << *i << ' ';
    }
    std::cout << std::endl;
}

int main() {

    std::list<int> l;
    l.push_back(3); l.push_back(2); l.push_back(1); l.push_back(2);
    l.push_back(1); l.push_back(3); l.push_back(2);

    print(l);
    swapNeighbours(l);
    print(l);
}

那么对于：

A B C D E F G
3 2 1 2 1 3 2

会有以下比较：A < B? （否）C < D? （是的，交换）E < F? （是的，交换也是）产生输出：

3 2 2 1 3 1 2 

Answer 5

如果你想要做的只是成对遍历和交换元素，如果第一个小于第二个，那么你可以例如像这样使用std::adjacent_find：

using std::swap;
for (auto it = std::begin(l); it != std::end(l); it = std::adjacent_find(it, std::end(l), std::less<int>{})) {
    swap(*it, *std::next(it));
}

这将导致数字列表3 2 1 2 1 3 2 排列为：

3 2 2 1 3 2 1

但是，这不与您的预期结果3 2 2 1 3 1 2 相同，我不明白您为什么不想交换最后一对1 2和其他人一样吗？

如果你想要的是一个 不稳定的 排序模式，那么就没有简单的解决方案。相反，您必须对单个元素进行特殊处理。