快速排序

快速排序（Quicksort），又称划分交换排序（partition-exchange sort）。在平均状况下，排序n个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n)算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。

快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。步骤为：

1、从数列中挑出一个元素，称为"基准"（pivot），

2、重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。

3、递归地（recursively）把小于基准值元素的子数列和大于基准值元素的子数列排序。

void quickSortRecursive(int arr[], int start, int end)
{
	if (start >= end)
	{
		return;
	}
	int mid = arr[end];
	int left = start, right = end - 1;
	while (left < right)
	{
		while (arr[left] < mid  && left < right)
		{
			left++;
		}
		while (arr[right] >= mid && left < right)
		{
			right--;
		}
		int temp = arr[left];
		arr[left] = arr[right];
		arr[right] = temp;
	}

	if (arr[left] >= arr[end])
	{
		int temp = arr[left];
		arr[left] = arr[end];
		arr[end] = temp;
	}
	else
	{
		left++;
	}
	if (left)
	{
		quickSortRecursive(arr, start, left - 1);
	}

	quickSortRecursive(arr, left + 1, end);

}
void quickSort(int arr[], int len)
{
	quickSortRecursive(arr, 0, len - 1);
}

Python版本

def quickSortRecursive(List, start, end):
    if start >= end:
        return
    mid = List[end]
    left = start
    right = end - 1
    while  left < right:
        while(List[left]<mid  and  left<right):
            left+=1
        while(List[right]>=mid  and  left < right):
            right-=1
        List[left], List[right] = List[right], List[left]
    if List[left]>=List[end]:
        List[left], List[end] = List[end], List[left]
    else:
        left+=1
    if left != None:
        quickSortRecursive(List, start, left-1)
    quickSortRecursive(List, left+1, end)

def quickSort(List):
    quickSortRecursive(List, 0, len(List)-1)

快速排序平均需要花费O(n log n)时间，