数据结构与算法1：引入概念

程序员老五

已于 2023-05-10 16:27:18 修改

阅读量229

点赞数 1

分类专栏：数据结构与算法【Python】文章标签： python 数据结构算法

于 2023-05-09 11:47:29 首次发布

本文链接：https://blog.csdn.net/weixin_45579026/article/details/130572507

版权

数据结构与算法【Python】专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章通过求解a+b+c=1000且a^2+b^2=c^2的组合问题，展示了算法优化的重要性，从直接使用for循环的低效方法到通过减少循环次数和利用条件简化算法的高效方法。讨论了算法的五性、时间复杂度和大O记法，强调了在算法设计中考虑最坏时间复杂度的必要性，并通过Python内置类型操作的性能分析，进一步阐述了数据结构选择对效率的影响。

摘要由CSDN通过智能技术生成

接下来系统的学一下数据结构与算法的知识，本章节是第一部分：数据结构与算法的进入与基本概述

第一章：引入概念

【铁打的算法demo】

先来看到题：

如果 a + b + c = 1000，且 a² + b² = c²（a, b , c 为⾃然数），如何求出所有 a、b、c 可能的组合?

方法一：直接干

思路：既然 a + b + c = 1000，说明 a、b、c 都在 0 ~ 1000 之内（不考虑负数），则可以用 for 循环 + if 直接写代码

# 导入time，用来计时运行程序所耗时间
import time

start = time.time()

for a in range(1000):
    for b in range(1000):
        for c in range(1000):
            if a ** 2 + b ** 2 == c ** 2 and a + b + c == 1000:
                print('a, b, c：%d, %d, %d' % (a, b, c))

end = time.time()
print('耗时：%fs.'.format(end - start))

运行结果：

a, b, c：0, 500, 500
a, b, c：200, 375, 425
a, b, c：375, 200, 425
a, b, c：500, 0, 500
耗时：251.520628s.

方法二：想想如何优化代码

优化一：优化 b 的 for 循环 for b in range(1000 - a)

a b 都在 0 ~ 1000 之内，a 循环范围是 0 ~ 1000，则循环 b 时可在此基础上用 1000 - a 即可，没必要再从 0 到 1000 循环一遍，因为 a b c 三者之和才只有 1000，如果 a = 500，循环到 b >= 500 时，会在后面判断 a ** 2 + b ** 2 == c ** 2 时被过滤掉（从结果看 c 也不能是 0，不符合逻辑），从而造成多余的没必要的循环，白白浪费资源，还拉长运行时间

优化二：优化 c 去掉for循环，改为 1000 - a - b

一共三个数，在循环两个数后，第三个数就是 1000 减掉前两个数，相比于再 for 循环一遍，使用它们共同的和减掉前两个数得到第三个数的方式更简单，且是由 1000 的量级直接降到一个简单的减法了，还省去了后续的一个 if 判断

优化后的代码：

import time

start = time.time()

for a in range(1000):
    for b in range(1000):
        c = 1000 - a - b
        if a ** 2 + b ** 2 == c ** 2:
            print('a, b, c：%d, %d, %d' % (a, b, c))

end = time.time()

print('耗时：%fs.' % (end - start))

运行结果：

a, b, c：0, 500, 500
a, b, c：200, 375, 425
a, b, c：375, 200, 425
a, b, c：500, 0, 500
耗时：0.510947s

发现执行时间明显缩短了！

1. 算法的概念

算法是计算机处理信息的本质，因为计算机程序本质上是⼀个算法来告诉计算机确切的步骤来执⾏⼀个指定的任务。⼀般地，当算法在处理信息时，会从输⼊设备或数据的存储地址读取数据，把结果写⼊输出设备或某个存储地址供以后再调⽤。算法是独⽴存在的⼀种解决问题的⽅法和思想。对于算法⽽⾔，实现的语⾔并不重要，重要的是思想。算法可以有不同的语⾔描述实现版本（如C描述、C++描述、Python描述等），我们现在是在⽤ Python 语⾔进⾏描述实现。

2. 算法的五⼤特性

输⼊: 算法具有 0 个或多个输⼊
输出: 算法⾄少有 1 个或多个输出
有穷性: 算法在有限的步骤之后会⾃动结束⽽不会⽆限循环，并且每⼀个步骤可以在可接受的时间内完成
确定性：算法中的每⼀步都有确定的含义，不会出现⼆义性
可⾏性：算法的每⼀步都是可⾏的，也就是说每⼀步都能够执⾏有限的次数完成

3. 算法效率衡量

1. 执⾏时间反应算法效率

对于同⼀问题，我们给出了两种解决算法，在两种算法的实现中，我们对程序执⾏的时间进⾏了测算，发现两段程序执⾏的时间相差悬殊，由此我们可以得出结论：实现算法程序的执⾏时间可以反映出算法的效率，即算法的优劣。

2. 单靠时间值绝对可信吗？

假设我们将第⼆次尝试的算法程序运⾏在⼀台配置古⽼性能低下的计算机中，情况会如何？很可能运⾏的时间并不会⽐在我们的电脑中运⾏算法⼀的 214.583347秒快多少。
单纯依靠运⾏的时间来⽐较算法的优劣并不⼀定是客观准确的！
程序的运⾏离不开计算机环境（包括硬件和操作系统），这些客观原因会影响程序运⾏的速度并反应在程序的执⾏时间上。那么如何才能客观的评判⼀个算法的优劣呢？

3. 时间复杂度与 “⼤O记法”

我们假定计算机执⾏算法每⼀个基本操作的时间是固定的⼀个时间单位，那么有多少个基本操作就代表会花费多少时间单位。显然对于不同的机器环境⽽⾔，确切的单位时间是不同的，但是对于算法进⾏多少个基本操作（即花费多少时间单位）在规模数量级上却是相同的，由此可以忽略机器环境的影响⽽客观的反应算法的时间效率。对于算法的时间效率，我们可以⽤ “⼤O记法” 来表示。

“⼤O记法”：对于单调的整数函数 f，如果存在⼀个整数函数 g 和实常数 c>0，使得对于充分⼤的 n 总有 f(n)<=c*g(n) ，就说函数 g 是 f 的⼀个渐近函数（忽略常数），记为 f(n)=O(g(n))。也就是说，在趋向⽆穷的极限意义下，函数 f 的增⻓速度受到函数 g 的约束，亦即函数 f 与函数 g 的特征相似。

时间复杂度：假设存在函数 g，使得算法 A 处理规模为 n 的问题示例所⽤时间为 T(n)=O(g(n))，则称 O(g(n)) 为算法 A 的渐近时间复杂度，简称时间复杂度，记为T(n)

4. 如何理解“⼤O记法”

对于算法进⾏特别具体的细致分析虽然很好，但在实践中的实际价值有限。对于算法的时间性质和空间性质，最重要的是其数量级和趋势，这些是分析算法效率的主要部分。⽽计量算法基本操作数量的规模函数中那些常量因⼦可以忽略不计。例如，可以认为 3n² 和 100n² 属于同⼀个量级，如果两个算法处理同样规模实例的代价分别为这两个函数，就认为它们的效率 “差不多”，都为 n² 级。

5. 最坏时间复杂度

分析算法时，存在⼏种可能的考虑：

算法完成⼯作最少需要多少基本操作，即最优时间复杂度
算法完成⼯作最多需要多少基本操作，即最坏时间复杂度
算法完成⼯作平均需要多少基本操作，即平均时间复杂度

分析：

对于最优时间复杂度，其价值不⼤，因为它没有提供什么有⽤信息，其反映的只是最乐观最理想的情况，没有参考价值；
对于最坏时间复杂度，提供了⼀种保证，表明算法在此种程度的基本操作中⼀定能完成⼯作；
对于平均时间复杂度，是对算法的⼀个全⾯评价，因此它完整全⾯的反映了这个算法的性质。但另⼀⽅⾯，这种衡量并没有保证，不是每个计算都能在这个基本操作内完成。⽽且，对于平均情况的计算，也会因为应⽤算法的实例分布可能并不均匀⽽难以计算。

