数据结构-学习笔记-快速排序

快速排序

• 左右指针的位置
• 递归
• 一般复杂度 O(nlogn) 每一层复杂度O(n),共有logn层
• 最坏复杂度O(n^2) 优化，随机选择一个数与第一个数交换位置
• 先选择一个数(可以是第一个数，也可以是其他位置的数，再跟第一个数交换位置)
• 从右边选择比其小的数放在左边指针位置，从左边选择比其大的数放置右边指针位置处，终止条件
• 算法框架

    def Quick_sort(li,left,right):
       终止条件(基例)
       mid = partion(li,left,right)
       Quick_sort(li,left,mid-1)
       Quick_sort(li,mid+1,right)

def partion(li,left,right):
    tem = li[left] # 选取一个临时值
    while left < right:
        while li[right] >= tem and left < right: # 从右选择小于tem的值
            right -= 1
        li[left] = li[right] # 放置左侧指针位置
        while li[left] <= tem and left < right: # 从左侧选择大于tem的值
            left += 1 
        li[right] = li[left] # 放置右侧指针的位置
    li[left] = tem
    return left

def Quick_sort(li,left,right):
    if left < right:
        mid = partion(li,left,right)
        Quick_sort(li,left,mid-1)
        Quick_sort(li,mid+1,right)
        
li = [5,3,6,8,2,9,4,1,7]
Quick_sort(li,0,len(li)-1)
print(li)

# result
[1, 2, 3, 4, 5, 6, 7, 8, 9]

时间复杂度对比

# 计算时间(函数)
import time 

def cal_time(func):
    def warpper(*args,**kwargs):
        t1 = time.time()
        result = func(*args,**kwargs)
        t2 = time.time()
        print("%s running time: %f secs." % (func.__name__, t2-t1))
        return result
    return warpper

import sys
import copy
import random

sys.setrecursionlimit(100000000) # 设置递归最大深度

@cal_time
def Bubble_sort(li):
    for i in range(len(li)-1):
        exchange = False
        for j in range(len(li)-i-1):
            if li[j] > li[j+1]:
                li[j], li[j+1] = li[j+1], li[j]
                exchange = True
        if not exchange:
            return
        
@cal_time
def _quick_sort(li):
    Quick_sort(li,0,len(li)-1)
    
li = list(range(1,10000))
random.shuffle(li)
li_1 = li.copy()
li_2 = li.copy()
Bubble_sort(li_1)
_quick_sort(li_2)

# result
Bubble_sort running time: 15.812118 secs.
_quick_sort running time: 0.029923 secs.