错误气泡排序（递归）Java中的整数数组

正在尝试实现递归方法对整数数组进行排序：

    public static void bubbleSort(int[] arr, int n){

      int index = n-1;

      System.out.println("Round number: " + n);
      System.out.println(Arrays.toString(arr));

      while(index>=1)
      {
          if(arr[index] <  arr[index-1])
              swap(arr, index, index-1);


          index--;
      }
      if(n>1)
          bubbleSort(arr, n-1);
  }

publicstaticvoidbubblesort（int[]arr，int n）{
int指数=n-1；
System.out.println（“整数：+n”）；
System.out.println（Arrays.toString（arr））；
而（索引>=1）
{
if（arr[index]1）
气泡运动（arr，n-1）；
}

}

---

在最初的几轮中，它似乎工作得很好，将集合中最小的整数移动到前面，但它只是在中途停止工作。知道为什么吗？谢谢

算法每次都将最小值移动到数组的开头，然后在后续调用中忽略最后一个元素。不幸的是，最后一个元素不能保证是最大的

---

解决此问题的一种方法可能是将

索引初始化为
arr.length-1
，并在
索引>arr.length-n
时继续循环
 算法每次都将最小值移动到数组的开头，然后在后续调用中忽略最后一个元素。不幸的是，最后一个元素不能保证是最大的

解决此问题的一种方法可能是将
索引初始化为
arr.length-1
，并在
索引>arr.length-n
时继续循环
 将
if
条件更改为：

...
if(arr[index] <  arr[index-1]){
   swap(arr, index, index-1);
   index = n;
}
index--;
...

。。。
if（arr[index]

问题是，在找到要在整个阵列中“委派”的阵列成员后，您需要“重新启动”，因为可能还有其他成员需要“重新考虑”。
使用调试器运行，如果我的描述不够清楚，请查看我的意思

完整解决方案：

import java.util.Arrays;

/**
 * User: alfasin
 * Date: 8/5/13
 */
public class BubbleSort {

    public static void bubbleSort(int[] arr, int n){

        int index = n-1;

        System.out.println("Round number: " + n);
        System.out.println(Arrays.toString(arr));

        while(index>=1)
        {
            if(arr[index] <  arr[index-1]){
                swap(arr, index, index-1);
                index = n;
            }
            index--;
        }
        if(n>1)
            bubbleSort(arr, n-1);
    }

    private static void swap(int[] arr, int index, int i) {
        arr[i] = arr[i] ^ arr[index];
        arr[index] = arr[i] ^ arr[index];
        arr[i] = arr[i] ^ arr[index];
    }

    public static void main(String...args){
        int[] arr = {4,2,9,6,2,8,1};
        bubbleSort(arr, arr.length);
        for(int i=0; i<arr.length; i++){
            System.out.print(arr[i]+" ");
        }
    }

}

