package vom.vice.Interface;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Random;

/**
* 5，编写程序:生成5个1至10之间的随机整数，存入一个List集合，编写方法对List集合进行排序
*             （ 自定义排序算法，禁用Collections.sort方法和TreeSet），然后遍历集合输出
* @author Administrator
*   求： 自定义排序算法，禁用Collections.sort方法和TreeSet，        {:3_65:}大神补全代码.....................
*/
public class InterfaceDemo2 {

        public static void main(String[] args) {
               
                ArrayList<Integer> list=new ArrayList<Integer>();               
            for(int i=0;i<5;i++){              
                    Random r=new Random(); //生成随机数
                int sum=r.nextInt(10)+1;  //1至10之间的随机整数      
                      list.add(sum); //集合添加元素
            }


        //Collections.sort(list);
        for(Integer s:list){
                System.out.println(s);
        }
        }
       

}

怎么感觉都写的代码一堆堆的，难看的要命。我也写个吧。

1. @Test
   
2.     public void testJson3() {
   
3.         //生成随机数
   
4.         ArrayList<Integer> list = generateRandomList(5);
   
5.         //排序
   
6.         sort(list);
   
7.         //打印
   
8.         System.out.println(list);
   
9.     }
   
10. 
    
11.     /**
    
12.      * 冒泡排序
    
13.      * @param list 排序list
    
14.      */
    
15.     private void sort(ArrayList<Integer> list) {
    
16.         int len = list.size();
    
17.         int temp = 0;
    
18.         for (int i = 0; i < len; i++) {
    
19.             for (int j = i + 1; j < len; j++) {
    
20.                 if (list.get(i) > list.get(j)) {
    
21.                     temp = list.get(i);
    
22.                     list.set(i, list.get(j));
    
23.                     list.set(j, temp);
    
24.                 }
    
25.             }
    
26.         }
    
27.     }
    
28. 
    
29.     /**
    
30.      * 生成随机数
    
31.      * @param count 随机数个数
    
32.      * @return 随机数列表
    
33.      */
    
34.     private ArrayList<Integer> generateRandomList(int count) {
    
35.         ArrayList<Integer> list = new ArrayList<Integer>();
    
36.         for (int i = 0; i < count; i++) {
    
37.             list.add(new Random().nextInt(10) + 1);
    
38.         }
    
39.         return list;
    
40.     }

复制代码

1. package vom.vice.Interface;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.Collections;
   
5. import java.util.Comparator;
   
6. import java.util.Random;
   
7. 
   
8. /**
   
9. * 5，编写程序:生成5个1至10之间的随机整数，存入一个List集合，编写方法对List集合进行排序
   
10. *             （ 自定义排序算法，禁用Collections.sort方法和TreeSet），然后遍历集合输出
    
11. * @author zhengyk
    
12. *   求： 自定义排序算法，禁用Collections.sort方法和TreeSet，        大神补全代码.....................
    
13. */
    
14. public class InterfaceDemo2{
    
15.    public static void main(String[] args) {
    
16.                
    
17.          ArrayList<Integer> list=new ArrayList<Integer>();               
    
18.          
    
19.                  for(int i=0;i<5;i++){               
    
20.              Random r=new Random(); //生成随机数
    
21.              int sum=r.nextInt(10)+1;  //1至10之间的随机整数      
    
22.              list.add(sum); //集合添加元素
    
23.          }
    
24. 
    
25.                 for (int x = 0;x<list.size()-1 ;x++ )
    
26.                 {
    
27.                         for (int y =x+1 ;y<list.size() ;y++ )
    
28.                         {
    
29.                                 if(list.get(x)>list.get(y))
    
30.                                 {
    
31.                                         Integer temp;
    
32.                                         temp = list.get(x);
    
33.                                         list.set(x,list.get(y));
    
34.                                         list.set(y,temp);
    
35.                                 }
    
36.                         }
    
37.                 }
    
38. 
    
39. 
    
40.         //Collections.sort(list);
    
41.         for(Integer s:list){
    
42.                 System.out.println(s);
    
43.         }
    
44.     }
    
45.       
    
46. }
    
47. 
    

复制代码

1. import java.util.*;
   
2. 
   
