C++ 这段代码是气泡排序程序吗？

我做了一个简单的气泡排序程序，代码可以工作，但我不知道它是否正确

我对冒泡排序算法的理解是，它检查一个元素和它旁边的另一个元素

#include <iostream>
#include <array>

using namespace std;

int main()
{


    int a, b, c, d, e, smaller = 0,bigger = 0;
    cin >> a >> b >> c >> d >> e;
    int test1[5] = { a,b,c,d,e };

    for (int test2 = 0; test2 != 5; ++test2)
    {
        for (int cntr1 = 0, cntr2 = 1; cntr2 != 5; ++cntr1,++cntr2)
        {
            if (test1[cntr1] > test1[cntr2]) /*if first is bigger than second*/{
                bigger = test1[cntr1];
                smaller = test1[cntr2];

                test1[cntr1] = smaller;  
                test1[cntr2] = bigger;
            }

        }
    }
    for (auto test69 : test1)
    {
        cout << test69 << endl;
    }
    system("pause");


}

#包括
#包括
使用名称空间std；
int main（）
{
int a，b，c，d，e，较小的=0，较大的=0；
cin>>a>>b>>c>>d>>e；
int test1[5]={a，b，c，d，e}；
for（int test2=0；test2！=5；++test2）
{
对于（int cntr1=0，cntr2=1；cntr2！=5；++cntr1，++cntr2）
{
if（test1[cntr1]>test1[cntr2]）/*如果第一个大于第二个*/{
更大=test1[cntr1]；
较小=试验1[cntr2]；
test1[cntr1]=更小；
test1[cntr2]=更大；
}
}
}
用于（自动测试69:test1）
{
cout是的。您的代码就像气泡排序一样工作

输入：351812

每次迭代后的输出：

                         3 1 5 2 8
                         1 3 2 5 8
                         1 2 3 5 8
                         1 2 3 5 8
                         1 2 3 5 8
                         1 2 3 5 8

实际上，在内部循环中，我们不需要从第二次迭代开始一直到数组的末尾，因为上一次迭代中最重的元素已经在最后一次了。但这并不能大大提高时间复杂度。因此，您可以继续

小型非正式证明：

排序算法背后的思想是遍历值数组（从左到右）。我们称之为传递。在传递过程中，检查并交换值对，使其顺序正确（右上角）

在第一次传递期间，将达到最大值。当达到最大值时，最大值将高于它旁边的值，因此它们将被交换。这意味着最大值将成为传递中下一对的一部分。此过程将重复，直到传递完成，最大值移到数组的右端

在第二次传递过程中，数组中第二高的值也是如此。唯一的区别是它不会与最后的最大值交换。现在，两个最正确的值被正确设置

在下一次传递中，一个值将被排序到右侧

有N个值和N个过程。这意味着在N个过程之后，所有N个值将按如下方式排序：

{kth最大，（k-1）th最大，…第二大，最大}
这是一个bubblesort实现。它只是一个非常基本的实现

两项改进：


outerloop迭代每次可能会缩短一次，因为可以保证上一次迭代的最后一个元素是最大的
当迭代过程中没有进行交换时，您就完成了。（这是wikipedia中bubblesort定义的一部分）

一些评论：


使用更好的变量名（test2？）
使用容器的大小或范围，不要硬编码5
使用
std:：swap（）
交换变量可以得到更简单的代码

是一个使用（随机访问）迭代器的更一般的示例，其中包含我建议的改进和注释，以及Yves Daoust建议的改进（迭代到最后一次交换）使用debug prints
不，不是。更糟糕。变量cntr1

中没有任何意义。您应该在这里使用

test1

，并且您应该参考bubblesort的许多规范实现之一，而不是试图自己弥补它。

可以解释您的算法的正确性具体如下

在第一个过程（内部循环）中，通过可能的交换比较

T[i]>T[i+1]

，确保最大的

T[i]

，

T[i+1]

位于右侧。从左到右重复所有对，确保最后

T[N-1]

保留最大的元素。（仅通过交换修改阵列的事实确保了不会丢失或复制任何元素。）

在第二个过程中，根据相同的推理，

N-1

第一个元素中最大的元素进入

T[N-2]

，它留在那里，因为

T[N-1]

更大

更一般地说，在

K

th过程中，

N-K+1

第一个元素中最大的一个元素进入

T[N-K]

，保持在那里，接下来的元素保持不变（因为它们已经在增加）

因此，经过

N

后，所有元素都已就位

---

这暗示了一个简单的优化：在一个过程中最后一次交换之后的所有元素都已就位（否则交换将不是最后一次）。因此，您可以记录最后一次交换的位置，并仅执行下一次传递到该位置

虽然这一变化似乎没有多大改善，但它可以减少通过次数。事实上，通过这一过程，通过次数等于最大位移，即元素到达其适当位置所需的步骤数（右侧过多的元素一次只能移动一个位置）

---

在某些配置中，此数字可能很小。例如，对已排序的数组进行排序只需一次，对所有元素成对交换的数组进行排序需要两次。这是从O（N²）到O（N）的改进！

不完全是。在循环过程中，你必须重复内部循环，直到你没有交换。你尝试过吗？文章中的描述或伪代码与你的代码相符吗？如果不符合，那就不是冒泡排序。在循环过程中，试着打印出数组的状态以及你正在比较/交换的内容。这有助于你直观地看到你的code正在做，然后你可以更好地判断自己是否是冒泡排序。我在可视化它们时学会了排序算法。变量

cntr1

和

cntr2

不是相互独立的；显然

cntr2==cntr1+1

是循环的一个变量。也许这个问题更适合于代码审查。气泡排序的主要要点是，在每次迭代后，最重的元素位于数组的末尾。一个示例无法证明什么。该示例显示它正在放置最重的元素