1. public class Sort {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 bubbleSort();
   
5.                 System.out.println("--------------------");
   
6.                 selectSort();
   
7.                
   
8.         }
   
9.         //冒泡排序
   
10.         public static void bubbleSort(){
    
11.                 int[] arr = {49,56,12,87,30,25,14};  //定义一个未排序的数组
    
12.                 System.out.print("进行未排序前的遍历：");
    
13.                 printArray(arr); //遍历数组
    
14.                 System.out.println();
    
15.                 for(int i = 0; i < arr.length; i++){
    
16.                         for(int j = 0; j < arr.length - 1 - i; j++){//没排序完一次，最大的就在最后面，所以不需要再比较，每次就少比较i次
    
17.                                 if(arr[j] > arr[j+1]){  //如果前面一个元素比后面一个元素大，就交换位置
    
18.                                         int temp = arr[j];
    
19.                                         arr[j] = arr[j+1];
    
20.                                         arr[j+1] = temp;
    
21.                                 }
    
22.                         }
    
23.                         System.out.print("第"+(i+1)+"次的结果为：");
    
24.                         printArray(arr); //遍历每一次排序的结果
    
25.                         System.out.println();
    
26.                 }
    
27.                
    
28.         }
    
29.         //选择排序
    
30.         public static void selectSort(){
    
31.                 int[] arr = {49,56,12,87,30,25,14};
    
32.                 System.out.print("进行未排序前的遍历：");
    
33.                 printArray(arr); //遍历数组
    
34.                 System.out.println();
    
35.                 for(int i = 0; i < arr.length; i++){
    
36.                         for(int j = i+1; j < arr.length; j++){
    
37.                                 if(arr[i] > arr[j]){  
    
38.                                         int temp = arr[i];
    
39.                                         arr[i] = arr[j];
    
40.                                         arr[j] = temp;
    
41.                                 }
    
42.                         }
    
43.                         System.out.print("第"+(i+1)+"次的结果为：");
    
44.                         printArray(arr); //遍历每一次排序的结果
    
45.                         System.out.println();
    
46.                 }
    
47.         }
    
48.         //打印数组
    
49.         public static void printArray(int[] arr){
    
50.                 System.out.print("["+arr[0]+",");
    
51.                 for(int i = 1; i < arr.length; i++){
    
52.                         if( i != arr.length - 1){
    
53.                                 System.out.print(arr[i]+",");
    
54.                         }else{
    
55.                                 System.out.print(arr[i]+"]");
    
56.                         }
    
57.                 }
    
58.         }
    
59. 
    
60. }

复制代码

看看 呵呵

如果能调试，我能写出来，但是如果让我用笔直接写，我估计就完蛋了！

还可以再优化优化！

寻觅 发表于 2015-1-21 21:59
还可以再优化优化！

怎么优化，是把置换代码提取出来吗？

这道题很经典

楼主其实还可以写一个插入排序的

面试题中会考这个吗？

来看下。。。。

奋斗吧骚年！！！

努力学习，奔向就业班

小棽 发表于 2015-1-22 16:21
怎么优化，是把置换代码提取出来吗？

你的冒泡排序，那我就插入排序

1. //描述插入排序
   
2. public class InsertSort {
   
3.         public static void main(String[] args) {
   
4.                 int maxSize = 100;
   
5.                 ArrayInsert arr = new ArrayInsert(maxSize);
   
6. 
   
7.                 /*for (int i=9; i>0; i--) {
   
8.                         arr.insert(i);
   
9.                 }*/
   
10. 
    
11.                 //插入100个0-100的随机数
    
12.                 for (int i=0; i<maxSize; i++) {
    
13.                         long n = (long) (Math.random()*(maxSize)+1);
    
14.                         arr.insert(n);
    
15.                 }
    
16. 
    
17.                 long start = System.currentTimeMillis();
    
18.                 System.out.println("排序前的数据: ");
    
19.                 arr.display();
    
20. 
    
21.                 arr.insertSort();
    
22.                 System.out.println("排序后的数据: ");
    
23.                 arr.display();
    
24. 
    
25.                 long end = System.currentTimeMillis();
    
26.                 System.out.println("spend time: " + (end-start));        //花费的时间
    
27.         }
    
28. }
    
29. 
    
30. //封装数据的类
    
31. class ArrayInsert {
    
32.         private long[] arr;
    
33.         private int nElems;
    
34. 
    
35.         public ArrayInsert(int size) {
    
36.                 arr = new long[size];
    
37.                 nElems = 0;
    
38.         }
    
39. 
    
40.         //插入数据
    
41.         public void insert(int value) {
    
42.                 arr[nElems] = value;
    
43.                 nElems ++;
    
44.         }
    
45. 
    
46.         public void display() {
    
47.                 for (int i=0; i<nElems; i++) {
    
48.                         System.out.print(arr[i] + " ");
    
49.                 }
    
50.                 System.out.println();
    
51.         }
    
52. 
    
53.         //插入排序
    
54.         public void insertSort() {
    
55.                 int in, out;
    
56. 
    
57.                 for (out=1; out<nElems; out++) {
    
58.                         long temp = arr[out];
    
59.                         in = out;
    
60. 
    
61.                         while(in>0 && arr[in-1]>temp) {
    
62.                                 arr[in] = arr[in-1];        //右移一位
    
63.                                 in --;
    
64.                         }
    
65.                         arr[in] = temp;                //插入数据
    
66.                 }
    
67.         }
    
68. }

复制代码