因此，我们主要关注算法的最坏情况，亦即最坏时间复杂度。

6. 时间复杂度的⼏条基本计算规则

基本操作，即只有常数项，认为其时间复杂度为 O(1)
顺序结构，时间复杂度按加法进⾏计算
循环结构，时间复杂度按乘法进⾏计算
分⽀结构，时间复杂度取最⼤值
判断⼀个算法的效率时，往往只需要关注操作数量的最⾼次项，其它次要项和常数项可以忽略
在没有特殊说明时，我们所分析的算法的时间复杂度都是指最坏时间复杂度

7. 空间复杂度

类似于时间复杂度的讨论，⼀个算法的空间复杂度S(n)定义为该算法所耗费的存储空间，它也是问题规模n的函数。
渐近空间复杂度也常常简称为空间复杂度。
空间复杂度(SpaceComplexity) 是对⼀个算法在运⾏过程中临时占⽤存储空间⼤⼩的量度。
算法的时间复杂度和空间复杂度合称为算法的复杂度。

4. 算法分析

第⼀次尝试的算法核⼼部分

for a in range(0, 1001):
	for b in range(0, 1001):
		for c in range(0, 1001):
			if a**2 + b**2 == c**2 and a+b+c == 1000:
				print("a, b, c: %d, %d, %d" % (a, b, c))

时间复杂度：T(n) = O(n*n*n) = O(n3)

第⼆次尝试的算法核⼼部分

for a in range(0, 1001):
	for b in range(0, 1001 - a):
		c = 1000 - a - b if a**2 + b**2 == c**2:
			print("a, b, c: %d, %d, %d" % (a, b, c))

时间复杂度： T(n) = O(n*n*(1+1)) = O(n*n) = O(n2)

由此可⻅，我们尝试的第⼆种算法要⽐第⼀种算法的时间复杂度好多的。

5. 常⻅时间复杂度

执⾏次数函数举例	阶	⾮正式术语
12	O(1)	常数阶
2n+3	O(n)	线性阶
3n²+2n+1	O(n²)	平⽅阶
5log₂n+20	O(logn)	对数阶
2n+3nlog₂n+19	O(nlogn)	nlogn阶
6n³+2n²+3n+4	O(n³)	⽴⽅阶
2ⁿ	O(2ⁿ)	指数阶

注意，经常将 log₂n（以 2 为底的对数）简写成 logn

常⻅时间复杂度之间的关系为：

在这里插入图片描述
所消耗的时间从⼩到⼤：

O(1) < O(logn) < O(n) < O(nlogn) < O(n²) < O(n³) < O(2ⁿ) < O(n!) < O(nⁿ)

6. Python内置类型性能分析

1. timeit 模块

timeit 模块可以⽤来测试⼀⼩段 Python 代码的执⾏速度

class timeit.Timer(stmt=‘pass’, setup=‘pass’, timer=<timer function>)

参数说明：

Timer 是测量⼩段代码执⾏速度的类
stmt 参数是要测试的代码语句（statment）
setup 参数是运⾏代码时需要的设置
timer 参数是⼀个定时器函数，与平台有关

timeit.Timer.timeit(number=1000000)

Timer 类中测试语句执⾏速度的对象⽅法。number 参数是测试代码时的测试次数，默认为 1000000 次。⽅法返回执⾏代码的平均耗时，⼀个 float 类型的秒数

2. list 的操作测试

1. 添加元素的四种方式效率比较

from timeit import Timer

def t1():
    l = []
    for i in range(1000):
        l = l + [i]

def t2():
    l = []
    for i in range(1000):
        l.append(i)

def t3():
    l = [i for i in range(1000)]

def t4():
    l = list(range(1000))

timer1 = Timer("t1()", "from __main__ import t1")
print("concat", timer1.timeit(number=1000), "s")
timer2 = Timer("t2()", "from __main__ import t2")
print("append", timer2.timeit(number=1000), "s")
timer3 = Timer("t3()", "from __main__ import t3")
print("comprehension", timer3.timeit(number=1000), "s")
timer4 = Timer("t4()", "from __main__ import t4")
print("list_range", timer4.timeit(number=1000), "s")