导入java.util.array；
/**
*用户：阿尔法辛
*日期：2013年8月5日
*/
公共类泡泡糖{
公共静态void bubbleSort（int[]arr，int n）{
int指数=n-1；
System.out.println（“整数：+n”）；
System.out.println（Arrays.toString（arr））；
而（索引>=1）
{
if（arr[index]1）
气泡运动（arr，n-1）；
}
私有静态无效交换（int[]arr，int索引，int i）{
arr[i]=arr[i]^arr[index]；
arr[index]=arr[i]^arr[index]；
arr[i]=arr[i]^arr[index]；
}
公共静态void main（字符串…参数）{
int[]arr={4,2,9,6,2,8,1}；
气泡运动（arr，arr.length）；
对于（int i=0；i将
if
条件更改为：

...
if(arr[index] <  arr[index-1]){
   swap(arr, index, index-1);
   index = n;
}
index--;
...

。。。
if（arr[index]

问题是，在找到要在整个阵列中“委派”的阵列成员后，您需要“重新启动”，因为可能还有其他成员需要“重新考虑”。
使用调试器运行，如果我的描述不够清楚，请查看我的意思

完整解决方案：

import java.util.Arrays;

/**
 * User: alfasin
 * Date: 8/5/13
 */
public class BubbleSort {

    public static void bubbleSort(int[] arr, int n){

        int index = n-1;

        System.out.println("Round number: " + n);
        System.out.println(Arrays.toString(arr));

        while(index>=1)
        {
            if(arr[index] <  arr[index-1]){
                swap(arr, index, index-1);
                index = n;
            }
            index--;
        }
        if(n>1)
            bubbleSort(arr, n-1);
    }

    private static void swap(int[] arr, int index, int i) {
        arr[i] = arr[i] ^ arr[index];
        arr[index] = arr[i] ^ arr[index];
        arr[i] = arr[i] ^ arr[index];
    }

    public static void main(String...args){
        int[] arr = {4,2,9,6,2,8,1};
        bubbleSort(arr, arr.length);
        for(int i=0; i<arr.length; i++){
            System.out.print(arr[i]+" ");
        }
    }

}

导入java.util.array；
/**
*用户：阿尔法辛
*日期：2013年8月5日
*/
公共类泡泡糖{
公共静态void bubbleSort（int[]arr，int n）{
int指数=n-1；
System.out.println（“整数：+n”）；
System.out.println（Arrays.toString（arr））；
而（索引>=1）
{
if（arr[index]1）
气泡运动（arr，n-1）；
}
私有静态无效交换（int[]arr，int索引，int i）{
arr[i]=arr[i]^arr[index]；
arr[index]=arr[i]^arr[index]；
arr[i]=arr[i]^arr[index]；
}
公共静态void main（字符串…参数）{
int[]arr={4,2,9,6,2,8,1}；
气泡运动（arr，arr.length）；
对于（int i=0；i请尝试以下方法：

import java.util.*;

public class Test{
    public static void main(String[] args){
        int[] ttt = {9,8,7,6,5,4,3,2,1};

        bubbleSort(ttt, ttt.length);
    }

    public static void bubbleSort(int[] arr, int n){
        int index = 0;

        System.out.println("Round number: " + n);
        System.out.println(Arrays.toString(arr));

        while(index < n - 1){
            if(arr[index] >  arr[index + 1]){
                swap(arr, index, index + 1);
            }
            index++;
        }

        if(n > 1){
            bubbleSort(arr, n-1);
        }
    }

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

import java.util.*；
公开课考试{
公共静态void main（字符串[]args）{
int[]ttt={9,8,7,6,5,4,3,2,1}；
气泡运动（ttt，ttt.长度）；
}
公共静态void bubbleSort（int[]arr，int n）{
int指数=0；
System.out.println（“整数：+n”）；
System.out.println（Arrays.toString（arr））；
而（指数arr[index+1]）{
掉期（arr、指数、指数+1）；
}
索引++；
}
如果（n>1）{
气泡运动（arr，n-1）；
}
}
公共静态无效交换（int[]arr，int i，int j）{
int tmp=arr[i]；
arr[i]=arr[j]；
arr[j]=tmp；
}
}

在每一轮中，你保证在每一轮结束时，你将有最小的数字被推到它的位置，但然后省略数组的最后一个元素，它不一定是最大的数字。你应该按相反的顺序进行，将最大的数字推到它的位置，然后在下一轮中忽略它


仅供参考：冒泡排序的最坏情况性能是O（n^2），也许您希望实现更好的排序算法，如快速排序或合并排序？
尝试以下方法：

import java.util.*;

public class Test{
    public static void main(String[] args){
        int[] ttt = {9,8,7,6,5,4,3,2,1};

        bubbleSort(ttt, ttt.length);
    }

    public static void bubbleSort(int[] arr, int n){
        int index = 0;

        System.out.println("Round number: " + n);
        System.out.println(Arrays.toString(arr));

        while(index < n - 1){
            if(arr[index] >  arr[index + 1]){
                swap(arr, index, index + 1);
            }
            index++;
        }

        if(n > 1){
            bubbleSort(arr, n-1);
        }
    }

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

import java.util.*；
公开课考试{
公共静态void main（字符串[]args）{
int[]ttt={9,8,7,6,5,4,3,2,1}；
气泡运动（ttt，ttt.长度）；
}
公共静态void bubbleSort（int[]arr，int n）{
int指数=0；
System.out.println（“整数：+n”）；
System.out.println（Arrays.toString（arr））；
而（指数arr[index+1]）{
掉期（arr、指数、指数+1）；
}
索引++；
}
如果（n>1）{
气泡运动（arr，n-1）；
}
}
公共静态无效交换（int[]arr，int i，int j）{
int tmp=arr[i]；
arr[i]=arr[j]；
arr[j]=tmp；
}
}