快速排序--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()