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

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© LFW 中级黑马   /  2014-5-31 14:53  /  1411 人查看  /  10 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 LFW 于 2014-6-8 20:53 编辑

/*复习,纯理解后记忆算法,手敲。效果不错,加油!
需求:将数组arr从小到大排列,用冒泡排序写。然后将数组arr从大到小排列,用选择排序写。
1、冒泡排序,相邻的角标0与1,1与2比较,....每次符合条件就元素换位。第一次冒泡完,最后一个角标位存放的元素必为最值。
函数:明确结果:无,void;明确是否有未知内容参与运算,有,未知数组,int[]。
2、选择排序,0角标与1角标比较,符合条件就换位,然后0角标继续与角标1、2...比较,第一圈选择完,0角标位存放的元素必为最值。*/

class  ArrSortTest
{
        public static void main(String[] args)
        {
                int[] arr1={0,1,2,3,5,4,8,7,9,10};
                int[] arr2={1,2,3,4,5,9,9,8};
                int[] arr3={1,2,3,5,77,444,55,66,88,77,99};
                int[] arr=arr1;
                xuanArr(arr);
                arr=arr3;
                xuanArr(arr);
                arr=arr2;
                xuanArr(arr);
               
        }
        public static void xuanArr(int[] arr)
        {
                System.out.println("下边是数组"+arr+"的"+"遍历情况");
                readArr(arr);
                bubbleSort(arr);
                readArr(arr);
                selectSort(arr);
                readArr(arr);
                System.out.println("-------------华丽的分割线------------");
        }
        //遍历数组
        public static void readArr(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 bubbleSort(int[] arr)
        {
                for (int x=0; x<arr.length;x++ )
                {
                        for (int y=0;y<arr.length-x-1 ;y++ )
                        {
                                if(arr[y]>arr[y+1])
                                {
                                        diaohuan(arr,y,y+1);
                                        /*
                                int temp=arr[y];
                                arr[y]=arr[y+1];
                                arr[y+1]=temp;
                                        */
                                }

                        }
                }
                System.out.println("-------下边是冒泡排序,小到大-------");
        }
        //选择排序,大到小
        public static void selectSort(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])
                                {
                                        diaohuan(arr,x,y);
                                                /*
                                int temp=arr[x];
                                arr[x]=arr[y];
                                arr[y]=temp;
                                        */
                                }
                        }
                }
                System.out.println("-------下边是选择排序,大到小-------");
        }
        //将调换的代码封装成函数
        public static void diaohuan(int[] arr,int a,int b)
        {
                {
                int temp=arr[a];
                arr[a]=arr;
                arr=temp;
                }
        }
}


QQ截图20140531144746.png (98.79 KB, 下载次数: 11)

QQ截图20140531144746.png

10 个回复

倒序浏览
我知道输出结果的错误在哪,但我没想到怎么简单的把数组名输出来,虽然是小插曲,但也想弄明白
回复 使用道具 举报
  1. package com.itheima;
  2. class  ArrSortTest
  3. {
  4.         public static void main(String[] args)
  5.         {
  6.                 int[] arr1={0,1,2,3,5,4,8,7,9,10};
  7.                 int[] arr2={1,2,3,4,5,9,9,8};
  8.                 int[] arr3={1,2,3,5,77,444,55,66,88,77,99};
  9.                 int[] arr=arr1;
  10.                 xuanArr(arr);
  11.                 arr=arr3;
  12.                 xuanArr(arr);
  13.                 arr=arr2;
  14.                 xuanArr(arr);
  15.                
  16.         }
  17.         public static void xuanArr(int[] arr)
  18.         {
  19.                 System.out.println("下边是数组"+arr+"的"+"遍历情况");
  20.                 readArr(arr);
  21.                 bubbleSort(arr);
  22.                 readArr(arr);
  23.                 selectSort(arr);
  24.                 readArr(arr);
  25.                 System.out.println("-------------华丽的分割线------------");
  26.         }
  27.         //遍历数组
  28.         public static void readArr(int[] arr)
  29.         {
  30.                 for (int x=0;x<arr.length ;x++ )
  31.                 {
  32.                         if(x!=arr.length-1)
  33.                         System.out.print(arr[x]+"; ");
  34.                         else
  35.                                 System.out.println(arr[x]);
  36.                 }
  37.         }
  38.         //冒泡排序,小到大
  39.         public static void bubbleSort(int[] arr)
  40.         {
  41.                 for (int x=0; x<arr.length;x++ )
  42.                 {
  43.                         for (int y=0;y<arr.length-x-1 ;y++ )
  44.                         {
  45.                                 if(arr[y]>arr[y+1])
  46.                                 {
  47.                                         diaohuan(arr,y,y+1);
  48.                                         /*
  49.                                 int temp=arr[y];
  50.                                 arr[y]=arr[y+1];
  51.                                 arr[y+1]=temp;
  52.                                         */
  53.                                 }

  54.                         }
  55.                 }
  56.                 System.out.println("-------下边是冒泡排序,小到大-------");
  57.         }
  58.         //选择排序,大到小
  59.         public static void selectSort(int[] arr)
  60.         {
  61.                 for (int x=0;x<arr.length-1 ;x++ )
  62.                 {
  63.                         for (int y=x+1;y<arr.length ;y++ )
  64.                         {
  65.                                 if(arr[x]<arr[y])
  66.                                 {
  67.                                         diaohuan(arr,x,y);
  68.                                                 /*
  69.                                 int temp=arr[x];
  70.                                 arr[x]=arr[y];
  71.                                 arr[y]=temp;
  72.                                         */
  73.                                 }
  74.                         }
  75.                 }
  76.                 System.out.println("-------下边是选择排序,大到小-------");
  77.         }
  78.         //将调换的代码封装成函数
  79.         public static void diaohuan(int[] arr,int a,int b)
  80.         {
  81.                 {
  82.                 int temp=arr[a];
  83.                 arr[a]=arr[b];
  84.                 arr[b]=temp;
  85.                 }
  86.         }
  87. }
