Question

int i, j, temp, size = 4;
int[] bar= {6, 4, 7, 1};
for(i=0; i< size - 1; i++){
  for(j=i; j< size; j++) {
    if(bar[j] < bar[i]){
      temp = bar[j];
      bar[j] = bar[i];
      bar[i] = temp;
    }
  }
}

请帮助我理解这一点。它是如何准确地排序这些数字。我很困惑。

如果你想知道，在我正在做的程序中，在这个循环的第一个输出中，数字分别为1,6,7,4。所以请帮助我解释它是如何排序的！喜欢一步一步！谢谢！

Answer 1

所以，这很容易。

您的初始数组看起来像{6,4,7,1}。

i = 0。
j = i = 0。
将0元素与0元素进行比较，因此将6与6进行比较。它们是相同的，什么都不做。
J ++; j = 1。
将1元素与0元素进行比较，因此将4与6进行比较，4比较小，交换它们，数组现在看起来像{4,6,7,1}。
J ++; j = 2。
将2元素与0元素进行比较，因此将7与4进行比较.7更大，什么都不做。
J ++; j = 3。
将3元素与0元素进行比较，因此将1与4进行比较，1表示较小，交换它们，数组现在看起来像{1,6,7,4}。所以它与您第一次完成内部循环时所描述的完全相同。
我++; i = 1。
j = i = 1。
等等......

Answer 2

这绝对是泡泡排序：

开始数组： {6,4,7,1}

索引号： 6 = bar [0]，4 = bar [1]，7 = bar [2]，1 = bar [3]

第1步：

i = 0，j = 0，bar [i] = 6，bar [j] = 6

if(bar[j] < bar[i]) {...} // condition is not true so nothing happens

你的阵列： {6,4,7,1}

将 j 增加1。

第2步：

i = 0，j = 1，bar [i] = 6，bar [j] = 4

if(bar[j] < bar[i]) // condition is true, if loop starts
{
    temp = bar[j]; // bar[j] value is 4, temp value is now 4
    bar[j] = bar[i]; // bar[i] value is 6, bar[j] value is now 6
    bar[i] = temp; // temp value is 4, bar[i] value is now 4
}

结果： bar [i] = 4，bar [j] = 6 - 正如您所看到的那样，交换了值，这就是所有这一循环。

你的阵列： {4,6,7,1}

将 j 增加1。

第3步：

i = 0，j = 2，bar [i] = 4，bar [j] = 7

if(bar[j] < bar[i]) {...} // condition is not true so nothing happens

你的阵列： {4,6,7,1}

将j增加1。

第4步：

i = 0，j = 3，bar [i] = 4，bar [j] = 1

if(bar[j] < bar[i]) // condition is true, if loop starts
{
    temp = bar[j]; // bar[j] value is 1, temp value is now 1
    bar[j] = bar[i]; // bar[i] value is 4, bar[j] value is now 4
    bar[i] = temp; // temp value is 1, bar[i] value is now 1
}

结果： bar [i] = 1，bar [j] = 4

你的阵列： {1,6,7,4}

将 j 增加1。

由于j值现在为4且且for循环中的大小为4（j

第5步：

将 i 增加1。

i = 1，j = 1，bar [i] = 6，bar [j] = 6

if(bar[j] < bar[i]) {...} // condition is not true so nothing happens

你的阵列： {1,6,7,4}

将 j 增加1。

第6步：

i = 1，j = 2，bar [i] = 6，bar [j] = 7

if(bar[j] < bar[i]) {...} // condition is not true so nothing happens

你的阵列： {1,6,7,4}

将 j 增加1。

第7步：

i = 1，j = 3，bar [i] = 6，bar [j] = 4

if(bar[j] < bar[i]) // condition is true, if loop starts
{
    temp = bar[j]; // bar[j] value is 4, temp value is now 4
    bar[j] = bar[i]; // bar[i] value is 6, bar[j] value is now 6
    bar[i] = temp; // temp value is 4, bar[i] value is now 4
}

结果： bar [i] = 4，bar [j] = 6

您的阵列： {1,4,7,6}

将 j 增加1。

j的值再次超过大小，外循环最后一次启动。

第8步：

i = 2，j = 2，bar [i] = 7，bar [j] = 7

if(bar[j] < bar[i]) {...} // condition is not true so nothing happens

您的阵列： {1,4,7,6}

将 j 增加1。

第9步：

i = 2，j = 3，bar [i] = 7，bar [j] = 6

if(bar[j] < bar[i]) // condition is true, if loop starts
{
    temp = bar[j]; // bar[j] value is 6, temp value is now 6
    bar[j] = bar[i]; // bar[i] value is 7, bar[j] value is now 7
    bar[i] = temp; // temp value is 6, bar[i] value is now 6
}

结果： bar [i] = 6，bar [j] = 7

您的阵列： {1,4,6,7}

在下一步中，j超出了大小值，因此内部循环中断，i值超过size-1，因此外部for循环中断。程序已结束，数组值现在从最小数字到最大数字排序。

<强>奖金：

如果你注意到，当你内心的我等于 j 时，总会迈出一步for循环并且该步骤是不必要的，因为您要将数组中的数字与其自身进行比较。将内循环条件从for(j=i; j< size; j++)更改为for(j=i+1; j< size; j++)，步数将大大减少。

我希望你现在能理解冒泡排序。如果您有任何其他问题，请随时询问。

Answer 3

由于其他答案已经告知了您的算法的逐步分析，所以没有必要一步一步地去。

简而言之，它的作用是在每个循环中找到最小值范围[i，n]（通过比较每个元素在位置i的值并将其中的最小值放在位置i），并且过程一直持续到最后一个元素。

因此，对于您的情况，即：-6,4,7,1

在第一次迭代后输出将是1,6,7,4（1是范围i [1,4]中的最小值）

在第二次迭代后输出将是1,4,7,6（4是范围i [2,4]中的最小值）

在第3次迭代后输出为1,4,6,7（6为范围i [1,4]中的最小值）

有关详细信息，您可以看到这种形式的buuble sort http://www.cs.oswego.edu/~mohammad/classes/csc241/samples/sort/Sort2-E.html

Answer 4

谷歌冒泡排序。看看这里，例如：http://www.algolist.net/Algorithms/Sorting/Bubble_sort

我如何理解这种排序？

4 个答案: