1. /**
   
2. 第四课数组程序练习
   
3. 1.数组遍历问题，要求打印数组中的所有数
   
4. 2.给定一个数组，输出最大最小值
   
5. */
   
6. class  shuzulianxi
   
7. {
   
8.         public static void main(String[] args)
   
9.         {
   
10.                 int[] arr={3,5,6,9,8,7,4,5,2};
    
11.                 printArray(arr);
    
12.                 getMax(arr);
    
13.                 getMin(arr);
    
14.                 selectSort(arr);
    
15.                 printArray(arr);
    
16.                 bubbleSort(arr);
    
17.                 printArray(arr);
    
18.                 }
    
19. 
    
20.         /*
    
21.         数组遍历问题，要求打印数组中所有数.元素间用逗号隔开。
    
22.         思路：定义一个函数，可以打印数组中的数字，
    
23.         知识点：数组中有一个属性可以直接获取到数组元素个数。使用方式：数组名称.length
    
24.         分析1：返回为打印值，void
    
25.         分析2：有位知量，是一组数组
    
26.         */
    
27.         public static void printArray(int[] arr)//次函数可以打印数组中所有数，并且元素中用逗号隔开。
    
28.         {
    
29.                 System.out.print("[");
    
30.                 for (int i=0;i<arr.length;i++)
    
31.                 {
    
32.                         if (i!=arr.length-1)
    
33.                                 System.out.print(arr[i]+", ");
    
34.                         else
    
35.                                 System.out.print(arr[i]+"]"+"\n");
    
36.                 }
    
37.         }
    
38.         /*
    
39.     给定一个数组，输出最大值
    
40.         思路：定义一个函数，可以打印出数组的最大值。
    
41.         1，获取最值需要进行比较。每一次比较都会有一个较大的值。因为该值不确定。通过一个变量进行临储。
    
42.         2，让数组中的每一个元素都和这个变量中的值进行比较。如果大于了变量中的值，就用该该变量记录较大值。
    
43.         3，当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值了。
    
44. 
    
45.         分析：返回值为打印值，所以void
    
46.               有未知量，是一组数组
    
47.     */
    
48.         public static void getMax(int arr[])
    
49.         {
    
50.                 int max=arr[0];
    
51.                 for (int x=1;x<arr.length;x++)
    
52.                 {
    
53.                         if(arr[x]>max)
    
54.                                 max=arr[x];        
    
55.                 }
    
56.                 System.out.println(max+"是这组数中最大值");
    
57.         }
    
58.     /*
    
59.     给定一个数组，输出最小值
    
60.         思路：定义一个函数，可以打印出数组的最小值。
    
61.         1，获取最值需要进行比较。每一次比较都会有一个较小的值。因为该值不确定。通过一个变量进行临储。
    
62.         2，让数组中的每一个元素都和这个变量中的值进行比较。如果小于了变量中的值，就用该该变量记录较小值。
    
63.         3，当所有的元素都比较完成，那么该变量中存储的就是数组中的最小值了。
    
64. 
    
65.         分析：返回值为打印值，所以void
    
66.               有未知量，是一组数组
    
67.     */
    
68.         public static void getMin(int arr[])
    
69.         {
    
70.                 int min=arr[0];
    
71.                 for (int x=1;x<arr.length;x++)
    
72.                 {
    
73.                         if(arr[x]<min)
    
74.                                 min=arr[x];
    
75.                 }
    
76.                 System.out.println(min+"是这组数中最小值");
    
77.         }
    
78.         /*
    
79.         因为，发现无论什么排序。都需要对满足条件的元素进行位置置换。所以可以把这部分相同的代码提取出来，单独封装成一个函数。
    
80.         */
    
81.         public static void swap(int arr[],int a,int b)//提高复用性
    
82.         {
    
83.                 int temp;
    
84.                 temp=arr[a];
    
85.         arr[a]=arr[b];
    
86.                 arr[b]=temp;
    
87.         }
    
88.     /*
    
89.         对给定数组进行顺序排序
    
90.         思路：给定一个函数，使之可以让数组里面的数按照升幂排列
    
91.         1.取第一个数，让去与后面的数挨个比较大小，若后面的数比这个数小，则交换位置，用到for循环
    
92.         2.取第二个数，让去与后面的数挨个比较大小，若后面的数比这个数小，则交换位置，以此类推。直到.length-1结束。完成排序。
    
93.         
    
94.         分析：不会返回值，在堆内存中已经排好序，所以是void
    
95.               有未知量，是一组数组。
    
96.         */
    
97.         public static void selectSort(int arr[]);
    
98.         {
    
99.                 for (int x=0;x<arr.length-1;x++)
    
100.                 {
     
101.                         for (int y=x+1;y<arr.length;y++)
     
102.                         {
     
103.                                 if(arr[y]<arr[x])
     
104.                                         swap(arr[],x,y);
     
105.                         }
     
106.                 }
     
107.         }
     
108.         /*
     
109.         冒泡排序 降幂
     
110.         思路：循环嵌套。相邻两个数之间比较，如果大的在前面，比较下一组，如果小的在前面，换位，比较下一组。每一次内循环完成最右边的数就是min
     
111.         */
     
112.         public static void bubbleSort(int arr[])
     
113.         {
     
114.                 for (int x=0;x<arr.length-1;x++)
     
115.                 {
     
116.                         for (int y=0;y<arr.length-x-1;y++)
     
117.                         {
     
118.                                 if(arr[y]<arr[y+1])
     
119.                                         swap(arr[],y,y+1);
     
120.                         }
     
121.                 }
     
122.         }
     
123. 
     
124. 
     
125. }
     
