Python基础:算法（非常详细）_python算法

一、简介

定义和特征

定义：算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。如果一个算法有缺陷，或不适合于某个问题，执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。

一个算法应该具有以下五个重要的特征：

• 有穷性：算法的有穷性是指算法必须能在执行有限个步骤之后终止；

• 确切性：算法的每一步骤必须有确切的定义；

• 输入项：一个算法有0个或多个输入，以刻画运算对象的初始情况，所谓0个输入是指算法本身定出了初始条件；

• 输出项：一个算法有一个或多个输出，以反映对输入数据加工后的结果，没有输出的算法是毫无意义的；

• 可行性：算法中执行的任何计算步骤都是可以被分解为基本的可执行的操作步，即每个计算步都可以在有限时间内完成（也称之为有效性）。

设计要求

算法设计的要求:

• 确定性: 指的是算法至少应该有输入,输出和加工处理无歧义性，能正确反映问题的需求,能够得到问题的正确答案。确定性大体分为四个层次:

1.算法程序无语法错误;

2.算法程序对于合法的输入产生满足要求的输出;

3.对于非法输入能够产生满足规格的说明;

4.算法程序对于故意***难的测试输入都有满足要求的输出结果。

• 可读性: 程序便于阅读,理解交流。
• 健壮性: 当输入数据不合法时,算法也能作出相关处理，而不是产生异常,崩溃或者莫名其妙的结果。
• 时间效率高和存储量低。

算法效率的度量方法

事后统计方法：主要是通过设计好的测试程序和数据，利用计算机计时器对不同算法编制的程序的运行时间进行比较，从而确定算法效率的高低，但这种方法有很大缺陷，一般不予采纳。

事前分析估算方法：在计算机程序编制前，依据统计方法对算法进行估算。

一个用高级语言编写的程序在计算机上运行时所消耗的时间取决于以下因素：

1. 算法采用的策略，方法；（算法好坏的根本）
2. 编译产生的代码质量；（由软件来支持）
3. 问题的输入规模；（由数据决定）
4. 机器执行指令的速度。（看硬件的性能）

算法时间复杂度

定义：在进行算法分析时，语句总的执行次数T(n)是关于问题规模n的函数，进而分析T(n)随n的变化情况并确定T(n)的数量级。算法的时间复杂度，也就是算法的时间量度，记作：T(n}=0(f(n))。它表示随问题规模n的增大，算法执行时间的埔长率和 f(n)的埔长率相同，称作算法的渐近时间复杂度，简称为时间复杂度。其中f( n)是问题规横n的某个函数。

根据定义，求解算法的时间复杂度的具体步骤是：

⑴ 找出算法中的基本语句；

算法中执行次数最多的那条语句就是基本语句，通常是最内层循环的循环体。
　　⑵ 计算基本语句的执行次数的数量级；
　　只需计算基本语句执行次数的数量级，这就意味着只要保证基本语句执行次数的函数中的最高次幂正确即可，可以忽略所有低次幂和最高次幂的系数。这样能够简化算法分析，并且使注意力集中在最重要的一点上：增长率。
　　⑶ 用大Ο记号表示算法的时间性能。
　　将基本语句执行次数的数量级放入大Ο记号中。

如何推导大o阶呢？下面是基本的推导方法：

1.用常数1取代运行时间中的所有加法常数。
　　2.在修改后的运行次数函数中，只保留最髙阶项。
　　3.如果最高阶项存在且不是1,则去除与这个项相乘的常数。

简单的说，就是保留求出次数的最高次幂，并且把系数去掉。 如T(n)=n2+n+1 =O(n2)

一些例子

######复杂度O(1)
print("this is wd")


######复杂度O(n)
for i in range(n):
    print(i)


######复杂度O(n2)
for i in range(n):
    for j in range(n):
        print(j)


######复杂度O(n3)
for i in range(n):
    for j in range(n):
        for k in range(n):
            print('wd')



######复杂度O(log2n)
while n > 1:
    print(n)
    n = n // 2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

常见的复杂度按效率排序：O(1)<O(logn)<O(n)<O(nlogn)<O(n2)<O(2nlogn)<O(n2)

空间复杂度

