首页 > 代码库 > python自动开发之（算法）第二十七天

python自动开发之（算法）第二十七天

2024-09-07 05:55:27   215人阅读

 

1、什么是算法？

算法（Algorithm）：一个计算过程，解决问题的方法

2、复习：递归

递归的两个特点：（1） 调用自身 （2）结束条件

技术分享 
def func1(x):
    print(x)
    func1(x-1)

def func2(x):
    if x>0:
        print(x)
        func2(x+1)


def func3(x):
    if x>0:
        print(x)
        func3(x-1)

def func4(x):
    if x>0:
        func4(x-1)
        print(x)
View Code

func1和func2不是递归

func3和func4是递归，但是结果不一样，func3（5）打印的是5,4,3,2，1 而func4（5）结果是1,2,3,4,5

3、时间复杂度

时间复杂度：用来评估算法运行效率的一个东西

技术分享

技术分享

小结：

　　时间复杂度是用来估计算法运行时间的一个式子（单位）。

　　一般来说，时间复杂度高的算法比复杂度低的算法快。

　　常见的时间复杂度（按效率排序）

　　O(1)<O(logn)<O(n)<O(nlogn)<O(n2)<O(n2logn)<O(n3)

　　不常见的时间复杂度（看看就好）

　　O(n!) O(2n) O(nn) …

　　如何一眼判断时间复杂度？

　　循环减半的过程?O(logn)

　　几次循环就是n的几次方的复杂度

 4、空间复杂度

　　空间复杂度：用来评估算法内存占用大小的一个式子

5、列表查找

　　列表查找：从列表中查找指定元素

　　输入：列表、待查找元素

　　输出：元素下标或未查找到元素

6、顺序查找

　　 从列表第一个元素开始，顺序进行搜索，直到找到为止。

7、二分查找

　　从有序列表的候选区data[0:n]开始，通过对待查找的值与候选区中间值的比较，可以使候选区减少一半。

技术分享 
def bin_search(data_set,val):
    ‘‘‘
    mid：下标
    low：每次循环的列表最左边下标
    high：每次循环的列表最右边下标
    :param data_set:列表
    :param val: 要找的值
    :return:
    ‘‘‘
    low = 0
    high = len(data_set)-1
    while low <= high:
        mid = (low+high)//2
        if data_set[mid] == val:
            return mid
        elif data_set[mid] > val:
            high = mid - 1
        else:
            low = mid + 1
    return
View Code

8、列表排序

　　将无序列表变为有序列表

　　应用场景： 各种榜单 各种表格 给二分查找用 给其他算法用

　　输入：无序列表

　　输出：有序列表

9、排序中比较慢的三种： 冒泡排序 选择排序 插入排序

　  快速排序

　  排序NB二人组： 堆排序 归并排序

     没什么人用的排序： 基数排序 希尔排序 桶排序

　　算法关键点： 有序区 无序区

10、冒泡排序

　　首先，列表每两个相邻的数，如果前边的比后边的大，那么交换这两个数

　　n = len(list),循环了i趟（i=n-1），第i趟循环比较了(j = n-i-1 )次，j是每趟循环比较的次数　

技术分享 
import random,time

#装饰器
def cal_time(func):
    def wrapper(*args,**kwargs):
        t1 = time.time()
        ret = func(*args,**kwargs)
        t2 = time.time()
        print(‘time cost: %s \r\nfunc from %s‘%(t2-t1,func.__name__))
        return func
    return wrapper

@cal_time
def bubble_sort(li):
    for i in range(len(li) - 1):
        for j in range(len(li) - i - 1):
            #升续
            if li[j] > li[j+1]:
                li[j],li[j+1]=li[j+1],li[j]
            #降续
            # if li[j] < li[j+1]:
            #     li[j],li[j+1]=li[j+1],li[j]



data = list(range(1000))
random.shuffle(data)
print(data)
bubble_sort(data)
print(data)
View Code

　　优化后的冒泡排序：

　　　　如果冒泡排序中执行一趟而没有交换，则列表已经是有序状态，可以直接结束算法。

技术分享 
import random,time

#装饰器
def cal_time(func):
    def wrapper(*args,**kwargs):
        t1 = time.time()
        ret = func(*args,**kwargs)
        t2 = time.time()
        print(‘time cost: %s \r\nfunc from %s‘%(t2-t1,func.__name__))
        return func
    return wrapper

@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 li[j] < li[j+1]:
            #     li[j],li[j+1]=li[j+1],li[j]
            #     exchange = True
        #这里是指上一趟，值之间没有发生交换，就退出循环
        if not exchange:
            break


data = list(range(1000))
random.shuffle(data)
print(data)
bubble_sort(data)
print(data)
View Code

11、选择排序

　　一趟遍历记录最小的数，放到第一个位置； 再一趟遍历记录剩余列表中最小的数，继续放置；

技术分享 
import random,time

#装饰器
def cal_time(func):
    def wrapper(*args,**kwargs):
        t1 = time.time()
        ret = func(*args,**kwargs)
        t2 = time.time()
        print(‘time cost: %s --> \nfunc from %s‘%(t2-t1,func.__name__))
        return func
    return wrapper

@cal_time
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
        li[i],li[min_loc] = li[min_loc],li[i]
View Code

12、插入排序

技术分享 
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
View Code

13、练习 用冒泡法把打乱的带ID的信息表排序

技术分享 
import random


def random_list(n):
    ids = range(1000,1000+n)
    result = []
    a1 = ["王","陈","李","赵","钱","孙","武"]
    a2 = ["丹","泽","","","晶","杰","金"]
    a3 = ["强","华","国","富","宇","齐","星"]
    for i in range(n):
        age = random.randint(16,38)
        id = ids[i]
        name = ‘%s%s%s‘%(random.choice(a1),random.choice(a2),random.choice(a3))
        dic = {}
        dic[‘id‘] = id
        dic[‘姓名‘] = name
        dic[‘年龄‘] = age
        result.append(dic)
    return result


def bubble_sort(li):
    for i in range(len(li)-1):
        for j in range(len(li)-i-1):
            if li[j][‘id‘] > li[j+1][‘id‘]:
                li[j],li[j+1] = li[j+1],li[j]

data1 = random_list(100)
random.shuffle(data1)
print(data1)
bubble_sort(data1)
print(data1)
View Code

 

　　

 

python自动开发之（算法）第二十七天


联系
我们