Arrays 冒泡排序的外循环N值

我只是在学习排序（不是第一次）。在冒泡排序中，我们有以下代码

int bubble_sort(int *arr, size_t n) {

    size_t i, j;
    for (i = 0; i < n; i++) {
        for (j = 0; j < n - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }

    return 0;
}

int-bubble\u排序（int*arr，size\t n）{
尺寸i，j；
对于（i=0；iarr[j+1]）{
内部温度=arr[j]；
arr[j]=arr[j+1]；
arr[j+1]=温度；
}
}
}
返回0；
}

---

正如大家所看到的，内部循环有

n-1

次（在for循环中），这是可以理解的（

a[i]，a[i-1]

都涉及一次迭代），但是外部循环有

i

，但它也适用于

i

。但是，internet上的大多数实现都使用

n

作为外循环值。执行外循环

n-1

在最坏的情况下工作正常

5 4 3 2 1

。只是想知道，是否有任何一组输入在外循环的

n-1

时间内不起作用。如果有，请张贴并解释。谢谢。

N-1也可以。正如您所描述的，最坏的情况需要N-1交换（因为最后一个必须成为第一个，反之亦然）。如果将i变量的打印添加到If语句的内部，您将看到在上一次迭代中从未调用过它。这意味着循环的最后一次迭代不会导致任何交换

不过，Bubblesort更高效的实现并不使用for循环作为外部循环。看看下面的代码。你能看到执行的不同吗

int bubble_sort(int *arr, size_t n) {
    size_t i,j;
    int flag = 1;
    while (flag) {
        flag = 0;
        for(j=0;j<n-1;j++) {
            if(arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
                flag = 1;
            }
        }
    }
    return 0;
}

int-bubble\u排序（int*arr，size\t n）{
尺寸i，j；
int标志=1；
while（旗帜）{
flag=0；
对于（j=0；j arr[j+1]）{
内部温度=arr[j]；
arr[j]=arr[j+1]；
arr[j+1]=温度；
flag=1；
}
}
}
返回0；
}

---

通过仅在实际交换发生时设置标志，当您处于一般情况下时，您将更快地跳出循环。

N-1也可以。正如您所描述的，最坏的情况需要N-1交换（因为最后一个必须成为第一个，反之亦然）。如果将i变量的打印添加到If语句的内部，您将看到在上一次迭代中从未调用过它。这意味着循环的最后一次迭代不会导致任何交换

不过，Bubblesort更高效的实现并不使用for循环作为外部循环。看看下面的代码。你能看到执行的不同吗

int bubble_sort(int *arr, size_t n) {
    size_t i,j;
    int flag = 1;
    while (flag) {
        flag = 0;
        for(j=0;j<n-1;j++) {
            if(arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
                flag = 1;
            }
        }
    }
    return 0;
}

int-bubble\u排序（int*arr，size\t n）{
尺寸i，j；
int标志=1；
while（旗帜）{
flag=0；
对于（j=0；j arr[j+1]）{
内部温度=arr[j]；
arr[j]=arr[j+1]；
arr[j+1]=温度；
flag=1；
}
}
}
返回0；
}

---

如果只在实际交换发生时设置标志，那么在一般情况下，您将很快跳出循环。

不，没有这样的输入

理性是在泡沫排序的证明。回想一下，当证明在冒泡排序的第次（外部）迭代中，

i

最后的元素已就位并排序时

因此，在

n-1

迭代之后，最后的

n-1

元素就位并排序，只剩下剩余的第一个元素-它只能位于正确的位置，即数组中的第一个位置

（因此，使用这种方法，我们可以证明冒泡排序最多需要

n-1

外部迭代）

---

---

还要注意：经典的冒泡排序只需要内部循环中的

n-i

迭代（因为我上面提到的rational），而不是

n-1

否，没有这样的输入

理性是在泡沫排序的证明。回想一下，当证明在冒泡排序的第次（外部）迭代中，

i

最后的元素已就位并排序时

因此，在

n-1

迭代之后，最后的

n-1

元素就位并排序，只剩下剩余的第一个元素-它只能位于正确的位置，即数组中的第一个位置

（因此，使用这种方法，我们可以证明冒泡排序最多需要

n-1

外部迭代）

---

---

还要注意：经典冒泡排序只需要内环中的

n-i

迭代（因为我上面提到的rational），而不是

n-1
注意经典冒泡排序的内环有n-i次迭代，而不是n-1次。注意经典冒泡排序的内环有n-i次迭代，而不是n-1次。是的，我已经做到了。。。。这就是为什么我想找到真正的冒泡排序和有效的比较当从复杂性的角度进行比较时，你会发现最坏的情况是相同的（加上或减去几个常数），而最好的情况更好（n而不是n^2）通过一个常数因子，平均情况更好。最坏情况需要n-1次迭代这一事实本身并不足以使声明正确。然而，这个说法是正确的，人们可以正式证明它（我试图在我的回答中提供如何证明它的指南）。是的，我已经这样做了。。。。这就是为什么我想找到真正的冒泡排序和有效的比较当从复杂性的角度进行比较时，你会发现最坏的情况是相同的（加上或减去几个常数），而最好的情况更好（n而不是n^2）通过一个常数因子，平均情况更好。最坏情况需要n-1次迭代这一事实本身并不足以使声明正确。然而，这个说法是正确的，人们可以正式地证明它（我试图在我的答案中提供如何证明它的指南）。需要注意的是，您必须从0迭代到n-I，而不是从I迭代到n-1（这两个都是n-I迭代）。需要注意的是，您将