空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度。一个算法在计算机存储器上所占用的存储空间，包括存储算法本身所占用的存储空间，算法的输入输出数据所占用的存储空间和算法在运行过程中临时占用的存储空间这三个方面。算法的输入输出数据所占用的存储空间是由要解决的问题决定的，是通过参数表由调用函数传递而来的，它不随本算法的不同而改变。存储算法本身所占用的存储空间与算法书写的长短成正比，要压缩这方面的存储空间，就必须编写出较短的算法。算法在运行过程中临时占用的存储空间随算法的不同而异，有的算法只需要占用少量的临时工作单元，而且不随问题规模的大小而改变，这种算法是节省存储的算法；有的算法需要占用的临时工作单元数与解决问题的规模n有关，它随着n的增大而增大，当n较大时，将占用较多的存储单元。

如当一个算法的空间复杂度为一个常量，即不随被处理数据量n的大小而改变时，可表示为O(1)；当一个算法的空间复杂度与以2为底的n的对数成正比时，可表示为0(log2n)；当一个算法的空间复杂度与n成线性比例关系时，可表示为0(n).若形参为数组，则只需要为它分配一个存储由实参传送来的一个地址指针的空间，即一个机器字长空间；若形参为引用方式，则也只需要为其分配存储一个地址的空间，用它来存储对应实参变量的地址，以便由系统自动引用实参变量。

二、python中的常见算法

冒泡排序

效率：O(n2)

原理：

1. 比较相邻的元素，如果第一个比第二个大，就交换他们两个；
2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。做完以后，最后的元素会是最大的数，这里可以理解为走了一趟；
3. 针对所有的元素重复以上的步骤，除了最后一个；
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较，最后数列就是从大到小一次排列；

# 基本冒泡排序
arr = [1, 3, 56, 34, 45, 32, 2, 34, 45, 67]
 
def bubble_sort1(arr):
    # 外层循环累计排序轮数，同时控制待排序数组的上边界，即A[0..i]为待排序部分
    # 内层循环扫描A[0..i-1]，比较相邻元素，并通过交换元素值的方式将最大值放到最后一位
    for i in range(len(arr)-1,0,-1):  # 趟数
        # print("arr[%d]=%s" % (i,arr[i]))
        for index in range(len(arr) - i - 1):  # 遍历数据，依次交换
            if arr[index] > arr[index + 1]:
                arr[index], arr[index + 1] = arr[index + 1], arr[index]
bubble_sort1(arr)
print(arr)
1
2
3
4
5
6
7
8
9
10
11
12
13

优化版本：当某一趟走完以后发现并没有进行数据交换，那么此时的数列已经排列好了，没有必要在进行下去。例如：极端情况下，数列本来已经排序好的，我们只需要走一趟即可完成排序。

# 算法二：冒泡排序改进，设置交换操作标志
def bubble_sort2(arr):
    for i in range(len(arr) - 1, 0, -1): #趟数
        swapFlag = False  # 先假设未做交换
        for j in range(0, i):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                swapFlag = True  # 改变交互操作标志
        if swapFlag == False:
            break  # 无交换操作，表示已完成排序，退出循环也可以写成if not swapFlag:
    return i  # 返回循环的次数
bubble_sort2(arr)
print(arr)
1
2
3
4
5
6
7
8
9
10
11
12
13

选择排序

效率：O(n2)

原理：

1. 每一次从待排序的列表中选出一个元素，并将其与其他数依次比较，若列表中的某个数比选中的数小，则交换位置，把所有数比较完毕，则会选出最小的数，将其放在最左边（这一过程称为一趟）；
2. 重复以上步骤，直到全部待排序的数据元素排完；

def select_sort(lists):
    """
    选择排序
    :param data: 待排序的数据列表
    :return:
    """
    for i in range(len(lists) - 1):  # 趟数
        min_value = i  # 记录i趟开始最小数的索引
        for j in range(i + 1, len(lists)):  # 每一次趟需要循环的次数
            if lists[min_value] > lists[j]:  # 当数列中的某一个数比开始的数要小时候，更新最小值索引位置
                min_value = j
                # 一趟走完，交换最小值的位置，第一趟最小
                lists[min_value], lists[i] = lists[i], lists[min_value]
    return lists
 
 
print(select_sort(arr))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

插入排序

效率：O(n2)

原理：

1. 以从小到大排序为例，元素0为第一个元素，插入排序是从元素1开始，尽可能插到前面。
2. 插入时分插入位置和试探位置，元素i的初始插入位置为i，试探位置为i-1，在插入元素i时，依次与i-1,i-2······元素比较，如果被试探位置的元素比插入元素大，那么被试探元素后移一位，元素i插入位置前移1位，直到被试探元素小于插入元素或者插入元素位于第一位。
3. 重复上述步骤，最后完成排序

