快速排序、冒泡排序

(一)快速排序

快速排序由于排序效率在同为O(N*logN)的几种排序方法中效率较高，因此经常被采用，再加上快速排序思想----分治法也确实实用，因此很多软件公司的笔试面试，包括像腾讯，微软等知名IT公司都喜欢考这个，还有大大小的程序方面的考试如软考，考研中也常常出现快速排序的身影。

快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。

该方法的基本思想是：

1．先从数列中取出一个数作为基准数。

2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。

3．再对左右区间重复第二步，直到各区间只有一个数。

虽然快速排序称为分治法，但分治法这三个字显然无法很好的概括快速排序的全部步骤。因此我的对快速排序作了进一步的说明：挖坑填数+分治法：

先来看实例吧，定义下面再给出（最好能用自己的话来总结定义，这样对实现代码会有帮助）。

以一个数组作为示例，取区间第一个数为基准数。

0	1	2	3	4	5	6	7	8	9
72	6	57	88	60	42	83	73	48	85

初始时，i = 0; j = 9; X = a[i] = 72

由于已经将a[0]中的数保存到X中，可以理解成在数组a[0]上挖了个坑，可以将其它数据填充到这来。

从j开始向前找一个比X小或等于X的数。当j=8，符合条件，将a[8]挖出再填到上一个坑a[0]中。a[0]=a[8];
i++; 这样一个坑a[0]就被搞定了，但又形成了一个新坑a[8]，这怎么办了？简单，再找数字来填a[8]这个坑。这次从i开始向后找一个大于X的数，当i=3，符合条件，将a[3]挖出再填到上一个坑中a[8]=a[3];
j--;

数组变为：

0	1	2	3	4	5	6	7	8	9
48	6	57	88	60	42	83	73	88	85

i = 3; j = 7; X=72

再重复上面的步骤，先从后向前找，再从前向后找。

从j开始向前找，当j=5，符合条件，将a[5]挖出填到上一个坑中，a[3] = a[5]; i++;

从i开始向后找，当i=5时，由于i==j退出。

此时，i = j = 5，而a[5]刚好又是上次挖的坑，因此将X填入a[5]。

数组变为：

0	1	2	3	4	5	6	7	8	9
48	6	57	42	60	72	83	73	88	85

可以看出a[5]前面的数字都小于它，a[5]后面的数字都大于它。因此再对a[0…4]和a[6…9]这二个子区间重复上述步骤就可以了。

对挖坑填数进行总结

1．i =L; j = R; 将基准数挖出形成第一个坑a[i]。

2．j--由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中。

3．i++由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中。

4．再重复执行2，3二步，直到i==j，将基准数填入a[i]中。

照着这个总结很容易实现挖坑填数的代码：

int AdjustArray(int s[], int l, int r) // 返回调整后基准数的位置
{
int i = l, j = r;
int x = s[l]; // s[l]即s[i]就是第一个坑
while (i < j) {
// 从右向左找小于x的数来填s[i]
while (i < j && s[j] >= x)
j--;
if (i < j) {
s[i] = s[j]; // 将s[j]填到s[i]中，s[j]就形成了一个新的坑
i++;
}
// 从左向右找大于或等于x的数来填s[j]
while (i < j && s[i] < x)
i++;
if (i < j) {
s[j] = s[i]; // 将s[i]填到s[j]中，s[i]就形成了一个新的坑
j--;
}
}
// 退出时，i等于j。将x填到这个坑中。
s[i] = x;
return i;
}

再写分治法的代码：

void quick_sort1(int s[], int l, int r) {
if (l < r) {
int i = AdjustArray(s, l, r);// 先成挖坑填数法调整s[]
quick_sort1(s, l, i - 1); // 递归调用
quick_sort1(s, i + 1, r);
}
}

这样的代码显然不够简洁，对其组合整理下：

