1. 
   
2. package test;//选择排序
   
3. //需求：对数组{34,19,11,109,3,56}进行“选择排序”
   
4. /*  分析：
   
5. *  数组 {34,19,11,109,3,56}
   
6. *  角标    0         1        2  3  4  5
   
7. *  第一轮：0角标上的元素和1,2,3,4,5角标上的元素分别进行比较，如果0角标小，不用动，否则交换位置       
   
8. *  第一轮    0---->1,2,3,4,5   0和1,2,3,4,5比较
   
9. *  第二轮    1---->  2,3,4,5   1和     2,3,4,5比较
   
10. *  第三轮    2---->    3,4,5   2和          3,4,5比较
    
11. *  第四轮    3---->      4,5   3和               4,5比较
    
12. *  第五轮    4---->        5   4和             5比较
    
13. *  
    
14. 该列对应外循环    横线右边  对应内循环   
    
15. *  
    
16. * 一共5轮，第几轮对应外循环，外循环0到4，5取不到 for(int x=0;x<arr.length-1;x++){ }
    
17. * 内循环是每一轮比较的次数，第一轮5次，第二轮4次……
    
18. * 每一轮 内循环y的初始值都不一样，所以这也就说明y的初始值不确定，不能指定具体的值，看y和行x有什么关系，y=x+1
    
19. * 那内循环y的取值呢，第一个值和最后一个都值能取到，所以是y<arr.length
    
20. *  明确1  有没有返回值？没有
    
21. *  明确2        有没有未知内容参与？有  数组 int[]
    
22. *   */
    
23. public class test25 {
    
24.         public static void main(String args[]){
    
25.                 int [] arr ={34,19,11,109,3,56};
    
26.                 sortArr(arr);
    
27.                 //System.out.println(arr);//直接打印数组是个什么东西，只能是遍历才能取出来，遍历打印
    
28.                
    
29.                 for(int i=0;i<arr.length-1;i++){
    
30.                         System.out.print(arr[i]+",");
    
31.                 }
    
32.                
    
33.                
    
34.         }
    
35.         public static void sortArr(int []arr){
    
36.                 for(int x=0;x<arr.length-1;x++){//对应有几轮
    
37.                         for(int y=x+1;y<arr.length;y++){//对应每轮比较几次
    
38.                                 if(arr[x]>arr[y])//目的是x这边放最小的，如果是arr[x]>arr[y]就要交换
    
39.                                 {
    
40.                                         int temp = arr[x];
    
41.                                         arr[x] = arr[y];
    
42.                                         arr[y] = temp;
    
43.                                        
    
44.                                 }               
    
45.                                
    
46.                         }
    
47.                 }
    
48.                
    
49.         }
    
50. }

复制代码

1. class MyArrays{
   
2. 
   
3.         /**
   
4.                 排序方式一,效率高                :属于选择排序
   
5.        
   
6.         */
   
7.         public static void sort1(int[] arr){
   
8.                 int dexMin = 0;
   
9.                 for(int i = 0 ; i < arr.length ; i++){
   
10.                         dexMin = i;
    
11.                         for(int j = i + 1 ; j < arr.length ; j++){               
    
12.                                 if(arr[dexMin]>arr[j]){
    
13.                                         dexMin = j;       
    
14.                                 }
    
15.                         }
    
16.                         if(dexMin!=i){
    
17.                                 exchangeArr(arr,dexMin,i);
    
18.                         }
    
19.                 }
    
20.         }
    
21.        
    
22.         /**
    
23.        
    
24.         排序方式二,效率低                        :属于选择排序
    
25.        
    
26.         */
    
27.         public static void sort2(int[] arr){
    
28.                 for(int i = 0 ; i < arr.length ; i++){               
    
29.                         for(int j = i + 1 ; j < arr.length ; j++){               
    
30.                                 if(arr[i]>arr[j]){
    
31.                                         exchangeArr(arr,i,j);
    
32.                                 }
    
33.                         }
    
34.                 }
    
35.         }
    
36.        
    
37.         /**
    
38.        
    
39.         排序方式三,效率居中                                        :属于冒泡排序
    
40.        
    
41.         */
    
42.         public static void sort3(int[] arr){
    
43.                 for(int i = 0 ; i < arr.length ; i ++){
    
44.                         for(int x = 0 , y = x + 1 ;y < arr.length - i ; x ++ , y ++){
    
45.                                 if(arr[x]>arr[y]){                               
    
46.                                         exchangeArr(arr,x,y);
    
47.                                 }                       
    
48.                         }
    
49.                 }
    
50.         }
    
51. 
    
52.        
    
53.   /**
    
54.    *        遍历数组,打印到控制台
    
55.    */
    
56.         public static void printArr(int[] arr){
    
57.                 for(int i = 0 ; i < arr.length ; i ++){
    
58.                         System.out.print(arr[i]+" , ");
    
59.                 }
    
60.         }
    
61.        
    
62.         //私有方法,给数组提供换位服务
    
63.         private static void exchangeArr(int[] arr , int a , int b){
    
64.                 /*
    
65.                 arr[a] = arr[a]^arr[b];
    
66.                 arr[b] = arr[a]^arr[b];                异或换位//根据测试的时间上看,异或换位和利用第三方变量换位所需要的时间是一样的
    
67.                 arr[a] = arr[b]^arr[a]; */
    
68.                
    
69.                 int i = arr[a];
    
70.                 arr[a] = arr[b];
    
71.                 arr[b] = i;       
    
72.         }
    
73.        
    
74.    /**
    
75.         *        获取一个int类型数组;通过传入的参数决定数组的长度,该方法随机生成随机数填充到数组中
    
76.         */
    
77.         public static int[] getIntArr(int len){
    
78.                
    
79.                 Random random = new Random(1245125L);                //传入随机数种子,这样每次生成的10000个随机数都是一样的
    
80.                 int[] arr = new int[len];
    
81.                 for(int i = 0; i < arr.length ; i++){
    
82.                         arr[i] = random.nextInt(100000);
    
83.                 }
    
84.                 return arr;
    
85.         }
    
86. }

复制代码

楼主你的排序方式效率很低,在内圈每次排序之后先不要移动,记住最大数的角标位,内圈一圈走完再进行移动,我曾经实验过同样的10000个整数进行排序,如果是不记住角标位这种算法,在我的电脑上面排序需要的时间大概是是300毫秒,如果记住角标位再移动,排序需要的时间是70毫秒,而java自带的Arrays类里面的排序需要的时间是3毫秒,到现在我看不懂java中Arrays类的排序是如何做到的,