3. /**
   
4. * 5，编写程序:生成5个1至10之间的随机整数，存入一个List集合，
   
5. * 编写方法对List集合进行排序
   
6. *             （ 自定义排序算法，禁用Collections.sort方法和TreeSet），
   
7. * 然后遍历集合输出
   
8. * @author zhengyk
   
9. *   求： 自定义排序算法，禁用Collections.sort方法和TreeSet，        
   
10. * 大神补全代码.....................
    
11. */
    
12. public class InterfaceDemo2 {
    
13.    public static void main(String[] args) {
    
14.                
    
15.         ArrayList<Integer> list=new ArrayList<Integer>();               
    
16.          
    
17.         for(int i=0;i<5;i++){               
    
18.              Random r=new Random(); //生成随机数
    
19.              int sum=r.nextInt(10)+1;  //1至10之间的随机整数      
    
20.              list.add(sum); //集合添加元素
    
21.         }
    
22. 
    
23.         System.out.print("排序前的数据: ");
    
24.         printList(list);
    
25.         sort(list);
    
26.         System.out.print("排序后的数据: ");
    
27.         printList(list);
    
28.         //Collections.sort(list);
    
29.         /*for(Integer s:list){
    
30.                 System.out.println(s);
    
31.         }*/
    
32.     }
    
33.       
    
34.     public static List sort(List<Integer> list) {
    
35.         Integer[] arr = new Integer[list.size()];
    
36.         arr = list.toArray(arr);   //转为数组方便遍历
    
37.         list.clear();
    
38. 
    
39.         //做选择排序
    
40.         int k;  
    
41.         Integer temp;
    
42.         for (int i=0; i<arr.length; i++) {
    
43.             k = i;
    
44.             for (int j=k+1; j<arr.length; j++) {
    
45. 
    
46.                 if (arr[k] > arr[j]) {
    
47.                     k = j;      //完成一次排序后,最小值的索引值存放在k中
    
48.                 }
    
49.             }
    
50. 
    
51.             if (k != i) {
    
52.                     temp = arr[i];
    
53.                     arr[i] = arr[k];
    
54.                     arr[k] = temp;
    
55.             }
    
56.             list.add(arr[i]);    //一次排序完成后插入数据
    
57.         }
    
58. 
    
59.         return list;
    
60.     }
    
61. 
    
62.     //打印数据
    
63.     public static void printList(List<Integer> list) {
    
64.         for (Integer i: list) {
    
65.             System.out.print(i + " ");
    
66.         }
    
67.         System.out.println();
    
68.     }
    
69. }
    
70. 
    

复制代码

在你的基础上修改的，这样可以不？

yuanlingqi 发表于 2015-1-8 16:25
怎么感觉都写的代码一堆堆的，难看的要命。我也写个吧。

大神！受教了

学习了！！！

三个人的代码都看了，一楼的排序核心代码跟三楼没啥区别，都是用的冒泡排序的翻版（算法根本不满足冒泡排序的定义），效率在所有排序算法中最差的，二楼的算法虽然长点，但是它通过设置一个标志，减少数据的交换次数，但是比较次数，三个人的是一样的，相比较下，二楼的好点。但是对于5个数据的排序，基本看不出来，数据比较大的时候就有差别了。

学习了。。

学习了！

邓士林 发表于 2015-1-13 15:49
三个人的代码都看了，一楼的排序核心代码跟三楼没啥区别，都是用的冒泡排序的翻版（算法根本不满足冒泡排序 ...

是选择排序把

嗯  明白了

厉害啊啊啊

求学之路，来之不易啊

赐教了！！

进来赐教  真多大神

受教了      

public class TEST {

        public static void main(String[] args) {
                Random r = new Random();
                List<Integer> al = new ArrayList<>();
                al.add(r.nextInt(9)+1);
                al.add(r.nextInt(9)+1);
                al.add(r.nextInt(9)+1);
                al.add(r.nextInt(9)+1);
                al.add(r.nextInt(9)+1);
                List<Integer> newal=sortMethod(al);
                for (Integer integer : newal) {
                        System.out.println(integer);
                }
        }

        private static List<Integer> sortMethod(List<Integer> al) {
               
                for (int i = al.size()-1;i>0; i--) {
                        for (int j =0 ; j < i; j++) {
                                if(al.get(j)>al.get(j+1))
                                        Collections.swap(al, j, j+1);
                        }
                }
                return al;
        }

}

说着禁用 collections sort 和 treeset