1. /*
   
2. 练习：
   
3. {5,95,45,1,2,8,36,44,15,98,774,11,32}
   
4. 使用选择排序和冒泡排序方法对数组进行排序
   
5. */
   
6. class  array
   
7. {
   
8.         public static void main(String[] args)
   
9.         {
   
10.                 int[] arr=new int[]{5,95,45,1,2,8,36,44,15,98,774,11,32};
    
11. 
    
12.                 print(arr); //打印数组
    
13. //                Select(arr); //调用函数进行选择排序
    
14.                 bubble(arr);  //进行冒泡排序
    
15.                 print(arr);//打印选择排序后的结果
    
16.                
    
17.         }
    
18. 
    
19.         //选择排序
    
20.         public static void Select(int[] arr)
    
21.         {
    
22.                 for (int x=0;x<arr.length-1 ;x++ )   // 是不是也可以不用-1？
    
23.                 {
    
24.                         for (int y=x+1;y<arr.length ;y++ )
    
25.                         {
    
26.                                 if (arr[x]>arr[y])
    
27.                                 {
    
28.                                         int i=arr[x];
    
29.                                         arr[x]=arr[y];
    
30.                                         arr[y]=i;
    
31.                                 }
    
32.                         }
    
33.                 }
    
34.         }
    
35. 
    
36.         //冒泡排序
    
37.         public static void bubble(int[] arr)
    
38.         {
    
39.                 for (int x=0;x<arr.length-1 ;x++ )
    
40.                 {
    
41.                         for (int y=0;y<arr.length-x-1 ;y++ )  //-x 让每一次比较的元素减少，  -1 避免角标越界
    
42.                         {
    
43.                                 if (arr[y]>arr[y+1])
    
44.                                 {
    
45.                                         int i=arr[y];
    
46.                                         arr[y]=arr[y+1];
    
47.                                         arr[y+1]=i;
    
48.                                 }
    
49.                         }
    
50.                 }
    
51.         }
    
52.         
    
53.         //打印数组
    
54.         public static void print(int[] arr)
    
55.         {
    
56.                 System.out.print("[");
    
57.                 for (int x=0;x<arr.length ;x++ )
    
58.                 {
    
59.                         
    
60.                         if (arr[x]!=arr[arr.length-1])
    
61.                         {
    
62.                                 System.out.print(arr[x]+",");
    
63.                         }
    
64.                         else
    
65.                                 System.out.println(arr[x]+"]");
    
66.                 }
    
67.                                 System.out.println();
    
68.         }
    
69. }
    

复制代码

昨天还不太明白，今天思路就变得清晰了。自己按着老师的思路走了一下写出来了。



大家看看还有什么错误或者还能改进的地方

{:soso__14430788048038969402_4:}

       //选择排序
        public static void Select(int[] arr)
        {
                for (int x=0;x<arr.length-1 ;x++ )   // 是不是也可以不用-1？
                                                                                                        //<-----注释：
                {                                                                        //可以不用-1，-1是为了提高执行效率，原因是：
                                                                                                        //x = arr.length-1时对应的arr[x]已经是数组中最后一个元素了，此时就没有比较的必要了
                                                                                                        //------->
                        for (int y=x+1;y<arr.length ;y++ )
                        {
                                if (arr[x]>arr[y])
                                {
                                        int i=arr[x];
                                        arr[x]=arr[y];
                                        arr[y]=i;
                                }
                        }
                }
        }

                /*
                优化后的选择排序
                减少数据的交换次数，实现效率的提升
                */
                public static void selectorSort(int[] arr)
                {
                        for(int x = 0; x < arr.length-1; x++)
                        {
                                int tempIndex = x;

                                for(int y = x+1; y < arr.length; y++)
                                {
                                        if (arr[tempIndex]>arr[y])
                    {
                                                tempIndex = y;
                    }
                                }
                                if(tempIndex != x)
                                {
                                                //可以将其封装为函数
                    int temp =arr[x];
                    arr[x]=arr[tempIndex];
                    arr[tempIndex]=temp;
                                }
                        }
                }

        //冒泡排序
                /*
                楼主有兴趣可以自己实现
                思路：
                        通过减少数据交换次数，实现效率提升
                步骤：
                        1. 定义一个数组，用来存放排好序的元素的角标
                        2. 内循环完成一次后将最大(最小)的元素对应的角标存放到数组中；
                        3. 最后遍历角标数组，该角标数组中存放的是原数组中的角标值。
                */
        public static void bubble(int[] arr)
        {
                for (int x=0;x<arr.length-1 ;x++ )
                {
                        for (int y=0;y<arr.length-x-1 ;y++ )  //-x 让每一次比较的元素减少，  -1 避免角标越界
                        {
                                if (arr[y]>arr[y+1])
                                {
                                        int i=arr[y];
                                        arr[y]=arr[y+1];
                                        arr[y+1]=i;
                                }
                        }
                }
        }
有不对之处，请指正

zhangchao 发表于 2014-1-25 12:59
//选择排序
        public static void Select(int[] arr)
        {

{:3_64:}多谢纠正~

不用减1也行，程序不会出现错误，但是外层循环会多一次判断，效率低一点。

IT人 发表于 2014-1-25 13:45
不用减1也行，程序不会出现错误，但是外层循环会多一次判断，效率低一点。 ...

{:soso__2975127348007296759_3:}

zhangchao 发表于 2014-1-25 12:59
//选择排序
        public static void Select(int[] arr)
        {

学习了，谢谢

客气了，互相学习，共同进步

不错！思路挺清晰的，

                                if (arr[y]>arr[y+1])
                                {
                                        int i=arr[y];
                                        arr[y]=arr[y+1];
                                        arr[y+1]=i;
                                }
可以将此处用于替换的代码块封装成一个私有方法来使用