冒泡排序Java不同的输出

Question

我遇到了一个非常混乱的情况，我编写了这个 BubbleSort 程序，它运行得很好。输出正确：

public class BubbleSortInput {

private static void Sorting(int[] intArray)
{
    int i, temp=0;
    int n = intArray.length;

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

public static void main(String[] args) {

    int array[] = {1,5,65,34,76,234};

    Sorting(array);
    for(int k = 0; k < array.length; k++)
    {
        System.out.println(array[k]);
    }
}
}

但是，我尝试在 main 方法中，在另一个类中编写基本相同的代码：

class BubbleSort {
public static void main(String[] args) {
   int numbers[] = {12,43,65,12,65,92,32,54};
   int i,temp=0;

    for(i=0; i < numbers.length-1; i++)
    {
        for(int j = 0; j < numbers.length-i-1; j++)
        {
            if(numbers[i]>numbers[i+1])
            {
                temp = numbers[i+1];
                numbers[i] = numbers[i+1];
                numbers[i]= temp;
            }
        }
    }

    for(i=0;i<numbers.length;i++)
    {
        System.out.println(numbers[i]);
    }
}
}

我在第二个文件上得到的输出完全错误，即使我使用了几乎相同的代码，有人可以解释一下吗？

Output: 

12
43
12
12
65
32
32
54

Answer 1

正如其他人指出的那样，您应该看看冒泡排序算法。提醒一下，在说明您的原始代码可以正常工作之前运行许多测试用例。为了清楚起见，第一个程序也给出了错误的输出。您可能为输入集获得的输出可能是正确的，但一开始就有点排序。尝试您在第二个程序中为您的第一个代码使用的输入集并找出错误。另外，看看您的 for 循环中的交换代码。

                temp = intArray[i+1];
                intArray[i] = intArray[i+1];
                intArray[i] = temp;

您正在将 [i+1] 位置的值分配给 temp。您再次将 [i+1] 处的值分配给位置 i。因此，位置 [i] 的值在此过程中丢失了。现在位置 [i] 和 [i+1] 的值相同。所以也要努力。

除此之外。在冒泡排序中，排序通过交换相邻元素来进行。所以在第一遍（升序排序）结束时，数组中最大的元素将在最后。这个过程一直持续到所有元素都被排序为止。

Example:
First Pass:
( 6 1 3 2 9 ) –> ( 1 6 3 2 9 ), Here, algorithm compares the first two elements, and swaps since 6 > 1.
( 1 6 3 2 9 ) –>  ( 1 3 6 2 9 ), Swap since 6 > 3
( 1 3 6 2 9 ) –>  ( 1 3 2 6 9 ), Swap since 6 > 2
( 1 3 2 6 9 ) –> ( 1 4 2 5 8 ), Now, since these elements are already in order (9 > 6), algorithm does not swap them.
Second Pass:
( 1 3 2 6 9 ) –> ( 1 3 2 6 9 )
( 1 3 2 6 9 ) –> ( 1 3 4 6 9 ), Swap since 3 > 2
( 1 2 3 5 9 ) –> ( 1 2 3 5 9 )
( 1 2 3 5 9) –>  (1 2 3 5 9 )
Now, the array is already sorted, but our algorithm does not know if it is completed. The algorithm needs one whole pass without any swap to know it is sorted.
Third Pass:
( 1 2 3 5 9 ) –> (1 2 3 5 9 )
( 1 2 3 5 9 ) –> ( 1 2 3 5 9 )
( 1 2 3 5 9 ) –> ( 1 2 3 5 9 )
( 1 2 3 5 9 ) –> ( 1 2 3 5 9 )

Answer 2

我认为您的冒泡排序代码不正确。这是你的循环：

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

请注意，您从不使用变量j。所以它所做的只是遍历数组，然后如果第一个元素大于第二个元素，则交换两个元素。您应该再次查看冒泡排序算法并重新编写代码。

Answer 3

您使用的排序逻辑不正确。

冒泡排序比较每对相邻的项目，如果它们的顺序错误（不是升序），则交换它们。 在第一遍（升序排序）结束时，数组中的最大元素将位于最后一个索引处。 在第二遍（升序排序）结束时，数组中的第二大元素将位于倒数第二个索引处，依此类推.....

请访问http://visualgo.net/sorting 以获得更好的理解。

因此，在您的代码中，您应该将项目与第二次初始化（在您的情况下为变量 j）进行比较。修改后应该是这样的：

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