快速排序算法
快速排序（Quicksort）是对
冒泡排序的一种改进。
快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以
递归进行，以此达到整个数据变成有序
序列。
算法介绍
快排图
一趟快速排序的算法是：
1）设置两个变量i、j，
排序开始的时候：i=0，j=N-1；
2）以第一个数组元素作为关键数据，赋值给
key，即
key=A[0]；
3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于
key的值A[j]，将A[j]和A[i]互换；
4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于
key的A[i]，将A[i]和A[j]互换；
5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于
key,4中A[i]不大于
key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。
排序演示
示例
假设用户输入了如下数组：
|
下标
|
0
|
1
|
2
|
3
|
4
|
5
|
|
数据
|
6
|
2
|
7
|
3
|
8
|
9
|
创建变量i=0（指向第一个数据）, j=5(指向最后一个数据), k=6(
赋值为第一个数据的值)。
我们要把所有比k小的数移动到k的左面，所以我们可以开始寻找比6小的数，从j开始，从右往左找，不断递减变量j的值，我们找到第一个下标3的数据比6小，于是把数据3移到下标0的位置，把下标0的数据6移到下标3，完成第一次比较：
|
下标
|
0
|
1
|
2
| 3 |
4
|
5
|
|
数据
|
3
|
2
|
7
|
6
|
8
|
9
|
i=0 j=3 k=6
接着，开始第二次比较，这次要变成找比k大的了，而且要从前往后找了。递加变量i，发现下标2的数据是第一个比k大的，于是用下标2的数据7和j指向的下标3的数据的6做交换，数据状态变成下表：
|
下标
|
0
|
1
|
2
|
3
|
4
|
5
|
|
数据
|
3
|
2
|
6
|
7
|
8
|
9
|
i=2 j=3 k=6
称上面两次比较为一个循环。
接着，再递减变量j，不断重复进行上面的循环比较。
在本例中，我们进行一次循环，就发现i和j“碰头”了：他们都指向了下标2。于是，第一遍比较结束。得到结果如下，凡是k(=6)左边的数都比它小，凡是k右边的数都比它大：
|
下标
|
0
|
1
|
2
|
3
|
4
|
5
|
|
数据
|
3
|
2
|
6
|
7
|
8
|
9
|
如果i和j没有碰头的话，就递加i找大的，还没有，就再递减j找小的，如此反复，不断循环。注意判断和寻找是同时进行的。
然后，对k两边的数据，再分组分别进行上述的过程，直到不能再分组为止。
注意：第一遍快速排序不会直接得到最终结果，只会把比k大和比k小的数分到k的两边。为了得到最后结果，需要再次对下标2两边的数组分别执行此步骤，然后再分解数组，直到数组不能再分解为止（只有一个数据），才能得到正确结果。
调用函数
在c++中可以用函数qsort（）可以直接为
数组进行排序。
[1]
用 法:
void qsort(void *base, int nelem, int width, int (*fcmp)(const void *,const void *));
示例代码
GO
// 第一种写法
func quickSort(values []
int
, left, right
int
) {
temp := values[left]
p := left
i, j := left, right
for
i <= j {
for
j >= p && values[j] >= temp {
j--
}
if
j >= p {
values[p] = values[j]
p = j
}
if
values[i] <= temp && i <= p {
i++
}
if
i <= p {
values[p] = values[i]
p = i
}
}
values[p] = temp
if
p-left > 1 {
quickSort(values, left, p-1)
}
if
right-p > 1 {
quickSort(values, p+1, right)
}
}
func QuickSort(values []
int
) {
if
len(values) <= 1 {
return
}
quickSort(values, 0, len(values)-1)
}
// 第二种写法
func Quick2Sort(values []
int
) {
if
len(values) <= 1 {
return
}
mid, i := values[0], 1
head, tail := 0, len(values)-1
for
head < tail {
fmt.Println(values)
if
values[i] > mid {
values[i], values[tail] = values[tail], values[i]
tail--
}
else
{
values[i], values[head] = values[head], values[i]
head++
i++
}
}
values[head] = mid
Quick2Sort(values[:head])
Quick2Sort(values[head+1:])
}
C++语言
#include <iostream>
using
namespace
std;
void
Qsort(
int
a[],
int
low,
int
high)
{
if
(low >= high)
{
return
;
}
int
first = low;
int
last = high;
int
key = a[first];
/*用字表的第一个记录作为枢轴*/
while
(first < last)
{
while
(first < last && a[last] >= key)
{
--last;
}
a[first] = a[last];
/*将比第一个小的移到低端*/
while
(first < last && a[first] <= key)
{
++first;
}
a[last] = a[first];
/*将比第一个大的移到高端*/
}
a[first] = key;
/*枢轴记录到位*/
Qsort(a, low, first-1);
Qsort(a, first+1, high);
}
int
main()
{
int
a[] = {57, 68, 59, 52, 72, 28, 96, 33, 24};
Qsort(a, 0,
sizeof
(a) /
sizeof
(a[0]) - 1);
/*这里原文第三个参数要减1否则内存越界*/
for
(
int
i = 0; i <
sizeof
(a) /
sizeof
(a[0]); i++)
{
cout << a[i] <<
""
;
}
return
0;
}
/*参考数据结构p274(清华大学出版社，严蔚敏)*/
PHP
<?php
function
quickSort(&
$arr
){
if
(
count
(
$arr
)>1){
$k
=
$arr
[0];
$x
=
array
();
$y
=
array
();
$_size
=
count
(
$arr
);
for
(
$i
=1;
$i
<
$_size
;
$i
++){
if
(
$arr
[
$i
]<=
$k
){
$x
[]=
$arr
[
$i
];
}
elseif
(
$arr
[
$i
]>
$k
){
$y
[]=
$arr
[
$i
];
}
}
$x
=quickSort(
$x
);
$y
=quickSort(
$y
);
return
array_merge
(
$x
,
array
(
$k
),
$y
);
}
else
{
return
$arr
;
}
}
?>
Python递归
#quick sort
def
quickSort(
L
, low, high):
i = low
j = high
if
i >= j:
return
L
key =
L
[i]
while
i < j:
while
i < j
and
L
[j] >= key:
j = j-
1
L
[i] =
L
[j]
while
i < j
and
L
[i] <= key:
i = i+
1
L
[j] =
L
[i]
L
[i] = key
quickSort(
L
, low, i-
1
)
quickSort(
L
, j+
1
, high)
return
L
扫一扫
58万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