126. 
     

复制代码

public static void selectSort(int arr[]);第97行这里多了一个分号。。。

97行末尾,方法名后面多了个;号,
104 119行
swap(arr[],y,y+1);
传递数组变量arr就可以了,多了[]

cxdzh 发表于 2014-10-16 15:59
97行末尾,方法名后面多了个;号,
104 119行
swap(arr[],y,y+1);

swap(arr[],y,y+1);
传递数组变量arr就可以了,多了[]  这个能详细说一下么，不太明白，谢谢

run_wind 发表于 2014-10-16 17:24
swap(arr[],y,y+1);
传递数组变量arr就可以了,多了[]  这个能详细说一下么，不太明白，谢谢 ...

数组定义方式
元素类型[] 数组名=new 元素类型[]{元素1,元素2,元素3};
    int[]         arr =new int[]{1,2,3}
    int[]         arr =new int[3];
    int[]         arr={1,2,3};
int是整数型的意思
int[]是整数型数组的意思,
int[] arr={1,2,3};就是定义一个整数型数组,
而数组定义时,就会在内存中开辟一个空间来存储这些数组成员,,,然后将这个空间的内存地址,例如0x0045这个地址赋值给arr,所以arr这个变量就指向了这片内存空间,调用时直接传递arr这个变量就可以了..

public static void bubbleSort(int arr[])
另外,刚发现你方法写接收的参数是(int arr[])
这样表示他要接收的参数是int 型,然后在本方法内将这个变量赋值给arr[]这个变量然后使用,所以编译能通过,实际上使用时是错误的,接收的是一个整数,而不是一个整数型数组.
要接收数组型变量应该是 public static void bubbleSort(int[] arr)
意思是接收一个int[]类型的变量,也就是整数型数组变量.
48 68 81 97 112这些方法都是同样的问题.

cxdzh 发表于 2014-10-16 17:56
数组定义方式
元素类型[] 数组名=new 元素类型[]{元素1,元素2,元素3};
    int[]         arr =new int[] ...

大神！！！你精通了把，学了多久了

run_wind 发表于 2014-10-16 18:06
大神！！！你精通了把，学了多久了

学了11天了.....
毕老师的教程里都有讲这些问题啊...这是基础中的基础...

cxdzh 发表于 2014-10-16 18:46
学了11天了.....
毕老师的教程里都有讲这些问题啊...这是基础中的基础...

我靠有天赋啊，我晕头晕脑的

楼主厉害