C++ 如何以不同的方式实现此冒泡排序？

我希望实现一个冒泡排序。我编写了以下代码，在

do

循环中使用

for

循环。如何将其转换为使用两个

for

循环的冒泡排序

这是我的密码：

do {
    switched = false;
    for (int i = 1; i < size; i++) {
        if (a[i] < a[i-1]) {
            int temp = a[i];
            a[i] = a[i-1];
            a[i-1] = temp;
            switched = true;
        }
    }
} while (switched);

do{
切换=假；
对于（int i=1；i

---

（这是标记的家庭作业，但这是为期末考试准备的，不是实际的家庭作业。）

有点义务，但嘿，你自找的：

for(bool switched=true; switched;)
{
    switched = false;
    for (int i = 1; i < size; i++) {
        if (a[i] < a[i-1]) {
            int temp = a[i];
            a[i] = a[i-1];
            a[i-1] = temp;
            switched = true;
        }
    }
}

for（bool switched=true；switched；）
{
切换=假；
对于（int i=1；i

---

两个for循环…

您可以运行内部循环

size

次，而不是检查

切换的
，方法是让外部循环
for（int j=0；j第一次完全通过循环（即，外部
do
循环的第一次迭代）保证将最大的元素放置在
a[size-1]的位置
（你知道为什么吗？）。下一个完整过程保证不会改变这一点，此外，将第二大元素放置在位置
a[size-2]
（同样，你知道为什么吗？）依此类推。因此，第一个过程需要
i
从
1
到
size-1
，但第二个过程只需要
i
从
1
到
size-2
，第三个过程只需要
i
从
1
到
size-3
，依此类推。总的来说，您最多需要
size-1
过程（最后一次传球仅覆盖位置
1
，并将
a[1]
与
a[0]
进行比较，以确保最小的元素就位）

因此，您的外部
for
-循环需要改变
max_i
，最初设置为
size-1
，最后设置为
1
，而内部
for
-循环需要改变
i
从
1
到
max_i
，因为您知道列表中的最后一个元素总是会被排序的（因为它一直冒泡到顶部）你可以停在那里

for(int x = size; x >= 0; x--) {
    bool switched = false;
    for(int i = 1; i < x; i++) {
        if(blah) {
            // swap code here
            switched = true;
        }

    }
    if(!switched) break; // not the biggest fan of this but it gets the job done
}

用于（int x=size；x>=0；x--）{
布尔值=假；
对于（int i=1；i
想想
do
循环可以执行的最大次数。
由于内部循环运行的最大次数是
size
次，因此您知道外部循环只能由
size
绑定

for (int x = 0; x < size; x++ )
{
    switched = false;
    for (int i = 1; i < size; i++)
    {
        if (a[i] < a[i - 1])
        {
            int temp = a[i];
            a[i] = a[i - 1];
            a[i - 1] = temp;
            switched = true;
        }
    }

    if(switched)
    {
        break;
    }
}

for（int x=0；x
使用两个for循环的愚蠢方法如下：

for(bool switched=true;switched;)
{
    switched=false;
    for(int i=1; i<size; ++i)
    {
        if (a[i] < a[i-1]) 
        {
            int temp = a[i];
            a[i] = a[i-1];
            a[i-1] = temp;
            switched = true;
        }
    }
}

for（bool switched=true；switched；）
{
切换=假；
对于（int i=1；i冒泡排序的一个简单改进是记住发生交换的最后一个位置。每次传递后，对超过该点的元素进行排序。下一次循环仅迭代到上一个高水位线

void bubble_sort(int *arr, int size)
{
    for (int hwm; size > 1; size = hwm)
    {
        hwm = 0;
        for (int i = 1; i < size; ++i)
        {
            if (arr[i] < arr[i-1])
            {
                std::swap(arr[i], arr[i-1]);
                hwm = i;
            }
        }
    }
}

void bubble\u排序（int*arr，int size）
{
用于（整数hwm；大小>1；大小=hwm）
{
hwm=0；
对于（int i=1；i
“我想实现一个冒泡排序”-这是你的问题！（说真的，他们为什么继续坚持教授使用冒泡排序…）@ MikWesty，实现BuffelORT只是教学排序的入门……它帮助您理解其他排序技术。您不应该从零开始吗？@ GLoWoCuff:I认为JVM不太抱怨C++代码。@ DelMmg是的，是的，正如我刚才说的，乍一看，它似乎是一个java问题。我今天早上起得很早，去和国际客户一起工作：-（我要怪它！哇。为什么讨厌呢？：（我不想提高投票率，因为…哇，这太糟糕了！同时，我不想降低投票率，因为它很聪明，很好）正确。撕碎了！你应该被报告为对
声明的
残忍对待！@glowcoder:请不要投票。非常感谢你的评论！我在这个简短的回答和一个尖刻的评论之间被撕碎了：）如果你不喜欢
中断
你可以做
i@Jon以前给CS101作业评分过，是的，我同意。这可能是教授最想要的，特别是关于“最近最高元素”总是如何排序的一个小片段。@Jon是的。我更喜欢
break
。这样做会让在循环之外是可变的，因此在一个比它需要的范围更大的范围内。函数往往会变得足够大，我们不应该给人们比他们需要的更多的变量。我也是
break
的粉丝。如果你不介意最好的情况==最坏的情况，那么
break
是完全可选的。也不会
x>1
是否为第一个循环工作？
void bubble_sort(int *arr, int size)
{
    for (int hwm; size > 1; size = hwm)
    {
        hwm = 0;
        for (int i = 1; i < size; ++i)
        {
            if (arr[i] < arr[i-1])
            {
                std::swap(arr[i], arr[i-1]);
                hwm = i;
            }
        }
    }
}