快速排序--C语言实现、python实现

快速排序（从小到大排序）：（C语言）

采用三数中值分割法：

选取数组的左右端点和中间点，并交换顺序使 左< 中 <右，并将中间的元素作为pivot来分割数组；

对于小的数组，快速排序不如插入排序好，所以设置当数组长度小于某个值的时候，使用插入排序的方法；

quick_sort:

void quick_sort(int *a, int n)
{
q_sort(a, 0, n-1);
}

q_sort:

#define CUTOFF 20 //当数组长度小于20时，采用插入排序
void q_sort(int *a, int left, int right)
{
int i, j;
int pivot;

if (left+CUTOFF <= right) {
pivot = median3(a, left, right);//选取pivot并将左、中、右端点排序
i = left;
j = right - 1;
while (1) {
while (a[++i] < pivot);
while (a[--j] > pivot);	//这里已经将小于pivot的元素置于左端点，将大于pivot的元素置于右端点，故这里不用判断越界
if (i < j)
swap(&a[i], &a[j]);
else
break;
}
swap(&a[i], &a[right-1]);

q_sort(a, left, i-1);
q_sort(a, i+1, right);
} else
insert_sort(a+left, right-left+1);
}

median3:

int median3(int *a, int left, int right)
{
int center = (left+right)/2;

if (a[left] > a[right])
swap(&a[left], &a[right]);
if (a[left] > a[center])
swap(&a[left], &a[center]);
if (a[center] > a[right])
swap(&a[center], &a[right]);

swap(&a[center], &a[right-1]);

return a[right-1];
}

swap:

void swap(int *a, int *b)
{
int tmp;
tmp = *a;
*a = *b;
*b = tmp;
}

insert_sort:

void insert_sort(int *a, int n)
{
int i, j, key;

for (i = 1; i < n; i ++) {
key = a[i];
for (j = i; a[j-1]>key && j>0; j --) {
a[j] = a[j-1];
}
a[j] = key;
}
}

python实现，相对简单点，直接选取右端点作为pivot：

import sys
import random

lenth = 100

def q_sort(arr, left, right):
pivot = arr[right]
i = left
j = right

if i == j:
return

while True:
while (arr[i] <= pivot) and (i < j):
i = i + 1
while (arr[j] >= pivot) and (i < j):
j = j - 1
if i >= j:
break
arr[i], arr[j] = arr[j], arr[i]

arr[i], arr[right] = arr[right], arr[i]
if left < i:
q_sort(arr, left, i-1)
if i < right:
q_sort(arr, i+1, right)

def main():
arr = []
sys.setrecursionlimit(10000) #set the depth of the stack
for i in range(lenth):
arr.append(random.randint(0, 1000))
print 'before: \n', arr
q_sort(arr, 0, lenth-1)
print 'after: \n', arr

if __name__ == '__main__':
main()

在网上看到个别人用python写的快速排序，非常简洁：

import sys
import random

def q_sort(arr):
if len(arr) <= 1:
return arr
else:
pivot = arr[0]
return q_sort([x for x in arr[1:] if x < pivot]) + [pivot] + \
q_sort([x for x in arr[1:] if x >= pivot])

def main():
sys.setrecursionlimit(10000)
a = random.sample([i for i in range(100)], 15)
print "random:\n", a
print "quick sort:\n", q_sort(a)

if __name__ == '__main__':
main()