按冒泡排序的算法输出的结果应该是
[1，2，55，151，2，585，151，5155]
可是这个程序执行后的结果是
排序前[1, 2, 55, 585, 151, 2, 5155, 151]
排序后[1, 5155, 2, 55, 151, 2, 585, 151]
哪里出问题了，还是我理解错了？求解

1. 
   
2. public class List2{
   
3. public static void bubbleSort(int[] arr){//冒泡排序
   
4.                         for(int i=0;i<arr.length-1;i++){
   
5.                                 for(int j=0;i<arr.length-1;i++){
   
6.                                         if(arr[i]>arr[j+1]){
   
7.                                                 int temp=arr[i];
   
8.                                                 arr[i]=arr[j+1];
   
9.                                                 arr[j+1]=temp;
   
10.                                         }
    
11.                                        
    
12.                                 }
    
13.                                 
    
14.                         }
    
15.                
    
16.                 }
    
17. public static void main(String[] args){
    
18.         int[] arr={1,2,55,585,151,2,5155,151};
    
19.         System.out.print("排序前");
    
20.         printArray(arr);
    
21.         bubbleSort(arr);
    
22.         System.out.print("排序后");
    
23.         printArray(arr);
    
24.         
    
25. }
    
26.         
    
27. public static void printArray(int[] arr){
    
28.         System.out.print("[");
    
29.         for(int i=0;i<arr.length;i++){
    
30.                 if(i!=arr.length-1)
    
31.                         System.out.print(arr[i]+", ");
    
32.                 else
    
33.                         System.out.println(arr[i]+"]");
    
34.         }
    
35. }
    
36. }
    

复制代码

关于错误，前面几位已经解释很详细了，我就不多说了，下面给你总结下几种常见的简单排序算法吧，希望你能用到
    冒泡排序：定义两个for循环，比较相邻元素，前者比后者大就交换相邻元素
*选择排序：定义初始最小项，比较找出最小项，然后进行交换
*插入排序：将一个记录插入到已经排序好的有序表中，从而得到一个新的，记录数增一的有序表。
*                定义两个for循环，以第一个记录为已经排好的有序表，然后逐渐排序后面的记录。

1. public class Test {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 int[] a = { 3, 5, 1, 56, 3, 15, 7, 0, 1 };
   
5.                 System.out.print("原有数组：");
   
6.                 print(a);
   
7.                 xuanZe(a);
   
8.                 System.out.print("选择排序：");
   
9.                 print(a);
   
10.                 maoPao(a);
    
11.                 System.out.print("冒泡排序：");
    
12.                 print(a);
    
13.                 chaRu(a);
    
14.                 System.out.print("插入排序：");
    
15.                 print(a);
    
16. 
    
17.         }
    
18. //插入排序
    
19.         private static void chaRu(int[] a) {
    
20.                 for (int i = 1; i < a.length; i++) {
    
21.                         for (int j = i; j > 0; j--) {
    
22.                                 if (a[j] < a[j - 1]) {
    
23.                                         jiaohuan(a, j, j - 1);
    
24.                                 }
    
25.                         }
    
26.                 }
    
27.         }
    
28. //打印数组
    
29.         private static void print(int[] a) {
    
30.                 for (int i : a) {
    
31.                         System.out.print(i + "   ");
    
32.                 }
    
33.                 System.out.println();
    
34.         }
    
35. //冒泡排序
    
36.         private static void maoPao(int[] a) {
    
37.                 for (int i = 0; i < a.length; i++) {
    
38.                         for (int j = i + 1; j < a.length; j++) {
    
39.                                 if (a[i] > a[j]) {
    
40.                                         jiaohuan(a, i, j);
    
41.                                 }
    
42.                         }
    
43.                 }
    
44.         }
    
45. //交换数组元素
    
46.         private static void jiaohuan(int[] a, int i, int j) {
    
47.                 int temp;
    
48.                 temp = a[i];
    
49.                 a[i] = a[j];
    
50.                 a[j] = temp;
    
51.         }
    
52. //选择排序
    
53.         private static void xuanZe(int[] a) {
    
54.                 for (int i = 0; i < a.length - 1; i++) {
    
55.                         int min = i;
    
56.                         for (int j = i + 1; j < a.length; j++) {
    
57.                                 if (a[min] > a[j]) {
    
58.                                         min = j;
    
59.                                 }
    
60.                         }
    
61.                         if (min != i) {
    
62.                                 jiaohuan(a, min, i);
    
63.                         }
    
64. 
    
65.                 }
    
66. 
    
67.         }
    
68. }
    

复制代码

