java中从最高到最低的冒泡排序

Question

我正在寻找与我在互联网上搜索时看到的通常情况相反的 java 中的冒泡排序代码。 我不太明白下面的代码，我只知道它把一堆数字从低到高排序。下面的代码是否可修改，而不是输出从最低到最高的数字。它从最高到最低输出它？

int i;
    int array[] = {12,9,4,99,120,1,3,10};
    System.out.println("Values Before the sort:\n");
    for(i = 0; i < array.length; i++)
      System.out.print( array[i]+"  ");
    System.out.println();
    bubble_srt(array, array.length);
    System.out.print("Values after the sort:\n");
    for(i = 0; i <array.length; i++)
      System.out.print(array[i]+"  ");
    System.out.println();
    System.out.println("PAUSE");
  }

  public static void bubble_srt( int a[], int n ){
    int i, j,t=0;
    for(i = 0; i < n; i++){
      for(j = 1; j < (n-i); j++){
        if(a[j-1] > a[j]){
          t = a[j-1];
          a[j-1]=a[j];
          a[j]=t;
        }
      }
    }
  }

Answer 1

改变

if(a[j-1] > a[j]){

到

if(a[j-1] < a[j]){

Answer 2

for(i = array.length -1; i >=0; i--)
{
System.out.println(array[i]);
}

应该可以。你从数组的末尾开始往回走

Answer 3

您可以更改冒泡排序以满足您的需求，或者保持原样并向后遍历排序数组。对于两者，您应该尝试理解这样一小段代码，而不是简单地要求修改后的代码。

Answer 4

关于您的代码的一些话：

如果您将交换方法移出内部循环，则它的可读性更高，并且更容易推理独立部分。

public void swap (int i, int j, int [] arr) {
    int tmp = arr [i];
    arr [i] = arr [j];
    arr [j] = tmp;
}

可爱的小方法易于理解和测试，这一点很重要。

不要在 for 之外声明索引变量。这使得你的代码更难推理——变量在循环之外是可见的。在旧代码中，在内循环之外声明 tmp 没有任何好处。声明在运行时是免费的。

public static void bubbleSort (int a[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 1; j < (n-i); j++) {
            if (a[j-1] > a[j]) {
                swap (j, j-1, a);
            }
        }
    }
}

    // ... missing ...

不要重复自己。将重复的代码移动到方法中。

public static void show (int [] arr)
{
    for (int i : arr) 
        System.out.print (i + " ");
    System.out.println ();
}

可爱的小方法很容易测试。尽可能使用简化的 for 循环，以避免一次错误，并且对代码更改更加健壮 - 例如，它们也适用于列表。

    int array[] = {12, 9, 4, 99, 120, 1, 3, 10};
    System.out.println ("Values Before the sort:\n");
    show (array);
    bubbleSort (array, array.length);
    System.out.print ("Values after the sort:\n");
    show (array);
    System.out.println ("PAUSE");
}

使用简化的代码，更容易推断出哪个部分的作用。

if (a[j-1] > a[j]) {

只需要改变

if (a[j-1] < a[j]) {

颠倒顺序。