python实现快速排序

快速排序是对冒泡排序的一种改进，他的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，一次达到整个数据的有序序列。

## 快速排序

def quick(lst):
    """
    原理：
        1、首先设定一个分界值，通过分界值将数组分成两部分。
        2、将大于或等于分界值的数据放到数组右边，小于分界值的数据放到数据的左边，此时左边部分元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值。
        3、然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以去一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。
        右侧的数组数据也可以做类似处理。
        4、重复上述过程，可以看出，这是一个递归定义，用过递归将左侧部分排序好后，在递归排好右侧部分的顺序，将左侧和右侧两部分数据排好后，整个数组的排序也就完成了。
    :param lst:
    :return:
    """
    def group(lst,low,high):
        ## 对lst中索引low到索引high中的元素进行分组，基准值为low索引处的元素，即lst[low]
        ## 从左向右扫描lst，找到一个大于lst[low]的值为止，再从右向左扫描lst，找到一个小于lst[low]的值为止，然后交换两个值，重复此步骤，直到
        ## 左边扫描到的元素的索引大于或等于右边扫描到的元素的索引时停止，并在停止时交换右边扫描到的元素与lst[low]
        left = low ## 左边开始扫描的索引
        right = high+1 ## 右边开始扫描的索引
        while True:
            while True:
                right -= 1
                if right == low or lst[right] < lst[low]:
                    break
            while True:
                left+=1
                if left == high or lst[left] > lst[low]:
                    break
            if left>=right:
                lst[low],lst[right] = lst[right],lst[low]
                break
            else:
                lst[left], lst[right] = lst[right], lst[left]
        return right
    def sort(lst,low,high):
        # 对列表lst从给定的最小索引low到给定的最大索引high进行排序
        if low>=high: # 如果low>=high表示lst中只有一个元素，排序完成，返回列表
            return lst
        boundary = group(lst,low,high) # 获取lst通过0索引处的元素进行分组之后的0索引处所在元素的索引
        sort(lst,low,boundary-1) # 对分组后左边的元素进行排序
        sort(lst,boundary+1,high) # 对分组后右边的元素进行排序
        return lst
    return sort(lst,0,len(lst)-1)


if __name__ == '__main__':
    import random
    import time
    import copy
    from merge import merge
    from shell import shell
    list = [random.randint(1, 10000000) for i in range(100000)]
    newList1 = copy.deepcopy(list)
    newList2 = copy.deepcopy(list)
    start_time = time.time()
    list = quick(list)
    end_time = time.time()
    print("快速排序用时：{}秒".format(end_time - start_time))
    start_time = time.time()
    newList = merge(newList1)
    end_time = time.time()
    print("归并排序用时：{}秒".format(end_time - start_time))
    start_time = time.time()
    newList2 = shell(newList2)
    end_time = time.time()
    print("希尔排序用时：{}秒".format(end_time - start_time))

比较对100000条数据进行排序时快速排序、归并排序，希尔排序所用时间：

快速排序不够稳定，在最坏情况下耗时较长，当我们对700条数据进行排序时，可以发现快排是最慢的：

if __name__ == '__main__':
	import random
    import time
    import copy
    from merge import merge
    from shell import shell
    list = [random.randint(1, 10000000) for i in range(700)]
    list = quick(list)
    newList3 = copy.deepcopy(list)
    newList3.reverse()
    newList4 = copy.deepcopy(list)
    newList4.reverse()
    newList5 = copy.deepcopy(list)
    newList5.reverse()
    newList6 = copy.deepcopy(list)
    newList6.reverse()
    start_time = time.time()
    newList3 = merge(newList3)
    end_time = time.time()
    print("最坏情况下归并排序用时：{}秒".format(end_time - start_time))
    start_time = time.time()
    newList4 = shell(newList4)
    end_time = time.time()
    print("最坏情况下希尔排序用时：{}秒".format(end_time - start_time))
    start_time = time.time()
    newList5 = quick(newList5)
    end_time = time.time()
    print("最坏情况下快速排序用时：{}秒".format(end_time - start_time))

测试结果如下：