黑马程序员技术交流社区

标题: 选择和冒泡 排序怎么输出的都是哈希地址值的问题？ [打印本页]
作者: 李志群    时间: 2012-7-10 19:48
标题: 选择和冒泡 排序怎么输出的都是哈希地址值的问题？
本帖最后由 李志群 于 2012-7-13 10:22 编辑

/*
需求分析：选择排序图示：
0-1 0-2 0-3 0-4 0-5
1-2 2-3 3-4 4-5
2-3 3-4 4-5
3-4 4-5
4-5
通过分析 可以看出是个倒三角形，我们可以用两个for循环嵌套的模式来打印出来

相比较的都是角标位。


*/
class  XZDemo
{        
        public static void paiqian(int[] arr)
                {
                        for(int x=0;x<arr.length;x++)
                        {
                                if(x!=arr.length-1)
                                System.out.print(arr[x]+",");
                                else
                                System.out.println(arr[x]);
                        }
               
                }
        public static void main(String[] args)
                        {
                                int[] arr={5,6,9,12,55,78,43};
               
                //System.out.println("qian=");
                                paiqian(arr);
                                pai(arr);
                                paiqian(arr);
                        }
public static void pai(int[] arr)
        {
        for(int x=0;x<arr.length-1;x++)
                {
                for(int y=x+1;y<arr.length;y++)
                   {
                        if(arr[x]>arr[y])
                                {
                                int temp=arr[x];
                                arr[x]=arr[y];
                                arr[y]=temp;
                                }
               
                        }
                 }
         }
}
这个可以 为什么？

/*0-1 1-2 2-3 3-4 4-5 每增加一个 减少一个 y的值在减少
0-1 1-2 2-3 3-4
0-1 1-2 2-3
0-1 1-2
0-1
先初始化的是最后的一个角标


*/


class MpDemo
{
        //定义一个功能，为了遍历数组中的元素。
        public static void paiqian(int[] arr)
                {
                        for(int x=0;x<arr.length;x++)
                        {
                                if(x!=arr.length-1)
                                System.out.print(arr[x]+",");
                                else
                                System.out.println(arr[x]);
                        }
               
                }

        public static void main(String[] args)
        {
                int[] arr={35,23,43,54,65,56};
                        
                        paiqian(arr);
                                maopao(arr);
                                System.out.println("paihou=");
                                paiqian(arr);
        }
         public static void maopao(int[] arr)
                        {
                                for(int x=0;x<arr.length-1;x++ )
                                        {
                                                for(int y=0;y>arr.length-1-x;y++)//为什么减1 为了避免越界 -x是让逐轮比较元素递减。
                                                        {
                                                                if(arr[y]>arr[y+1])
                                                                        {
                                                                                int temp = arr[y];
                                                                                arr[y]=arr[y+1];
                                                                                arr[y+1]=temp;//选择和冒泡 区别在于 什么和什么相比较。
                        
                                                                        }
                                                               
                                                        }
                                        }
                        }
}
这个 可以又为什么啊？
求正解！！！求分析 ，求分配图！求详细说明 两个一个可以 另一个不可以为什么？
作者: 曹恒业    时间: 2012-7-10 20:19
/*
需求分析：选择排序图示：
0-1 0-2 0-3 0-4 0-5
1-2 2-3 3-4 4-5
2-3 3-4 4-5
3-4 4-5
4-5
通过分析 可以看出是个倒三角形，我们可以用两个for循环嵌套的模式来打印出来

相比较的都是角标位。


*/
class  XZDemo
{        
        public static void paiqian(int[] arr)   //该方法是顺序打印数组的全部元素
                {
                        for(int x=0;x<arr.length;x++)
                        {
                                if(x!=arr.length-1)     //判断只要不是最后一个元素，则在打印后加一个“，”；否则打印元素且换行
                                System.out.print(arr[x]+",");
                                else
                                System.out.println(arr[x]);
                        }
               
                }
        public static void main(String[] args)   //main方法
                        {
                                int[] arr={5,6,9,12,55,78,43};
               
                //System.out.println("qian=");
                                paiqian(arr);    //输出排序前的数组
                                pai(arr);        //对数组进行排序
                                paiqian(arr); //输出排序后的数组
                        }
public static void pai(int[] arr)    //这是选择排序的方法
        {
        for(int x=0;x<arr.length-1;x++)   //外循环，保证数组中的每一个元素都可以进入内循环与其他元素比较
                {
                for(int y=x+1;y<arr.length;y++)  //内循环，将起始元素与其后面的每一个元素比较，不比较该元素前面的
                   {
                        if(arr[x]>arr[y])    //如果arr[x]的值大于所比较元素的值，则交换位置
                                {
                                int temp=arr[x];
                                arr[x]=arr[y];
                                arr[y]=temp;
                                }
               
                        }
                 }
         }
}
这个可以 为什么？
具体解释见注释

