[size=14.0000009536743px]

1. 
   
2. class ArrayDemo
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 int[] a ={23,13,34,533,34,545,6,63,132,24};
   
7.                 //排序前
   
8.                 printArray(a);
   
9.                 int max = getMax(a);
   
10.                 int min = getMin(a);
    
11.                 System.out.println("max="+max);
    
12.                 System.out.println("min="+min);
    
13.                 //选择排序；
    
14.                 //selectSort(a);        //选择排序
    
15.                 bubbleSort(a);                //冒泡排序
    
16.                 //排序后
    
17.                 printArray(a);
    
18.                 System.out.println("max="+a[a.length-1]);
    
19.                 System.out.println("min="+a[0]);
    
20.         }       
    
21.        
    
22.         /*
    
23.                 要求：定义一个功能，实现数组中的元素用逗号隔开输出
    
24. 
    
25.         */
    
26.         public static void printArray(int[] arr)
    
27.         {
    
28.                 System.out.print("{ ");
    
29.                 for(int i=0;i<arr.length;i++)
    
30.                 {
    
31.                         if(i!=arr.length-1)
    
32.                                 System.out.print(arr[i]+", ");
    
33.                         else
    
34.                                 System.out.println(arr[i]+" }");
    
35.                        
    
36.                 }
    
37.         }
    
38. 
    
39.         /*
    
40.                 要求：定义一个求数组中最大的元素并输出。
    
41.         */
    
42.         public static int getMax(int[] arr)
    
43.         {
    
44.                 int max = 0;
    
45.                 for(int i = 1;i<arr.length;i++)
    
46.                 {
    
47.                         //max为数组的下标
    
48.                                 if(arr[i]>arr[max])
    
49.                                 max = i;
    
50.                 }
    
51.                 return arr[max];
    
52.         }
    
53. 
    
54.         /*
    
55.                 要求：定义一个求数组中最小的元素并输出。
    
56.         */
    
57.         public static int getMin(int[] arr)
    
58.         {
    
59.                 int min = 0;
    
60.                 for(int i = 0;i<arr.length;i++)
    
61.                 {
    
62.                         if(arr[i]<arr[min])
    
63.                                 min = i;
    
64.                 }
    
65.                 return arr[min];
    
66.         }
    
67. 
    
68.         /*
    
69.                 选择排序
    
70.         */
    
71.         public static void selectSort(int[] arr)
    
72.         {
    
73.                 for(int i = 0;i<arr.length-1;i++)        //i<arr.length-1是为了在比完倒数第二个后，最后一个数不需要比较了
    
74.                 {
    
75.                         for(int j = i+1;j<arr.length;j++)       
    
76.                         {
    
77.                                 if(arr[i] > arr[j])
    
78.                                 {
    
79.                                         int temp = arr[i];
    
80.                                         arr[i] = arr[j];
    
81.                                         arr[j] = temp;
    
82.                                 }
    
83.                         }
    
84.                 }
    
85.         }
    
86. 
    
87.         /*
    
88.                 冒泡排序,这里是从左往右冒，首先将Max冒出
    
89.         */
    
90.         public static void bubbleSort(int[] arr)
    
91.         {
    
92.                 for(int i = 0;i<arr.length-1;i++)        //i<arr.length-1是为了在比完倒数第二个数后，最后一个数不需要比较了
    
93.                 {
    
94.                         //lengh-i是因为外围循环每执行一次便冒出一个最大值，所以剩余需要比较的元素需要减1；
    
95.                         //-1是为了防止下面if判断中的【j+1】可能造成下标越界
    
96.                         for(int j = 0;j<arr.length-i-1;j++)                                                   
    
97.                         {
    
98.                                 if(arr[j]>arr[j+1])
    
99.                                 {
    
100.                                         int temp = arr[j];
     
101.                                         arr[j] = arr[j+1];
     
102.                                         arr[j+1] = temp;
     
103.                                 }
     
104.                         }
     
105.                 }
     
106.         }
     
107. }

复制代码

小肥啾 发表于 2015-11-1 23:06
可以尝试把数组的所有方法封装一个单独的类，作为数组的工具类

嗯，多谢指点，现在学基础还没学到类，后面再做实现{:2_32:}

不错不错~

可以尝试把数组的所有方法封装一个单独的类，作为数组的工具类

samge 发表于 2015-11-1 18:28
嗯，是的，老师也说实际开发时是直接用函数实现，之所以要练习这些算法，一是为了了解算法的实现，二是为 ...

嗯,练练内功

qw9685 发表于 2015-11-1 17:53
还没学到这里 看不懂

刚开始按照毕老师的视频一边看一边敲代码，敲多几遍就熟悉了，加油

dongran 发表于 2015-11-1 17:25
可以用sort方法直接排序

嗯，是的，老师也说实际开发时是直接用函数实现，之所以要练习这些算法，一是为了了解算法的实现，二是为了到时面试时可能会被问到。至于第三点，是我个人认为的，多学点东西可以拓展自己知识面，总是好事~{:2_32:}

还没学到这里 看不懂

可以用sort方法直接排序

a1441114 发表于 2015-11-1 11:57
System.out.print("{ ");
System.out.println(arr+" }");//原视频里“{”是用的“[".

嗯，谢谢。按照你的提示，我已经将

1. int temp = arr[j];
   
2.           arr[j] = arr[j+1];
   
3.           arr[j+1] = temp;
   

复制代码

这段代码整合为一个函数，函数如下：

1.         /*
   
2.                 写一个用于数组前后角标元素的置换功能
   
3.         */
   
4.         public static void exChange(int i,int j,int[] arr)
   
5.         {
   
6.                 int temp = arr[i];
   
7.                 arr[i] = arr[j];
   
8.                 arr[j] = temp;
   
9.         }

复制代码

到时候上面函数如需用到相邻元素之间的置换的话，则可以这样调用了：

1. if(arr[i] > arr[j])
   
2.                                 {
   
3.                                         exChange(i,j,arr);
   
4.                                 }

复制代码

System.out.print("{ ");
System.out.println(arr[i]+" }");//原视频里“{”是用的“[".

int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;//这替换应该还可以封装。简化代码。

好高深啊，看不懂