def insert_sort(data):
    """
    插入排序
    :param data: 待排序的数据列表
    :return:
    """
    for i in range(1, len(data)): # 无序区域数据
        tmp = data[i] # 第i次插入的基准数
        for j in range(i, -1, -1):
            if tmp < data[j - 1]:  # j为当前位置，试探j-1位置
                data[j] = data[j - 1]  #  移动当前位置
            else:  # 位置确定为j
                break
        data[j] = tmp  # 将当前位置数还原print(select_sort(arr))
1
2
3
4
5
6
7
8
9
10
11
12
13
14

第二种：

def insert_sort(arr):
    """
    插入排序
    :param data: 待排序的数据列表
    :return:
    """
    for i in range(len(arr)):
        preindex = i - 1
        current = arr[i]
        while preindex >= 0 and arr[preindex] > current:
            arr[preindex + 1] = arr[preindex]
            preindex -= 1
        arr[preindex + 1] = current
    return arr
 
 
print(insert_sort(arr))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

快速排序

效率:平均O(nlogn)

原理：

1. 从数列中随机挑选出一个数作为基数；
2. 重新排列数列，使得比基数小的元素在左边，比基数大元素在右边，相等的元素放左边或者右边都可以，最后使得该基数在处于数列中间位置，这个称为分区操作；
3. 递归上述操作，完成排序，如下如；

arr = [1, 3, 56, 34, 45, 32, 2, 34, 45, 67]
 
def quick_sort(data,left,right):
    """
    快速排序
    :param data: 待排序的数据列表
    :param left: 基准数左边元素的索引
    :param right: 基准数右边元素的索引
    :return:
    """
    if left < right:
        mid = partition(data,left,right)  # 分区操作,mid代表基数所在的索引
        quick_sort(data,left,mid-1)   # 对基准数前面进行排序
        quick_sort(data,mid+1,right)  # 对基准数后面进行排序
 
 
def partition(data,left,right):
    tmp=data[left]  # 随机选择的基准数,从最左边开始选
    while left < right:
        while left < right and data[right] >= tmp:  # 右边的数比基准数大
            right-=1  # 保留该数，然后索引指针往左移动
        data[left]=data[right]   # 否则此时右边数比基数小，则将该数放到基准位置
        while left < right and data[left] <= tmp: # 右边的数比基准数小
            left+=1  # 此时保持该数位置不动，索引指针往前移动
        data[right]=data[left]  # 否则此时左边的数比基数大，则将该数放到右边
    data[left] = tmp  # 最后将基准数量放回中间
    return left  # 返回基准数位置
 
if __name__=='__main__':
    quick_sort(arr,0,len(arr)-1)
    print(arr)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

以上就是今天的全部内容分享，觉得有用的话欢迎点赞收藏哦！

Python经验分享

学好 Python 不论是用于就业还是做副业赚钱都不错，而且学好Python还能契合未来发展趋势——人工智能、机器学习、深度学习等。
小编是一名Python开发工程师，自己整理了一套最新的Python系统学习教程，包括从基础的python脚本到web开发、爬虫、数据分析、数据可视化、机器学习等。如果你也喜欢编程，想通过学习Python转行、做副业或者提升工作效率，这份【最新全套Python学习资料】 一定对你有用！

小编为对Python感兴趣的小伙伴准备了以下籽料 ！

对于0基础小白入门：

如果你是零基础小白，想快速入门Python是可以考虑培训的！

• 学习时间相对较短，学习内容更全面更集中
• 可以找到适合自己的学习方案

包括：Python激活码+安装包、Python web开发，Python爬虫，Python数据分析，人工智能、机器学习、Python量化交易等学习教程。带你从零基础系统性的学好Python！

一、Python所有方向的学习路线

Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

二、学习软件

工欲善其事必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。

三、入门学习视频

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。

四、实战案例

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

五、面试资料

我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

最新全套【Python入门到进阶资料 & 实战源码 &安装工具】（安全链接，放心点击）

我已经上传至CSDN官方，如果需要可以扫描下方官方二维码免费获取【保证100%免费】

*今天的分享就到这里，喜欢且对你有所帮助的话，记得点赞关注哦~下回见 ！