C ++中的冒泡排序实现

Question

下面的代码用于实现冒泡排序。 为什么在这种情况下使用模板？ swapped可变参数的目的是什么。 即使我从循环代码中删除了swapped变量和swapped condition仍然可以正常工作

#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";
}

另一个实现：

template<typename Iterator>
 void bubbleSort(Iterator first, Iterator last)
 {
     Iterator i, j;
     for (i = first; i != last; i++)
         for (j = first; j < i; j++)
             if (*i < *j)
                 std::iter_swap(i, j); // or std::swap(*i, *j);
 }

Answer 1

模板的存在只是为了方便使用具有不同类型的功能。 实现使用迭代器而不是简单数组的函数可以为您节省很多指针和大小的麻烦。

swapped变量向算法指示从begin到end的最后一次运行没有导致任何交换。 这意味着该数组已经在该范围内进行了排序（并且在end也进行了排序，因为这是在前一遍中所处理的），并且无需循环，直到begin和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:之后0:数组已经排序，但是没有swapped标志，算法将不会中断并继续检查。 如果标志在1:之后存在，则swapped标志为false ，算法退出。

Answer 2

不同的容器具有自己的迭代器类型。 例如，对于一维数组，使用指针作为迭代器，而对于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";
}   

程序输出为

-199 -52 2 3 33 56 99 100 177 200 
-199 -52 2 3 33 56 99 100 177 200 

在程序中，这里使用了一个数组和一个类型为std::forward_list的对象，并且该算法可以应用于两个容器。