快速排序 及与冒泡排序比较

快速排序基本思路

1、先从数列中取出一个数作为基准数

2、分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边

3、再对左右区间重复第二步，直到各区间只有一个数

快排操作过程

import random
def partition(arr,left,right):
    tmp = arr[left]
    while left < right:
        while left<right and arr[right] >=tmp:#从右边找找比tmp小的数
            right -= 1 #向左移1位
        arr[left] = arr[right]#把右边的值写到左边空位上
        print(arr,'right')
        while left<right and arr[left] <= tmp:
            left += 1
        arr[right] = arr[left]#把左边的值写到右边空位上
        print(arr,'left')
    arr[left]=tmp #把tmp归位

    return left
arr=[random.randint(0,10000) for i in range(10)]
print('----------------------左右互换操作-----------------------')
print(arr)
partition(arr,0,len(arr)-1)
print(arr)

print('-----------------------快排操作-------------------------')
def quick_sort(arr,left,right):  
    if left < right: #至少两个元素
        mid = partition(arr,left,right)  
        quick_sort(arr,left,mid-1)  
        quick_sort(arr,mid+1,right) 


quick_sort(arr,0,len(arr)-1)

代码实现

import random
def partition(arr,left,right):
    tmp = arr[left]
    while left < right:
        while left<right and arr[right] >=tmp:#从右边找找比tmp小的数
            right -= 1 #向左移1位
        arr[left] = arr[right]#把右边的值写到左边空位上
        while left<right and arr[left] <= tmp:
            left += 1
        arr[right] = arr[left]#把左边的值写到右边空位上  
    arr[left]=tmp #把tmp归位
    return left
def quick_sort(arr,left,right):  
    if left < right: #至少两个元素
        mid = partition(arr,left,right)  
        quick_sort(arr,left,mid-1)  
        quick_sort(arr,mid+1,right) 

arr = [random.randint(0,10000) for i in range(10)]

quick_sort(arr,0,len(arr)-1)
print(arr)

快速排序的效率

时间复杂度O(nlog(n))

快排与冒泡排序的比较

计算执行时间函数代码（execution_time.py）

import time

def execution_time(func):
	def wraper(*args,**kwargs):
		t1 = time.time()
		result = func(*args,**kwargs)
		t2 = time.time()
		print('%s running time %s　second' % (func.__name__, t2-t1))
		return result
	return wraper

执行时间比较函数

from execution_time import * 
import random 
import copy

#冒泡排序
@execution_time
def bubble_sort(arr):
    n = len(arr)
    for i in range(n-1):
        exchange = True#交换为
        for j in range(n-i-1):
            if arr[j]>arr[j+1]:
                arr[j],arr[j+1]=arr[j+1],arr[j]  
                exchange = False        
        print(arr)
        if exchange:
            return

#快速排序
def partition(arr,left,right):
    tmp = arr[left]
    while left < right:
        while left<right and arr[right] >=tmp:#从右边找找比tmp小的数
            right -= 1 #向左移1位
        arr[left] = arr[right]#把右边的值写到左边空位上
        while left<right and arr[left] <= tmp:
            left += 1
        arr[right] = arr[left]#把左边的值写到右边空位上  
    arr[left]=tmp #把tmp归位
    return left

def _quick_sort(arr,left,right):  
    if left < right: #至少两个元素
        mid = partition(arr,left,right)  
        _quick_sort(arr,left,mid-1)  
        _quick_sort(arr,mid+1,right) 

@execution_time
def quick_sort(arr):
    _quick_sort(arr,0,len(arr)-1)


arr = list(range(10000))
random.shuffle(arr)

arr1 = copy.deepcopy(arr)#深拷贝
arr2 = copy.deepcopy(arr)

bubble_sort(arr1)
quick_sort(arr2)
print(arr1)
print(arr2)

快速排序的问题:

• 最坏情况（倒序排序的列表，每次只少一个数，时间复杂度为O(n**2)）
• 递归（浪费系统资源）