java实现冒泡、选择、快速排序算法

冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

快速排序（Quicksort）是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

注：详细的排序算法可以参考wiki；

下面给出三种排序算法的具体实现：

[java]  view plain  copy

 

1. package com.xjtu.cruise;  
2.   
3. public class Sort {  
4.   
5.     /** 
6.      * 冒泡排序 
7.      *  
8.      * @param data 
9.      *            目标数组 
10.      */  
11.     public static void bubbleSort(int[] data) {  
12.   
13.         for (int i = 0; i < data.length - 1; i++) {// 控制趟数  
14.             for (int j = 0; j < data.length - i - 1; j++) {  
15.   
16.                 if (data[j] > data[j + 1]) {  
17.                     int tmp = data[j];  
18.                     data[j] = data[j + 1];  
19.                     data[j + 1] = tmp;  
20.                 }  
21.             }  
22.         }  
23.   
24.     }  
25.   
26.     /** 
27.      * 选择排序 
28.      *  
29.      * @param data 
30.      *            目标数组 
31.      */  
32.     public static void selectSort(int[] data) {  
33.         if (data == null || data.length == 0) {  
34.             return;  
35.         }  
36.   
37.         for (int i = 0; i < data.length - 1; i++) {  
38.             int min = i;// 将当前下标定为最小值下标  
39.             for (int j = i + 1; j < data.length; j++) {  
40.                 if (data[j] < data[min]) {  
41.                     min = j;  
42.                 }  
43.             }  
44.   
45.             if (i != min) {  
46.                 int tmp = data[i];  
47.                 data[i] = data[min];  
48.                 data[min] = tmp;  
49.             }  
50.         }  
51.     }  
52.   
53.     /** 
54.      * 选择排序 此算法效率不如上面的高 
55.      *  
56.      * @param sort 
57.      */  
58.     public static void selectSort2(int[] data) {  
59.   
60.         for (int i = 0; i < data.length - 1; i++) {  
61.             for (int j = i + 1; j < data.length; j++) {  
62.                 if (data[j] < data[i]) {  
63.                     int temp = data[j];  
64.                     data[j] = data[i];  
65.                     data[i] = temp;  
66.                 }  
67.             }  
68.         }  
69.     }  
70.   
71.     /** 
72.      * 快速排序算法 
73.      *  
74.      * @param data 
75.      *            目标数组 
76.      * @param start 
77.      *            起始位 
78.      * @param end 
79.      *            结束位 
80.      */  
81.     public static void quickSort(int[] data, int start, int end) {  
82.         // 设置关键数据key为要排序数组的第一个元素，  
83.         // 即第一趟排序后，key右边的数全部比key大，key左边的数全部比key小  
84.         int key = data[start];  
85.         // 设置数组左边的索引，往右移动比key大的数  
86.         int i = start;  
87.         // 设置数组右边的索引，往左移动比key小的数  
88.         int j = end;  
89.         // 如果左边索引比右边索引小，则还有数据没有排序  
90.         while (i < j) {  
91.             while (data[j] > key && j > i) {  
92.                 j--;  
93.             }  
94.             data[i] = data[j];  // //交换比枢轴小的记录到左端
95.   
96.             while (data[i] < key && i < j) {  
97.                 i++;  
98.             }  
99.             data[j] = data[i];  //交换比枢轴大的记录到右端
100.         }  
101.         // 此时 i==j  
102.         data[i] = key;  
103.   
104.         // 递归调用  
105.         if (i - 1 > start) {  
106.             // 递归调用，把key前面的完成排序  
107.             quickSort(data, start, i - 1);  
108.         }  
109.         if (i + 1 < end) {  
110.             // 递归调用，把key后面的完成排序  
111.             quickSort(data, i + 1, end);  
112.         }  
113.     }  
114.   
115.     /** 
116.      * @param args 
117.      */  
118.     public static void main(String[] args) {  
119.         int[] p = { 34, 21, 54, 18, 23, 76, 38, 98, 45, 33, 27, 51, 11, 20, 79,  
120.                 30, 89, 41 };  
121.   
122.         long start = System.currentTimeMillis();  
123.   
124. //      Sort.bubbleSort(p);// 冒泡排序  
125. //      Sort.selectSort(p);// 选择排序  
126. //      Sort.selectSort2(p);// 选择排序2  
127.         Sort.quickSort(p, 0, p.length - 1);// 快速排序  
128.   
129.         System.out.println("所用时间：" + (System.currentTimeMillis() - start));  
130.         for (int i = 0; i < p.length; i++) {  
131.             System.out.print(p[i] + " ");  
132.         }  
133.     }  
134.   
135. }  
136. 
     

代码实现

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

public  static  void  quickSort( int [] arr){      qsort(arr,  0 , arr.length- 1 ); } private  static  void  qsort( int [] arr,  int  low,  int  high){      if  (low < high){          int  pivot=partition(arr, low, high);         //将数组分为两部分          qsort(arr, low, pivot- 1 );                    //递归排序左子数组          qsort(arr, pivot+ 1 , high);                   //递归排序右子数组      } } private  static  int  partition( int [] arr,  int  low,  int  high){      int  pivot = arr[low];      //枢轴记录      while  (low<high){          while  (low<high && arr[high]>=pivot) --high;          arr[low]=arr[high];              //交换比枢轴小的记录到左端          while  (low<high && arr[low]<=pivot) ++low;          arr[high] = arr[low];            //交换比枢轴小的记录到右端      }      //扫描完成，枢轴到位      arr[low] = pivot;      //返回的是枢轴的位置      return  low; }

算法性能/复杂度

可以看出，每一次调用partition()方法都需要扫描一遍数组长度（注意，在递归的时候这个长度并不是原数组的长度n，而是被分隔出来的小数组，即n*(2^(-i))），其中i为调用深度。而在这一层同样长度的数组有2^i个。那么，每层排序大约需要O(n)复杂度。而一个长度为n的数组，调用深度最多为log(n)层。二者相乘，得到快速排序的平均复杂度为O(n ㏒n)。