/**
*
* @author @流沙河鱼
* ------------------ ---------
* ---------递归方法实现快速排序-----
*  ---------------------------
*/
public class QuickSort1 {
void quick_sort(int s[], int o, int r) {
// 递归调用此方法，当o=r时结束
if (o < r) {
int i = o, j = r, x = s[o];// 初始i是首指针，j是尾指针，x是数组第一个元素
// 第一趟排序后，i=j,此时数组被分成两部分，前部分的值均小于s[o],后半部分的值均大于s[o]
while (i < j) {
while (i < j && s[j] >= x)
j--; // 从右向左找第一个小于x的数
if (i < j)
s[i++] = s[j];
while (i < j && s[i] < x)
i++; // 从左向右找第一个大于等于x的数
if (i < j)
s[j--] = s[i];
}
s[i] = x;// 将基准元素放入两部分中间元素为空的位置，此时i=j;
quick_sort(s, o, i - 1); // 递归调用前部分
quick_sort(s, i + 1, r);// 递归调用后半部分
}
}

public static void main(String[] args) {
int[] str = new int[] { 11, 66, 22, 0, 55, 22, 10, 32 };
QuickSort1 sort = new QuickSort1();
sort.quick_sort(str, 0, str.length - 1);
for (int i = 0; i < str.length; i++) {// 打印排序后的结果
System.out.println("oK:" + str[i] + " ");
}
}
}

快速排序还有很多改进版本，如随机选择基准数，区间内数据较少时直接用另的方法排序以减小递归深度。有兴趣的筒子可以再深入的研究下。

注1，有的书上是以中间的数作为基准数的，要实现这个方便非常方便，直接将中间的数和第一个数进行交换就可以了。

假设要排序的数组是A[1]……A
，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一躺快速排序。一趟快速排序的算法是：

1）、设置两个变量I、J，排序开始的时候I：=1，J：=N；

2）、以第一个数组元素作为关键数据，赋值给X，即X：=A[1]；

3）、从J开始向前搜索，即由后开始向前搜索（J：=J-1），找到第一个小于X的值，将之移动到A[1]处（A[1]元素已经空缺），J：J-1；

4）、从I开始向后搜索，即由前开始向后搜索（I：=I+1），找到第一个大于X的值，j将之移动到A[J+1]处（A[J+1]元素已经空缺），I：I+1；

5）、重复第3、4步，直到I=J；

例如：待排序的数组A的值分别是：（初始关键数据X：=49）

A[1] A[2] A[3] A[4] A[5] A[6] A[7]：

49 38 65 97 76 13 27

进行第一次交换后： 27 38 65 97 76 13 49

