package oop;

import java.util.Arrays;

public class SortDemo {

        /**
         * @param args
         */
        public static void main(String[] args) {
                int [] array=new int[]{3,19,5,6,8};
                /*Arrays.sort(array);
                for (int i = 0; i < array.length; i++) {
                        System.out.println(array[i]);
                }
                System.out.println(array[0]);
                System.out.println(array[array.length-1]);*/
                //冒泡排序
                for (int i = 0; i < array.length-1; i++) {
                        for (int j = i,t=i+1; j < array.length; j++,t++) {
                                if(t<array[j])
                                {
                                        int temp=array[i];
                                        array[i]=array[j];
                                        array[j]=temp;
                                }
                        }
                }
                for (int i = 0; i < array.length; i++) {
                System.out.println(array[i]);       
                                }
                //下面是增强for
//                for(int a:array)
//                {
//                        System.out.println(a);
//                }
        }
       

}

lz的代码比较卖萌
请用下面代码替换对应位置
//冒泡排序
        for (int i = 0; i < array.length-1; i++) {
                for (int j = array.length -1,t=j-1; t>=0; j--,t--) {
                        if(array[t]<array[j])
                        {
                                int temp=array[t];
                                array[t]=array[j];
                                array[j]=temp;
                        }
                }
        }
-----------以下是解释------------
1.lz的外层循环是从0开始的，后面又将两两比较的结果存到外层循环对应的角标处，也就是说，你外层每一轮走完，冒出的大泡或小泡（最大值最小值）会往数组前面排。
2.结果网数组前面排就意味着你的泡应该从后向前冒！否则，数组前面保存的是最值（不管是最大还是最小），第一轮比完后，你用最值套用比较出了最值的规则进行后面轮次的排序，最终结果只能是数组中全是同一个最值。
3.内层for循环中，if语句的条件，你在用数组的一个索引同数组的一个元素进行比较？？？有什么意义吗
不是应该用相邻的两个元素的值进行比较吗
4.上面那点出了问题下面当然出问题，冒泡排序是内层相邻的两个元素之间比较交换，lz跟外层交换作甚？

综上，以我个人观点，lz对于冒泡的思路较为混乱，建议先抛开代码，理清思路再说。

楼主写的比较麻烦，下面是我写的，楼主可以看看

1. public class SortDemo {
   
2.         public static void main(String[] args) {
   
3.                 int [] array=new int[]{3,19,5,6,8};
   
4.                 sort(array);
   
5.                  //打印数组
   
6.                 for (int i : array) {
   
7.                         System.out.println(i);
   
8.                 }
   
9.         }
   
10.         //冒泡排序
    
11.         private static void sort(int[] array) {
    
12.                 for (int i = array.length-1; i >0; i--) {
    
13.                         for (int j = 0; j < i; j++) {
    
14.                                 //当 当前数大于下一位数时 条换位置
    
15.                                 if(array[j]>array[j+1]){
    
16.                                         //位置调换
    
17.                                         int temp=array[j];
    
18.                                         array[j]=array[j+1];
    
19.                                         array[j+1]=temp;
    
20.                                 }
    
21.                         }
    
22.                 }
    
23.         }
    
24. }

复制代码

yqj 发表于 2014-7-29 13:31
楼主写的比较麻烦，下面是我写的，楼主可以看看

你的简单在了那里？感觉就是把lz的代码改了然后删掉了注释。

zeus00456 发表于 2014-7-29 13:55
你的简单在了那里？感觉就是把lz的代码改了然后删掉了注释。

咋们的思路是不一样的，我的思路是先秒泡将最大的值（或最小值）放在数组的末尾，所以第一次循环array.length-1次，然后用同样的方法排序剩下的array.length-2次，依次将冒泡的最大值往数组的末尾放

ls的代码我看了好久才看懂，楼上的思路是把最大的值（或最小值）往最前面放，会发现外循环是四次，内循环没次也是四次，所以共运行16，效率会比较低，因为第一次运行时最大的值（或最小值）已经在开头了，所以下一次只需对剩下的数排序就ok了，内循环 for (int j = array.length -1,t=j-1; t>=0; j--,t--) 改为for (int j = array.length -1,t=j-1; t>=i; j--,t--)效率会增加（只运行10次）

希望我的回答对楼主有用！

谢谢了

把for循环改成这样呢？

1. for(int x=0;x<arr.length-1;x++)
   
2.                 {
   
3.                         for(int y=0;y<arr.length-x-1;y++)
   
4.                         {
   
5.                                 if(arr[y]>arr[y+1])
   
6.                                 {
   
7.                                         int temp=arr[y];
   
8.                                         arr[y]=arr[y+1];
   
9.                                         arr[y+1]=temp;
   
10.                                 }
    
11.                         }
    
12.                 }

复制代码