快速排序

从列表中选取一个数为基准数，重新排序数列，所有元素比基准值小的摆放在基准数前面，所有元素比基准数值大的摆在基准数的后面（相同的数可以到任一边）。在这个分区结束之后，该基准数就处于数列的中间位置。递归的对基准数两边的子序列继续进行排序

[code]def quick_sort(alist, first, last):
'''快速排序'''
if first >= last:
return
mid_value = alist[first] # 这个值应该要变的
low = first # 初始左边游标指向第一个元素
high = last# 右边游标指向最后一个元素，两个游标分别往中间走

# li = [12, 34, 2, 56, 23, 78, 2323, 7, 232]
#  7, 34, 2, 56,23,78,2323, ,232    -->第一次遍历
#  3, , 2, 56, 23,78,2323,34,232    －－－》第二次遍历
# 3,2, , 56,... －－－》第三次遍历
# 通过这个循环，就可以获取到基准值在序列中的位置，当low等于high时，说明最后只有一个元素，程序就可以退出了
while low < high:
# 首先走high游标
while low < high and alist[high] > mid_value:
high -= 1
# 退出循环要么两个游标重合要么有个值比基准值小,此时将low指向的跟high指向元素的交换位置
alist[low] = alist[high]

while low < high and alist[low] < mid_value:
low += 1
# 退出循环要么两个游标重合要么有个值比基准值大
alist[high] = alist[low]
alist[low] = mid_value
# 递归重复判断左右子序列
quick_sort(alist, first, low)
quick_sort(alist, low+1, last)

if __name__ == '__main__':
li = [12,34,2,56,23,78,2323,7,232]
#  7, 34, 2, 56,23,78,2323, ,232
#  3, , 2, 56, 23,78,2323,34,232
# 3,2, , 56,...
n = len(li)
print(li)
quick_sort(li, 0, n-1)
print(li)

• 最优时间复杂度：O(nlogn)
• 最坏时间复杂度：O(n2)
• 稳定性：不稳定

从一开始快速排序平均需要花费O(n log n)时间的描述并不明显。但是不难观察到的是分区运算，数组的元素都会在每次循环中走访过一次，使用O(n)的时间。在使用结合（concatenation）的版本中，这项运算也是O(n)。

在最好的情况，每次我们运行一次分区，我们会把一个数列分为两个几近相等的片段。这个意思就是每次递归调用处理一半大小的数列。因此，在到达大小为一的数列前，我们只要作log n次嵌套的调用。这个意思就是调用树的深度是O(log n)。但是在同一层次结构的两个程序调用中，不会处理到原来数列的相同部分；因此，程序调用的每一层次结构总共全部仅需要O(n)的时间（每个调用有某些共同的额外耗费，但是因为在每一层次结构仅仅只有O(n)个调用，这些被归纳在O(n)系数中）。结果是这个算法仅需使用O(n log n)时间。

代码是我写的，大家看下，能看懂恭喜，看不懂看大佬的，我是这方面的新手，有问题请指正，谢谢