数组的排序，加入数组中相邻元素的置换

[java] view plain copy

1. /* 
2. 按大小排列数组中元素的顺序{2,23,5,6,9,1} 
3. */  
4. //从小到大排列  
5. //内循环结束一次，最值出现在头角标位上  
6. //选择排序  
7. class ArrayTest2  
8. {  
9.     public static void selectsort(int[] arr)  
10.     {  
11.         for(int x=0;x<arr.length-1;x++)  
12.         {  
13.             for(int y=x+1;y<arr.length;y++)  
14.             {  
15.                 if(arr[y]<arr[x])  
16.                 {  
17.                     /* 
18.                     int temp=arr[x]; 
19.                     arr[x]=arr[y]; 
20.                     arr[y]=temp; 
21.                     */  
22.                     swap(arr,x,y);//换位置  
23.                 }  
24.             }  
25.         }  
26.     }  
27.     //打印数组  
28.     public static void printArray(int[] arr)  
29.     {  
30.         System.out.print("[");  
31.         for(int x=0;x<arr.length;x++)  
32.         {  
33.             if(x!=arr.length-1)  
34.                 System.out.print(arr[x]+",");  
35.             else  
36.                 System.out.println(arr[x]+"]");  
37.         }  
38.     }  
39.       
40.     public static void main(String[] args)  
41.     {  
42.         int[] arr={2,23,5,6,9,1};  
43.         //printArray(arr);  
44.         //selectsort(arr);//选择排序  
45.         //Arrays.sort(arr);//java中已经定义好的一种排序方式，开发中对数组排序要使用该句代码  
46.         bubblesort(arr);  
47.         printArray(arr);  
48.     }  
49.       
50.       
51.     //冒泡排序：相邻的两个元素相互比较，如果符合条件换位  
52.     //第一圈，最值出现在最后位  
53.       
54.     public static void bubblesort(int[] arr)  
55.     {  
56.         for(int x=0;x<arr.length-1;x++)  
57.         {  
58.             for(int y=0;y<arr.length-x-1;y++)//-x让每一次比较的元素减少。-1避免角标越界  
59.             {  
60.                 if(arr[y]>arr[y+1])  
61.                 {  
62.                     /* 
63.                     int temp=arr[y]; 
64.                     arr[y]=arr[y+1]; 
65.                     arr[y+1]=temp; 
66.                     */  
67.                     swap(arr,y,y+1);  
68.                 }  
69.             }  
70.         }  
71.     }  
72.       
73.     /* 
74.     发现无论什么排序都需要对满足条件的元素进行未知置换 
75.     所以可以把这部分相同的代码提取出来，单独封装成一个函数 
76.     */  
77.     public static void swap(int[] arr,int a,int b)  
78.     {  
79.         int temp = arr[a];  
80.         arr[a] = arr[b];  
81.         arr[b] = temp;  
82.     }  
83. }  

转载地址：

http://blog.csdn.net/java19930623/article/details/44946635