'''
concat 1.0436126479980885 s
append 0.08462878499994986 s
comprehension 0.03660322499490576 s
list_range 0.014424725006392691 s
'''

2. 删除元素的两种方式效率比较

从结果可以看出，pop 最后⼀个元素的效率远远⾼于 pop 第⼀个元素

x = list(range(2000000))
pop_zero = Timer("x.pop(0)", "from __main__ import x")
print("pop_zero", pop_zero.timeit(number=1000), "s")
y = list(range(2000000))
pop_end = Timer("y.pop()", "from __main__ import y")
print("pop_end", pop_end.timeit(number=1000), "s")

'''
pop_zero 0.9256400320009561 s
pop_end 9.138700261246413e-05 s
'''

3. list 内置操作的时间复杂度

在这里插入图片描述

4. dict 内置操作的时间复杂度

在这里插入图片描述

7. 数据结构

我们如何⽤Python中的类型来保存⼀个班的学⽣信息？如果想要快速的通过学⽣姓名获取其信息呢？

实际上当我们在思考这个问题的时候，我们已经⽤到了数据结构。列表和字典都可以存储⼀个班的学⽣信息，但是想要在列表中获取⼀名同学的信息时，就要遍历这个列表，其时间复杂度为 O(n)，⽽使⽤字典存储时，可将学⽣姓名作为字典的键，学⽣信息作为值，进⽽查询时不需要遍历便可快速获取到学⽣信息，其时间复杂度为 O(1)。

我们为了解决问题，需要将数据保存下来，然后根据数据的存储⽅式来设计算法实现进⾏处理，那么数据的存储⽅式不同就会导致需要不同的算法进⾏处理。我们希望算法解决问题的效率越快越好，于是我们就需要考虑数据究竟如何保存的问题，这就是数据结构。

在上⾯的问题中我们可以选择 Python 中的列表或字典来存储学⽣信息。列表和字典就是 Python 内建帮我们封装好的两种数据结构。

1. 概念

数据是⼀个抽象的概念，将其进⾏分类后得到程序设计语⾔中的基本类型。如：int，float，char 等。数据元素之间不是独⽴的，存在特定的关系，这些关系便是结构。

数据结构指数据对象中数据元素之间的关系。 Python 给我们提供了很多现成的数据结构类型，这些系统⾃⼰定义好的，不需要我们⾃⼰去定义的数据结构叫做 Python 的内置数据结构，⽐如列表、元组、字典。⽽有些数据组织⽅式，Python 系统⾥⾯没有直接定义，需要我们⾃⼰去定义实现这些数据的组织⽅式，这些数据组织⽅式称之为 Python 的扩展数据结构，⽐如栈，队列等。

2. 算法与数据结构的区别

数据结构只是静态的描述了数据元素之间的关系。
⾼效的程序需要在数据结构的基础上设计和选择算法。

程序 = 数据结构 + 算法
总结：算法是为了解决实际问题⽽设计的，数据结构是算法需要处理的问题载体

3. 抽象数据类型(Abstract Data Type)

抽象数据类型(ADT) 的含义是指⼀个数学模型以及定义在此数学模型上的⼀组操作。即把数据类型和数据类型上的运算捆在⼀起，进⾏封装。引⼊抽象数据类型的⽬的是把数据类型的表示和数据类型上运算的实现与这些数据类型和运算在程序中的引⽤隔开，使它们相互独⽴。

最常⽤的数据运算有五种：

插⼊
删除
修改
查找
排序

程序员老五

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
数据结构与算法1：引入概念

抽象数据类型(ADT) 的含义是指⼀个数学模型以及定义在此数学模型上的⼀组操作。即把数据类型和数据类型上的运算捆在⼀起，进⾏封装。引⼊抽象数据类型的⽬的是把数据类型的表示和数据类型上运算的实现与这些数据类型和运算在程序中的引⽤隔开，使它们相互独⽴。插⼊删除修改查找排序。
复制链接

扫一扫