使用 while 语句时的冒泡排序答案

【问题标题】：Bubble sort while using a while statement使用 while 语句时的冒泡排序
【发布时间】：2015-03-02 19:22:49
【问题描述】：

我必须编写代码来对一些数字进行排序，虽然我决定使用“for”而不是“while”，但我想知道它为什么会这样。它正在对所有内容进行排序，但它会将 14 留在原处，如果有人能解释一下，那将非常感激

public class SortForMe {

public static void main(String args[]) {
int ListOfNumbers[] = {16, 100, 205, 8, 1, 3, 2, 5, 7, 6, 15, 10, 14};
int Length = ListOfNumbers.length;
int Sorted = 1;
int T;
int Order = 0;
System.out.println("Given number :");
while(Order < Length) {
  System.out.println("  " + ListOfNumbers[Order]);
  Order++;
                     }
System.out.println("\n");
System.out.println("After Sort:");
while (Sorted < Length) {
  while (Order < Length - Sorted) {
    if (ListOfNumbers[Order] > ListOfNumbers[Order + 1]) {
      int temp = ListOfNumbers[Order];
      ListOfNumbers[Order] = ListOfNumbers[Order + 1];
        ListOfNumbers[Order + 1] = temp;
    }
    Order++;
  }
  Order = 0;
  Sorted++;

}
while(Order < Length) {
  System.out.println(ListOfNumbers[Order]);
  Order++;
}
}
}

【问题讨论】：

你只需要一个循环，所以 int Sorted = 0;

标签： arrays sorting while-loop bubble-sort

【解决方案1】：

您的实现看起来有点复杂。我建议您重构并将排列代码放在单独的方法中，以使其更具可读性。此外，您应该在每次迭代时检查是否有任何排列。如果没有排列，则完成。否则你应该再次迭代。通过一些重构，事情变得更简单了。

这是我根据您的输入完成并测试的一个实现

这个 `simpleBublleSort' 方法依赖于一个 swap 方法和一个 printArray 方法（见下文）

 public  void simpleBubbleSort(int[] datas)
 {
     boolean stillHasDisorder = false;
     do
     {
         stillHasDisorder = false;

         for (int i = 0; i <= datas.length - 2; i++)
         {
             if (new Integer(datas[i]).compareTo(new Integer(datas[i+1])) < 0)
             {
                 swap(datas,i, i + 1);
                 stillHasDisorder = true;


             }

         }

         printArray(datas);

     } while (stillHasDisorder);


 }

交换方法与交换两个比较元素的方法相同

 public void swap(int[] datas, int position1, int position2)
 {
     int temp = datas[position1];
     datas[position1] = datas[position2];
     datas[position2] = temp;
 }

printArray 可以在每次迭代后很好地打印数组，这样我们就可以直观地看到发生了什么

 public void swap(int[] datas, int position1, int position2)
 {
     int temp = datas[position1];
     datas[position1] = datas[position2];
     datas[position2] = temp;
 }

这是一个使用您的输入数据的演示代码

 public static void doDemo() {
     
     int[] datas = {16, 100, 205, 8, 1, 3, 2, 5, 7, 6, 15, 10, 14};
     (new BubbleSort()).simpleBubbleSort(datas);
 }
 
 public static void main(String[] args) {
     doDemo();
     
 }

结果如下：

[100 205 16 8 3 2 5 7 6 15 10 14 1 ]

[205 100 16 8 3 5 7 6 15 10 14 2 1]

[205 100 16 8 5 7 6 15 10 14 3 2 1]

[205 100 16 8 7 6 15 10 14 5 3 2 1]

[205 100 16 8 7 15 10 14 6 5 3 2 1]

[205 100 16 8 15 10 14 7 6 5 3 2 1]

[205 100 16 15 10 14 8 7 6 5 3 2 1]

[205 100 16 15 14 10 8 7 6 5 3 2 1]

[205 100 16 15 14 10 8 7 6 5 3 2 1]

当然，您可以通过将比较更改为>0 而不是<0 来使其升序

【讨论】：

【解决方案2】：

那是因为你在第一个循环中使用了变量Order 来显示数组的初始状态。

当它用于内部循环时，它已经在数组的末尾，所以在第一次迭代中没有任何排序。 Sorted 变量增加，最后一项未排序。

在显示初始状态的循环和进行排序的循环之间插入一个Order = 0;。

旁注：冒泡排序缺少一些东西。它应该检查内部循环中是否进行了任何交换。如果没有，则排序完成，可以退出外循环。

【讨论】：