黑马程序员技术交流社区

标题: 冒泡排序 [打印本页]
作者: 王石    时间: 2014-7-28 21:07
标题: 冒泡排序
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);
//                }
        }
       

}
作者: zeus00456    时间: 2014-7-29 08:56
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对于冒泡的思路较为混乱，建议先抛开代码，理清思路再说。
作者: yqj    时间: 2014-7-29 13:31
楼主写的比较麻烦，下面是我写的，楼主可以看看
  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. }
复制代码

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

你的简单在了那里？感觉就是把lz的代码改了然后删掉了注释。
作者: yqj    时间: 2014-7-29 14:59
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次）

希望我的回答对楼主有用！
作者: 王石    时间: 2014-7-30 02:04
谢谢了
作者: yueyouqiang    时间: 2014-7-30 13:16
把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.                 }
复制代码




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2