( 按照算法的第三步从后面开始找

进行第二次交换后： 27 38 49 97 76 13 65

( 按照算法的第四步从前面开始找>X的值，65>49,两者交换，此时I：=3 )

进行第三次交换后： 27 38 13 97 76 49 65

( 按照算法的第五步将又一次执行算法的第三步从后开始找

进行第四次交换后： 27 38 13 49 76 97 65

( 按照算法的第四步从前面开始找大于X的值，97>49,两者交换，此时J：=4 )

此时再执行第三不的时候就发现I=J，从而结束一躺快速排序，那么经过一躺快速排序之后的结果是：27 38 13 49 76 97 65，即所以大于49的数全部在49的后面，所以小于49的数全部在49的前面。

快速排序就是递归调用此过程——在以49为中点分割这个数据序列，分别对前面一部分和后面一部分进行类似的快速排序，从而完成全部数据序列的快速排序，最后把此数据序列变成一个有序的序列，根据这种思想对于上述数组A的快速排序的全过程如图6所示：

初始状态 {49 38 65 97 76 13 27}

进行一次快速排序之后划分为 {27 38 13} 49 {76 97 65}

分别对前后两部分进行快速排序 {13} 27 {38}

结束 结束 {49 65} 76 {97}

49 {65} 结束

结束

图6 快速排序全过程

1）、设有N（假设N=10）个数，存放在S数组中；

2）、在S[1。。N]中任取一个元素作为比较基准，例如取T=S[1]，起目的就是在定出T应在排序结果中的位置K，这个K的位置在：S[1。。K-1]<=S[K]<=S[K+1..N]，即在S[K]以前的数都小于S[K]，在S[K]以后的数都大于S[K]；

3）、利用分治思想（即大化小的策略）可进一步对S[1。。K-1]和S[K+1。。N]两组数据再进行快速排序直到分组对象只有一个数据为止。

如具体数据如下，那么第一躺快速排序的过程是：

数组下标： 1 2 3 4 5 6 7 8 9 10

45 36 18 53 72 30 48 93 15 36

I J

（1） 36 36 18 53 72 30 48 93 15 45

（2） 36 36 18 45 72 30 48 93 15 53

（3） 36 36 18 15 72 30 48 93 45 53

（4） 36 36 18 15 45 30 48 93 72 53

（5） 36 36 18 15 30 45 48 93 72 53

通过一躺排序将45放到应该放的位置K，这里K=6，那么再对S[1。。5]和S[6。。10]分别进行快速排序。

下面是快速排序的代码：

package sort;

public class QuickSort {
/**
* 快速排序
*
* @param strDate
* @param left
* @param right
*/
public void quickSort(String[] strDate, int left, int right) {
String middle, tempDate;
int i, j;
i = left;
j = right;
middle = strDate[(i + j) / 2];
do {
while (strDate[i].compareTo(middle) < 0 && i < right)
i++; // 找出左边比中间值大的数
while (strDate[j].compareTo(middle) > 0 && j > left)
j--; // 找出右边比中间值小的数
if (i <= j) { // 将左边大的数和右边小的数进行替换
tempDate = strDate[i];
strDate[i] = strDate[j];
strDate[j] = tempDate;
i++;
j--;
}
} while (i <= j); // 当两者交错时停止

if (i < right) {
quickSort(strDate, i, right);
}
if (j > left) {
quickSort(strDate, left, j);
}
}

public static void main(String[] args) {
String[] strVoid = new String[] { "11", "66", "22", "0", "55", "22",
"10", "32" };
QuickSort sort = new QuickSort();
sort.quickSort(strVoid, 0, strVoid.length - 1);
for (int i = 0; i < strVoid.length; i++) {
System.out.println(strVoid[i] + " ");
}
}

}

(二)冒泡排序

一般来说，冒泡法是程序员最先接触的排序方法，它的优点是原理简单，编程实现容易，但它的缺点就是--程序的大忌--速度太慢。下面我介绍一个理解上简单但编程实现上不是太容易的排序方法，我不知道它是不是现有排序方法中最快的，但它是我见过的最快的。排序同样的数组，它所需的时间只有冒泡法的 4% 左右。我暂时称它为“快速排序法”。

最简单的排序方法是冒泡排序方法。这种方法的基本思想是，将待排序的元素看作是竖着排列的“气泡”，较小的元素比较轻，从而要往上浮。在冒泡排序算法中我们要对这个“气泡”序列处理若干遍。所谓一遍处理，就是自底向上检查一遍这个序列，并时刻注意两个相邻的元素的顺序是否正确。如果发现两个相邻元素的顺序不对，即“轻”的元素在下面，就交换它们的位置。显然，处理一遍之后，“最轻”的元素就浮到了最高位置；处理二遍之后，“次轻”的元素就浮到了次高位置。在作第二遍处理时，由于最高位置上的元素已是“最轻”元素，所以不必检查。一般地，第i遍处理时，不必检查第i高位置以上的元素，因为经过前面i-1遍的处理，它们已正确地排好序。

package bubbleSort;//简单的冒泡排序
public class bubbleSortTest {
　　//冒泡排序，得到从大到小的顺序的数字，最坏的情况下进行了n(n-1)/2次比较。
public static void main(String[] args){
int a[] = {12,23,45,13,5,235,123,-94,3,83};
int i ,j;
for (i=0;i<a.length;i++){
　　//两两比较，将最小的数字推到最后
for(j=1;j<a.length-i;j++){
if(a[j-1]<a[j]){
int temp =a[j-1];
a[j-1]=a[j];
a[j]=temp;
}
}
}
for(i=0;i<a.length;i++){
System.out.println(a[i]);
}
}
}

下面是一段输出错误的代码，看看问题在哪里？

package sort;

public class bubbleSort {

/**
* @param args
*/
public static void main(String[] args) {
new bubbleSort().bubbleSort0();
}

static void swap(int i, int j) {
int temp;
temp = i;
i = j;
j = temp;
}

public void bubbleSort0() {
int a[] = { 12, 23, 45, 13, 5, 235, 123, -94, 3, 83 };
int len = a.length;
int in, out;
for (out = len - 1; out >= 0; out--) {
for (in = 0; in < out; in++) {
if (a[in] > a[in + 1]) {
swap(a[in], a[in + 1]);
}
}
}
for (int i = 0; i < len; i++) {
System.out.println(a[i]);
}
}
}

参考：
http://jsdo.it/norahiko/oxIy/fullscreen(日本程序猿动画演示)
点击打开链接http://www.ruanyifeng.com/blog/2011/04/quicksort_in_javascript.html
http://www.cnblogs.com/morewindows/archive/2011/08/13/2137415.html http://blog.csdn.net/wangkuifeng0118/article/details/7286332