算法，排序，最全

2024年6月9日 178次阅读

一、算法概念

1、Algorithm：一个计算的过程，解决问题的方法
汉诺塔问题

def hanoi(n, a, b, c):
    if n > 0:
        hanoi(n-1, a, c, b)
        asd = '从%s到%s' % (a, c)
        list1.append(asd)
        hanoi(n-1, b, a, c)
        return len(list1)

二、查找

一、在一些数据元素中，通过一定的方法找出与给定关键字相同的数据元素的过程。
1、计算程序运行时间的装饰器

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

@cal_time
def linear_search(li,val):
    for ind, v in enumerate(li):
        if v == val:
            return ind
    else:
        return None

#二分查找函数
@cal_time
def binary_search(li,val):
    left = 0
    right = len(li) - 1
    while left <= right:
        mid = (left + right) // 2
        if li[mid] == val:
            return mid
        elif li[mid] > val:
            right = mid - 1
        else:
            left = mid + 1
    else:
        return None

调用比较

list2 = list(range(1000000))
linear_search(list2, 288888)
binary_search(list2, 288888)

三、一般排序

一、概念：将一组无序的记录调整为有序的记录
1、冒泡排序

def bubble_sort(li):
    for i in range(len(li)-1):
        exchage = False
        for k in range(len(li)-i-1):
            if li[k] > li[k+1]:
                li[k], li[k+1] = li[k+1], li[k]
                exchage = True
        if not exchage:
            return li
    return li

li = [6,2,12,1,32,34,24,3,4,134]
print(bubble_sort(li))

2、选择排序

def select_sort(li):
    for i in range(len(li)-1):
        min_loc = i
        for j in range(i+1,len(li)):
            if li[j] < li[min_loc]:
                min_loc = j
        if min_loc != i :
            li[min_loc],li[i] = li[i],li[min_loc]
    return li


li = [6,2,12,1,32,34,24,3,4,134]
print(select_sort(li))

3、插入排序法

#插入排序法
def insert_sort(li):
    for i in range(1, len(li)):       #摸到的牌的下标
        tmp = li[i]
        j = i-1
        while j >= 0 and tmp < li[j]:
            li[j+1] = li[j]
            j -= 1
        li[j+1] = tmp
    return li

li = [6,2,12,1,32,34,24,3,4,134]
print(insert_sort(li))

四、快速排序

一、快速排序

#第一次取中间值，左边小，右边大
def partition(li, left, right):
    tmp = li[left]
    while left < right:
        while li[right] > tmp and left < right:
            right -= 1
        li[left] = li[right]
        while li[left] < tmp and left < right:
            left += 1
        li[right] = li[left]
    li[left] = tmp
    return left


#快速排序框架，左边、右边分别调用，
def _quick_sort(li, left, right):
    if left < right:
        mid = partition(li, left, right)
        _quick_sort(li, left, mid-1)
        _quick_sort(li, mid+1, right)


#装饰器不能用在递归函数上，所以再写一个函数
@cal_time
def quick_sort(li):
    _quick_sort(li, 0, len(li)-1)


#创建一个乱序列表，调用看时间
li = list(range(10000))
random.shuffle(li)
quick_sort(li)
点赞