复制代码




我看了,没哟普问题啊,你i昂首神马?搞不懂
回复 使用道具 举报
这个你需要看java基础加强了,int[]被java虚拟机是当成一个对象来打印的
回复 使用道具 举报
改变前下边是数组[I@1896d2c2的遍历情况
0; 1; 2; 3; 5; 4; 8; 7; 9; 10
-------下边是冒泡排序,小到大-------
0; 1; 2; 3; 4; 5; 7; 8; 9; 10
-------下边是选择排序,大到小-------
10; 9; 8; 7; 5; 4; 3; 2; 1; 0
-------------华丽的分割线------------
下边是数组[I@55e6cb2a的遍历情况
1; 2; 3; 5; 77; 444; 55; 66; 88; 77; 99
-------下边是冒泡排序,小到大-------
1; 2; 3; 5; 55; 66; 77; 77; 88; 99; 444
-------下边是选择排序,大到小-------
444; 99; 88; 77; 77; 66; 55; 5; 3; 2; 1
-------------华丽的分割线------------
下边是数组[I@23245e75的遍历情况
1; 2; 3; 4; 5; 9; 9; 8
-------下边是冒泡排序,小到大-------
1; 2; 3; 4; 5; 8; 9; 9
-------下边是选择排序,大到小-------
9; 9; 8; 5; 4; 3; 2; 1
-------------华丽的分割线------------





改成intent后下边是数组[Ljava.lang.Integer;@28b56559的遍历情况
0; 1; 2; 3; 5; 4; 8; 7; 9; 10
-------下边是冒泡排序,小到大-------
0; 1; 2; 3; 4; 5; 7; 8; 9; 10
-------下边是选择排序,大到小-------
10; 9; 8; 7; 5; 4; 3; 2; 1; 0
-------------华丽的分割线------------
下边是数组[Ljava.lang.Integer;@1d10caf0的遍历情况
1; 2; 3; 5; 77; 444; 55; 66; 88; 77; 99
-------下边是冒泡排序,小到大-------
1; 2; 3; 5; 55; 66; 77; 77; 88; 99; 444
-------下边是选择排序,大到小-------
444; 99; 88; 77; 77; 66; 55; 5; 3; 2; 1
-------------华丽的分割线------------
下边是数组[Ljava.lang.Integer;@397b6178的遍历情况
1; 2; 3; 4; 5; 9; 9; 8
-------下边是冒泡排序,小到大-------
1; 2; 3; 4; 5; 8; 9; 9
-------下边是选择排序,大到小-------
9; 9; 8; 5; 4; 3; 2; 1
-------------华丽的分割线------------
回复 使用道具 举报
基本数据类型的数组都会当恒一个对象来打印,打印的都是地址,可以看看基础加强.
回复 使用道具 举报
LFW 中级黑马 2014-5-31 15:07:51
7#
fenzheng 发表于 2014-5-31 14:59
我看了,没哟普问题啊,你i昂首神马?搞不懂

哥们你说点我能听懂的话,我知道我实现了排序的功能,我的代码我运行了没问题,但你看我cmd图,我想输出“下边是数组arr1/arr2/arr3”,但输出结果是内存地址,我也知道我那里写成+arr+是会让虚拟机打印出内存地址[I@~的。可我就是想知道怎么样实现动态输出对应的数组名而已。。。。。
回复 使用道具 举报
LFW 中级黑马 2014-5-31 15:10:04
8#
fenzheng 发表于 2014-5-31 15:00
这个你需要看java基础加强了,int[]被java虚拟机是当成一个对象来打印的

老毕告诉我了。。。我是想知道如何实现动态输出对应数组名。我知道代码不对了,但我想知道怎么样是正确的。uno?
回复 使用道具 举报
你给xuanArr方法传过去一个数组参数,它怎么知道引用这个数组的变量名是什么呀。
不知道反射能不能获取传递给方法的参数名。

或者麻烦点,改一下方法。
  1.             public static void main(String[] args)
  2.             {
  3.                     int[] arr1={0,1,2,3,5,4,8,7,9,10};
  4.                     int[] arr2={1,2,3,4,5,9,9,8};
  5.                     int[] arr3={1,2,3,5,77,444,55,66,88,77,99};
  6.                     int[] arr=arr1;
  7.                     xuanArr(arr,"arr1");
  8.                     arr=arr3;
  9.                     xuanArr(arr,"arr2");
  10.                     arr=arr2;
  11.                     xuanArr(arr,"arr3");
  12.             }
复制代码

回复 使用道具 举报 1 0
LFW 中级黑马 2014-5-31 15:54:26
10#
wangleixhlm 发表于 2014-5-31 15:43
你给xuanArr方法传过去一个数组参数,它怎么知道引用这个数组的变量名是什么呀。
不知道反射能不能获取传递 ...

int[] arr=arr1;》》》这句话是把arr1的起始内存地址给了arr,对么?你的方法我懂什么意思,但你这样改一下,arr2又不会出现了
回复 使用道具 举报
LFW 中级黑马 2014-5-31 15:58:31
11#
wangleixhlm 发表于 2014-5-31 15:43
你给xuanArr方法传过去一个数组参数,它怎么知道引用这个数组的变量名是什么呀。
不知道反射能不能获取传递 ...

改了前边,对应的的冒泡函数和选择函数的参数变量要增加,并且被设定死了吧?还有就是你代码错了。。。。“arr2”和“arr3”放错了{:2_31:}。可以跟我说说反射的方法么,我还没看到。。我新手哦
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马