快速排序和冒泡排序

写个快速排序和冒泡排序的例子，比较下2者

这个快速排序写的不是特别好，凑合一下吧，呵呵

1. package sort;
3. public class QuickSort 
4. {
5.     /**
6.      * @author yjb87
7.      * @分析 快速排序法 和 冒泡排序法 的详细步骤
8.      * @结论 快速排序法 在多核CPU下具有更高的效率
9.      */
10.     public static void main(String[] args) 
11.     {
12.         int array[] = new int[10];
13.         array[0] = 13;
14.         array[1] = 6;
15.         array[2] = 2;
16.         array[3] = 10;
17.         array[4] = 5;
18.         array[5] = 4;
19.         array[6] = 1;
20.         array[7] = 7;
21.         array[8] = 3;
22.         array[9] = 9;
23.         
24.         int array1[] = array.clone();
25.         System.out.println("*******************使用快速排序法********************");
26.         print(array);
27.         quickSort(array,0,9,0,1);
28.         System.out.println("*******************使用冒泡排序法********************");
29.         print(array1);
30.         bubble(array1,0);
31.     }
32.     /***快速排序法***/
33.     public static void quickSort(int array[],int first,int last,int count,int realNum)
34.     {
35.         /**
36.          * @array   需要排序的数组
37.          * @first   初始值为数组第一个元素的索引，即0
38.          * @last    初始值为数组的最后一个元素的索引，即数组长度
39.          * @count   计算排序步数
40.          * @realNum 分治成多少部分进行排序
41.          * */
42.         int temp,low,high,list_separator;
43.         low = first;
44.         high = last;
45.         list_separator = array[(first+last)/2];
46.         do
47.         {
48.             while(array[low] < list_separator)
49.             {
50.                 low++;
51.             }
52.             while(array[high] > list_separator)
53.             {
54.                 high--;
55.             }
56.             if(low<=high)
57.             {
58.                 count++;
59.                 //System.out.println("第 "+count+" 步 同时分 "+realNum+" 个部分进行排序 /n");
60.                 System.out.println("第 "+count+" 步");
61.                 temp=array[low];
62.                 array[low++]=array[high];
63.                 array[high--]=temp;
64.                 print(array);
65.             }
66.         }while(low <= high);
67.         if(first<high)
68.         {
69.             realNum++;
70.             quickSort(array,first,high,count,realNum);
71.         }
72.         if(low<last)
73.         {
74.             realNum++;
75.             quickSort(array,low,last,count,realNum);
76.         }
77.     }
78.     /**冒泡排序法**/
79.     public static void bubble(int array[],int count)
80.     {
81.         /**
82.          * @array 需要排序的数组
83.          * @count 计算排序步数
84.          * */
85.         int temp;
86.         for(int i=0;i<array.length;i++)
87.         {
88.             for(int j=i+1;j<array.length;j++)
89.             {
90.                 if(array[i]>array[j])
91.                 {
92.                     temp = array[i];
93.                     array[i] = array[j];
94.                     array[j] = temp;
95.                     count++;
96.                     System.out.println("第 "+count+" 步");
97.                     print(array);
98.                 }
99.             }
100.         }
101.     }
102.     public static void print(int array[])
103.     {
104.         for(int i=0;i<array.length;i++)
105.         {
106.             if(array[i]<10)
107.                 System.out.print(" -  "+array[i]);
108.             else
109.                 System.out.print(" - "+array[i]);
110.         }
111.         System.out.println();
112.     }
113. }