C++ 冒泡排序在c+中的实现+；

下面的代码用于实现冒泡排序。为什么在这种情况下使用模板？而

swapped

variabe的目的是什么。即使我从循环代码中删除

swapped

变量和

swapped条件

，仍然可以正常工作

#include <algorithm>
#include <iostream>
#include <iterator>

template <typename RandomAccessIterator>
void bubble_sort(RandomAccessIterator begin, RandomAccessIterator end) {
  bool swapped = true;
  while (begin != end-- && swapped) {
    swapped = false;
    for (auto i = begin; i != end; ++i) {
      if (*(i + 1) < *i) {
        std::iter_swap(i, i + 1);
        swapped = true;
      }
    }
  }
}

int main() {
  int a[] = {100, 2, 56, 200, -52, 3, 99, 33, 177, -199};
  bubble_sort(std::begin(a), std::end(a));
  copy(std::begin(a), std::end(a), std::ostream_iterator<int>(std::cout, " "));
  std::cout << "\n";
}

#包括
#包括
#包括
模板
void bubble_排序（RandomAccessIterator开始，RandomAccessIterator结束）{
bool swapped=true；
while（开始！=结束--&&swapped）{
交换=假；
for（自动i=开始；i！=结束；++i）{
如果（*（i+1）<*i）{
标准：国际热核实验堆交换（i，i+1）；
交换=真；
}
}
}
}
int main（）{
INTA[]={100,2,56,200，-52,3,99,33,177，-199}；
冒泡排序（std:：begin（a），std:：end（a））；
复制（std:：begin（a）、std:：end（a）、std:：ostream_迭代器（std:：cout“”）；
std:：cout模板只是为了方便使用不同类型的函数。实现该函数时使用迭代器而不是简单的数组可以为您节省大量指针和大小方面的麻烦

swapped
变量向算法指示从
begin
到
end
的最后一次运行没有导致任何交换。这意味着数组已经在这个范围内排序（并且超过
end
也会排序，因为这是在前面的过程中处理的）在
开始
和
结束
迭代器相同之前，无需循环。如果删除此检查，算法将起作用，但在部分排序数组的情况下可能会造成时间浪费

让我们看看这个例子：

0: {1   2   5   3   4} (begin = 0, end = 4)
1: {1   2   3   4   5} (begin = 0, end = 3)
2: {1   2   3   4   5} (begin = 0, end = 2)
3: {1   2   3   4   5} (begin = 0, end = 1)
4: {1   2   3   4   5} (begin = 0, end = 0)

您可以看到，在
0:
之后，数组已经排序，但是如果没有
swapped
标志，算法将不会中断并继续检查。如果
1:
之后有该标志，则
swapped
标志为
false
，并且算法退出。
该模板仅用于方便使用不同类型的函数。使用迭代器而不是简单数组来实现该函数可以在指针和大小方面为您节省很多麻烦

swapped
变量向算法指示从
begin
到
end
的最后一次运行没有导致任何交换。这意味着数组已经在这个范围内排序（并且超过
end
也会排序，因为这是在前面的过程中处理的）在
开始
和
结束
迭代器相同之前，无需循环。如果删除此检查，算法将起作用，但在部分排序数组的情况下可能会造成时间浪费

让我们看看这个例子：

0: {1   2   5   3   4} (begin = 0, end = 4)
1: {1   2   3   4   5} (begin = 0, end = 3)
2: {1   2   3   4   5} (begin = 0, end = 2)
3: {1   2   3   4   5} (begin = 0, end = 1)
4: {1   2   3   4   5} (begin = 0, end = 0)

您可以看到，在
0:
之后，数组已经排序，但是如果没有
swapped
标志，算法将不会中断并继续检查。如果
1:
之后有该标志，则
swapped
标志为
false
，算法将退出。
不同的容器有自己的迭代器类型例如，对于一维数组，使用指针作为迭代器，而对于std:：vector类型的对象，使用此模板类中定义的迭代器

变量
swapped
用作判断元素是否已排序的标准。如果在遍历序列时未交换序列的元素，则表示序列已排序

考虑到由于此语句，您显示的实现具有未定义的行为

while (begin != end-- && swapped) {
                ^^^^

因为有人试图在范围可以为空时减少最后一个迭代器，所以实现是不正确的

此外，该算法效率不高。例如，数组的尾部可以在内部循环迭代后进行排序。但是在外部循环中，最后一个迭代器仅向左移动一个位置

对冒泡排序使用前向迭代器就足够了。在这种情况下，即使使用
std:：forward_list
和其他没有随机访问迭代器的容器，也可以使用该算法

#include <iostream>
#include <algorithm>
#include <iterator>
#include <forward_list>

template <typename ForwardIterator>
void bubble_sort( ForwardIterator first, ForwardIterator last )
{
    for ( ForwardIterator sorted = first; first != last; last = sorted )
    {
        sorted = first;
        for ( ForwardIterator current = first, prev = first; ++current != last; ++prev )
        {
            if ( *current < *prev )
            {
                std::iter_swap( current, prev );
                sorted = current;
            }
        }
    }
}

int main() 
{
    int a[] = { 100, 2, 56, 200, -52, 3, 99, 33, 177, -199 };

    bubble_sort( std::begin( a ), std::end( a ) );
    std::copy( std::begin( a ), std::end( a ), 
               std::ostream_iterator<int>( std::cout, " " ) );
    std::cout << "\n";

    std::forward_list<int> lst = { 100, 2, 56, 200, -52, 3, 99, 33, 177, -199 };

    bubble_sort( std::begin( lst ), std::end( lst ) );
    std::copy( std::begin(lst ), std::end( lst ), 
               std::ostream_iterator<int>( std::cout, " " ) );
    std::cout << "\n";
}   

下面是一个演示程序，演示如何使用前向迭代器实现该算法

#include <iostream>
#include <algorithm>
#include <iterator>
#include <forward_list>

template <typename ForwardIterator>
void bubble_sort( ForwardIterator first, ForwardIterator last )
{
    for ( ForwardIterator sorted = first; first != last; last = sorted )
    {
        sorted = first;
        for ( ForwardIterator current = first, prev = first; ++current != last; ++prev )
        {
            if ( *current < *prev )
            {
                std::iter_swap( current, prev );
                sorted = current;
            }
        }
    }
}

int main() 
{
    int a[] = { 100, 2, 56, 200, -52, 3, 99, 33, 177, -199 };

    bubble_sort( std::begin( a ), std::end( a ) );
    std::copy( std::begin( a ), std::end( a ), 
               std::ostream_iterator<int>( std::cout, " " ) );
    std::cout << "\n";

    std::forward_list<int> lst = { 100, 2, 56, 200, -52, 3, 99, 33, 177, -199 };

    bubble_sort( std::begin( lst ), std::end( lst ) );
    std::copy( std::begin(lst ), std::end( lst ), 
               std::ostream_iterator<int>( std::cout, " " ) );
    std::cout << "\n";
}   

这里在程序中使用了一个数组和一个类型为
std:：forward_list
的对象，该算法可以应用于这两个容器。
不同的容器有自己的迭代器类型。例如，对于一维数组，使用指针作为迭代器，而对于std:：vector类型的对象，则有我们在这个模板类中定义的迭代程序

变量
swapped
用作判断元素是否已排序的标准。如果在遍历序列时未交换序列的元素，则表示序列已排序

考虑到由于此语句，您显示的实现具有未定义的行为

while (begin != end-- && swapped) {
                ^^^^

因为有人试图在范围可以为空时减少最后一个迭代器，所以实现是不正确的

此外，该算法效率不高。例如，数组的尾部可以在内部循环迭代后进行排序。但是在外部循环中，最后一个迭代器仅向左移动一个位置

对冒泡排序使用前向迭代器就足够了。在这种情况下，即使使用
std:：forward_list
和其他没有随机访问迭代器的容器，也可以使用该算法

#include <iostream>
#include <algorithm>
#include <iterator>
#include <forward_list>

template <typename ForwardIterator>
void bubble_sort( ForwardIterator first, ForwardIterator last )
{
    for ( ForwardIterator sorted = first; first != last; last = sorted )
    {
        sorted = first;
        for ( ForwardIterator current = first, prev = first; ++current != last; ++prev )
        {
            if ( *current < *prev )
            {
                std::iter_swap( current, prev );
                sorted = current;
            }
        }
    }
}

int main() 
{
    int a[] = { 100, 2, 56, 200, -52, 3, 99, 33, 177, -199 };

    bubble_sort( std::begin( a ), std::end( a ) );
    std::copy( std::begin( a ), std::end( a ), 
               std::ostream_iterator<int>( std::cout, " " ) );
    std::cout << "\n";

    std::forward_list<int> lst = { 100, 2, 56, 200, -52, 3, 99, 33, 177, -199 };

    bubble_sort( std::begin( lst ), std::end( lst ) );
    std::copy( std::begin(lst ), std::end( lst ), 
               std::ostream_iterator<int>( std::cout, " " ) );
    std::cout << "\n";
}   

下面是一个演示程序，演示如何使用前向迭代器实现该算法

#include <iostream>
#include <algorithm>
#include <iterator>
#include <forward_list>

template <typename ForwardIterator>
void bubble_sort( ForwardIterator first, ForwardIterator last )
{
    for ( ForwardIterator sorted = first; first != last; last = sorted )
    {
        sorted = first;
        for ( ForwardIterator current = first, prev = first; ++current != last; ++prev )
        {
            if ( *current < *prev )
            {
                std::iter_swap( current, prev );
                sorted = current;
            }
        }
    }
}

int main() 
{
    int a[] = { 100, 2, 56, 200, -52, 3, 99, 33, 177, -199 };

    bubble_sort( std::begin( a ), std::end( a ) );
    std::copy( std::begin( a ), std::end( a ), 
               std::ostream_iterator<int>( std::cout, " " ) );
    std::cout << "\n";

    std::forward_list<int> lst = { 100, 2, 56, 200, -52, 3, 99, 33, 177, -199 };

    bubble_sort( std::begin( lst ), std::end( lst ) );
    std::copy( std::begin(lst ), std::end( lst ), 
               std::ostream_iterator<int>( std::cout, " " ) );
    std::cout << "\n";
}   

在程序中使用了一个数组和一个类型为
std:：forward_list
的对象，该算法可以应用于这两个容器。
变量
swapped
使代码运行更快。基本上，它测试运行中是否有任何两个值交换。如果没有，则