A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

本帖最后由 李志群 于 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;//选择和冒泡 区别在于 什么和什么相比较。
                        
                                                                        }
                                                               
                                                        }
                                        }
                        }
}
这个 可以又为什么啊?
求正解!!!求分析 ,求分配图!求详细说明 两个一个可以 另一个不可以为什么?

2 个回复

倒序浏览
/*
需求分析:选择排序图示:
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趟,但是数组以有序,所以没变化。但是程序还是要走一遍。

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





点评

故意考你的 你看下 maopao方法的内循环的Y变量 我的错误 !!!! 兄弟 你运行了吗? 你没看Y变量< 和> 的问题吗? 这解释我也会 呵呵 不细心啊!....   发表于 2012-7-10 20:39

评分

参与人数 1技术分 +1 收起 理由
刘笑 + 1 赞一个!

查看全部评分

回复 使用道具 举报
本帖最后由 朱东方 于 2012-7-10 20:35 编辑

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

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

冒泡排序

冒泡排序

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

选择排序

选择排序

点评

不错呵呵 你们没看到我有个Y的变量写错了吗? 故意的哈哈  发表于 2012-7-10 20:35

评分

参与人数 1技术分 +1 收起 理由
韦念欣 + 1 赞一个!

查看全部评分

回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马