我分析总结了一下冒泡排序的思想，你参考一下，希望对你有所帮助！
/*冒泡排序
        分析：A：外循环控制比较次数，范围是数组元素个数-1次。
                  B：内循环范围是arr.length-1-i,因为内循环每比较完一次，会生成一个最大值放在最后面。
                        （跟冒泡一样，越往后越大）
                  C：最大值已经放在了最后面，那么再次内循环遍历的时候只需要遍历前面的元素就可以了，
                     所以需要arr.length-1-i。
                  D：最后循环内就是元素置换了。
*/
public static void bubbleSort(int[] arr){
        for(int i=0;i<arr.length-1;i++){        //外循环
                 for(int j=0;j<arr.length-1-i;j++){                //内循环判断条件：j<arr.length-1-i       
                         if(arr[j]>arr[j+1]){                //判断，大的往后排，置换。
                                 int temp=arr[j];
                 arr[j]=arr[j+1];
                 arr[j+1]=temp;
                         }
                }                                
    }
}

1. 
   
2. public class List2{
   
3. public static void bubbleSort(int[] arr){//冒泡排序
   
4.                         for(int i=0;i<arr.length-1;i++){
   
5.                                 for(int j=0;i<arr.length-1;i++){//这一行的i应该改为j.然后就是这一行的条件要变成                                                                                                                      //                                                                              arr.length-1-i
   
6.                                         if(arr[i]>arr[j+1]){
   
7.                                                 int temp=arr[i];//i应该是j
   
8.                                                 arr[i]=arr[j+1];
   
9.                                                 arr[j+1]=temp;
   
10.                                         }
    
11.                                        
    
12.                                 }
    
13.                                 
    
14.                         }
    
15.                
    
16.                 }
    
17. public static void main(String[] args){
    
18.         int[] arr={1,2,55,585,151,2,5155,151};
    
19.         System.out.print("排序前");
    
20.         printArray(arr);
    
21.         bubbleSort(arr);
    
22.         System.out.print("排序后");
    
23.         printArray(arr);
    
24.         
    
25. }
    
26.         
    
27. public static void printArray(int[] arr){
    
28.         System.out.print("[");
    
29.         for(int i=0;i<arr.length;i++){
    
30.                 if(i!=arr.length-1)
    
31.                         System.out.print(arr[i]+", ");
    
32.                 else
    
33.                         System.out.println(arr[i]+"]");
    
34.         }
    
35. }
    
36. }
    

复制代码

楼主第5行代码 ：for(int j=0;i<arr.length-1;i++){
请问你的 j 不是恒等于 0 吗亲，你仔细想想哪里错了.
其实你把5.6.7.8.9代码里的 i 都改成j就对了

冒泡排序的过程如下：（从小到大）
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
public class Test
        {
        public static void main(String[] args)
                {
                         int[] arr  = {1,2,55,585,151,2,5155,151};
                         bubblesort(arr);
                         show(arr);
            }
        public static void bubblesort(int[] Arr)
                {
                        for(int i = 0;i<Arr.length-1;i++)
                                {
                                        for(int j = 0;j<Arr.length-i-1;j++)//内部循环的下标要比长度小一
                                                {
                                                        if(Arr[j]>Arr[j+1])
                                                                {
                                                                        Arr[j]=Arr[j+1]^Arr[j];//异或，不借助第三方变量，效率提高很多。
                                                                        Arr[j+1]=Arr[j+1]^Arr[j];
                                                                        Arr[j]=Arr[j+1]^Arr[j];
                                                                }
                                                }
                                }
                }
        public static void show(int[] arr)
                {
                        for (int i = 0; i < arr.length; i++)
                                        {
                                                System.out.print(arr[i]+" ");
                                                if ((i+1)%10==0)
                                                        {
                                                                System.out.print('\n');
                                                        }
                                        }
                }
   }

循环套循环。
for(int i=0;x<arr.length-1;i++){   //循环的趟数，就是总共循环几趟；
   for(int j=0;j<arr.length-1-i;j++){   //每趟循环的次数：次数的规律就是（arr.length-1-i）；
    if(arr[j]>arr[j+1]){
     int temp=arr[j];
     arr[j]=arr[j+1];
     arr[j+1]=temp;
    }
   }

1. public static void bubbleSort(int[] arr){//冒泡排序
   
2.                        /**************仔细看这里*********/
   
3.                         for(int i=0;i<arr.length-1;i++){
   
4.                                 for(int j=0;j<arr.length-i-1;j++){
   
5.                                         if(arr[j]>arr[j+1]){
   
6.                                                 int temp=arr[j];
   
7.                                                 arr[j]=arr[j+1];
   
8.                                                 arr[j+1]=temp;
   
9.                                         }
   
10.                                 }
    
11.                                 
    
12.                         }
    
13.                
    
14.                 }
    

复制代码

冒泡排序的主要思想是 把相邻的两个元素进行比较 楼主记住这点 判断语句里面的就不会写错了
至于你的内层循环... 我相信你是不小心...

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

要 j 和 j+1 相比较，

for(int i=0;x<arr.length-1;i++){
  for(int j=0;j<arr.length-1-i;j++){  
   if(arr[j]>arr[j+1]){
    int temp=arr[j];
    arr[j]=arr[j+1];
    arr[j+1]=temp;
   }
  }
}
要-i：就是减少每次的比较元素的意思。