/*0-1 1-2 2-3 3-4 4-5 每增加一个 减少一个 y的值在减少
0-1 1-2 2-3 3-4
0-1 1-2 2-3
0-1 1-2
0-1
先初始化的是最后的一个角标


*/


class MpDemo
{
        //定义一个功能，为了遍历数组中的元素。
        public static void paiqian(int[] arr)
                {
                        for(int x=0;x<arr.length;x++)
                        {
                                if(x!=arr.length-1)
                                System.out.print(arr[x]+",");
                                else
                                System.out.println(arr[x]);
                        }
               
                }

        public static void main(String[] args)
        {
                int[] arr={35,23,43,54,65,56};
                        
                        paiqian(arr);      
                                maopao(arr);
                                System.out.println("paihou=");
                                paiqian(arr);
        }
         public static void maopao(int[] arr)   //冒泡排序方法
                        {
                                for(int x=0;x<arr.length-1;x++ )   //外循环，保证每一个元素都参与比较
                                        {
                                                for(int y=0;y>arr.length-1-x;y++)//为什么减1 为了避免越界 -x是让逐轮比较元素递减。
                                                        {
                                                                if(arr[y]>arr[y+1])  //如果前面的元素大于后面的元素，则交换位置
                                                                        {
                                                                                int temp = arr[y];
                                                                                arr[y]=arr[y+1];
                                                                                arr[y+1]=temp;//选择和冒泡 区别在于 什么和什么相比较。
                        
                                                                        }
                                                               
                                                        }
                                        }
                        }
}
这个 可以又为什么啊？   具体解释见注释！
求正解！！！求分析 ，求分配图！求详细说明 两个一个可以 另一个不可以为什么？
就拿楼主的数组当例子，分别分析选择排序和冒泡排序的具体排序过程。
5,6,9,12,55,78,43
选择排序：原则，拿出一个元素，与后面所有的元素逐个对比，其中小的放在该元素位置。
1. 5 6 9 12 55 78 43--》5会依次和后面的元素对比，都比过之后，没有比5小的，所以排序未变。
2. 5 6 9 12 55 78 43--》接着，6依次和后面的元素对比，都比过之后，没有比6小的，所以排序未变。
3,4两步和1,2一样，9和12都是依次与后面的元素比较，排序结果仍未变。
5. 5 6 9 12 55 78 43--》 55与78比较，位置不变，55与43比较，由于55较小，交换位置。
6. 5 6 9 12 43 78 55--》 78与55比较，55较小，交换位置，所以最终排序结果完成。

冒泡排序：原则，前一个和后一个比较，其中小的放在前面，依次向后比较。
1. 5 6 9 12 55 78 43--》 首先，5会和6比较，然后6和9比较，以此类推，直到78和43比较，交换位置。
2. 5 6 9 12 55 43 78 --》继续依据原则比较，这次从6开始，到了55和43比较，交换位置。
3. 5 6 9 12 43 55 78 --》 继续依据原则比较，这次从9开始，无变化。
随后还会比较3趟，但是数组以有序，所以没变化。但是程序还是要走一遍。

这就是选择排序和冒泡排序的实际过程。
希望有帮到你~~





作者: 朱东方    时间: 2012-7-10 20:27
本帖最后由 朱东方 于 2012-7-10 20:35 编辑

第一个是：选择排序。
    原理是：从数组中的第一个元素开始一次和后面的每一个元素进行比较。然后第二个元素依次和后面的比较。。以此类推
第二个是：冒泡排序。
    原来死：数组中的元素，从第一个开始，相邻两个进行比较：第一个和第二个比较，取较大值或较小值。然后第二个再和第三个比较，第三个再和第四个比较。以此类推。。到最后末尾的那个元素就是最大值或最小值了。
                第二轮比较就不用最后一个元素参与了。按照前面的方法再次比较。 倒数第二个元素就是排序在第二的了。

冒泡排序.PNG (29.46 KB, 下载次数: 46)

冒泡排序

冒泡排序

选择排序.PNG (38.34 KB, 下载次数: 48)

选择排序

选择排序




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