第 一 章 数 据 结 构
数据结构与算法概述(Python)
Why?
我们举一个可能不太恰当的例子：
如果将最终写好运行的程序比作战场，我们码农便是指挥作战的将军，而我们所写的代码 便是士兵和武器。
那么数据结构和算法是什么?答曰：兵法!
我们可以不看兵法在战场上肉搏，如此，可能会胜利，可能会失败。即使胜利，可能也会 付出巨大的代价。我们写程序亦然：没有看过数据结构和算法，有时面对问题可能会没有任何思
路，不知如何下手去解决；大部分时间可能解决了问题，可是对程序运行的效率和开销没有意识， 性能低下；有时会借助别人开发的利器暂时解决了问题，可是遇到性能瓶颈的时候，又不知该如何 进行针对性的优化。
如果我们常看兵法，便可做到胸有成竹，有时会事半功倍!同样，如果我们常看数据结构 与算法，我们写程序时也能游刃有余、明察秋毫，遇到问题时亦能入木三分、迎刃而解。
所以数据结构和算法是一名程序开发人员的必备基本功，不是一朝一夕就能练成绝世高手的。 冰冻三尺非一日之寒，需要我们平时不断的主动去学习积累。
数据结构和算法对于 python 而言是他的灵 魂；程序是数据结构加上算法来实现的，对于任何 一门编程语言都离不开数据结构和算法，但是 对于 python 而言内置了基础的数据结构如列表、字 典、集合等，再加上众多包，所以弱化了数据结构和算法的使用。
但是在一些特定领域对数据结构和算法的要求也很高，如大数据分析和人工智能 之中应用广 泛；同时数据结构和算法关系程序运行的效率，是每个程序员不得不考虑的问题。
先来看一道题：
简单分析：在不使用比较高级的用法前提情况，使用基本的数据类型+循环解决这个问题
尝试：
import time
starttime = time. time ()
# 这里使用三重循环
for a in range(1001):
for b in range(1001):
for c in range( 1001):
if a+b+C ==1000 and a **2+b**2 ==c
print (a ,b , c ) print (time. time () -starttime)
运行结果：
那上面就是一种算法，这种算法出来了我们耗时215秒
那此时存在一个疑问，什么是算法
算法的概念
算法是计算机处理信息的本质，因为计算机程序本质上是一个算法来告诉计算机确切的步 骤来执行一个指定的任务。一般地，当算法在处理信息时，会从输入设备或数据的存储地址读取数 据，把结果写入输出设备或某个存储地址供以后再调用
算法是独立存在的一种解决问题的方法和思想。
对于算法而言，实现的语言并不重要，重要的是思想。
算法可以有不同的语言描述实现版本(如C描述、C++描述、Python描述等),我们现在 是在用Python语言进行描述实现。
算法的五大特性
1 、输 入 ：算法具有0个或多个输入
2、输 出 ：算法至少有1个或多个输出
3、有穷性：算法在有限的步骤之后会自动结束而不会无限循环，并且每一个步骤可以在可接受的时间内 完成
4、确定性：算法中的每一步都有确定的含义，不会出现二义性
5、可行性：算法的每一步都是可行的
当我们熟悉算法结构发现，其实可以节省一重循环，
优化：
import time
starttime = time. time ()
# 这里使用二重循环
for a in range(1001):
for b in range(1001 ):
C = 1000 - a - b
if a +b+C ==1000 and a **2+b**2 ==C
print (a ,b ,c ) print (time. time () -starttime)
运行结果：
0500500
200375425
375200425
5000500
1.8227097988128662
Process finished w ith exit code 0
我们看到最后的运行时间达到了1.8 秒左右。
# 运行效率缩短了200多倍
那这些都是一种算法，但是算法与算法之间也存在着差值，那就衍生出算法的效率，那如 何去评判算法的效率尼?
算法效率衡量
执行时间反应算法效率
对于同一问题，我们给出了两种解决算法，在两种算法的实现中，我们对程序执行的时间 进行了测算，发现两段程序执行的时间相 差悬殊(215.50150537490845秒相比于
1.8227097988128662), 由此我们可以得出结论：实现算法程序的执行时间可以反应出算法的 效率，即算法的优劣
但是单靠时间值就绝对的么?
假设我们将第二次尝试的算法程序运行在一台配置古老性能低下的计算机中，情况会如 何?很可能运行的时间并不会比在我们的电脑中运行算法一的215.50150537490845秒快多少。
单纯依靠运行的时间来比较算法的优劣并不一定是客观准确的!
程序的运行离不开计算机环境(包括硬件和操作系统),这些客观原因会影响程序运行的 速度并反应在程序的执行时间上。那么如何才能客观的评判一个算法的优劣呢?
时间复杂度与"大 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)
对于算法进行特别具体的细致分析虽然很好，但在实践中的实际价值有限。
对于算法的时间性质和空间性质，最重要的是其数量级和趋势，这些是分析算法效率的主 要部分。
而计量算法基本操作数量的规模函数中那些常量因子可以忽略不计。
例如，可以认为3n2和100n2属于同一个量级，如果两个算法处理同样规模实例的代价分别 为这两个函数，就认为它们的效率"差不多",都为n2级
主要以算法的趋势和数量级来看，如100* n 的平方与1000* n 的平方，他们的时间复杂度是 相同的
就像迭代输出一个 n*n 的多维数组，他的时间复杂度就是 N*N 即 n 的平方 最坏时间复杂度
分析算法时，存在几种可能的考虑：
算法完成工作最少需要多少基本操作，即最优时间复杂度
算法完成工作最多需要多少基本操作，即最坏时间复杂度
算法完成工作平均需要多少基本操作，即平均时间复杂度
对于最优时间复杂度，其价值不大，因为它没有提供什么有用信息，其反映的只是最乐观 最理想的情况，没有参考价值。
对于最坏时间复杂度，提供了一种保证，表明算法在此种程度的基本操作中一定能完成工 作。
对于平均时间复杂度，是对算法的一个全面评价，因此它完整全面的反映了这个算法的性 质。但另一方面，这种衡量并没有保证，不是每个计算都能在这个基本操作内完成。而且，对于平 均情况的计算，也会因为应用算法的实例分布可能并不均匀而难以计算。
结论：
时间复杂度的几条基本计算规则
好的，熟悉了基本的算法规则，进行计算分析一下前两段的算法
1、第一次代码
#代码核心
for a in range( 1001):
for b in range(1001 ):
for c in range( 1001):
if a+b+C ==1000 and a **2+ b**2 ==C
print (a,b,c )
时间复杂度分析：
2、第二次代码
代 码 核 心
for a in range( 1001):
for b in range(1001 ):
C = 1000- a - b
if a+b +C ==1000 and a **2+ b** print ( a ,b , c)
时间复杂度分析：
#这里我们进行分析
每次循环都全部遍历完为 n
# 两次循环时间复杂度乘法计算
顺序结构，时间复杂度按加法进行计算 # 分支结构，时间复杂度取最大值
基本操作，即只有常数项，认为其时间复杂度为0(1)
判断一个算法的效率时，往往只需要关注操作数量的最高次项
#得出如下
T(n)=0(n*n*(1+1))= O(n*n)=0(n **2)
我们发现第二种算法要比第一种算法的时间复杂度好多的 3、常见时间复杂度
|------------------|-----------|---------------|
| 执行次数函数举例 | 阶 | 非正式术语 |
| 12 | O(1) | 常数阶 |
| 2n+3 | O(n) | 线性阶 |
| 3n2+2n+1 | O(n2) | 平方阶 |
| 5log2n+20 | O(logn) | 对数阶 |
| 2n+3nlog2n+19 | O(nlogn) | nlogn阶 |
| 6n3+2n2+3n+4 | O(n3) | 立方阶 |
| 2n | O(2n) | 指数阶 |
注意，经常将 log2n ( 以2为底的对数)简写成 l ogn
如图：
所消耗的时间从小到大
|-------|---|--------------------|------------------------|-------------------------------|-------------|
| O(1)<0(logn)<0(n)<0(nlogn)<0(n²)<0(n³)<0(2n)< O(n!)<0(nn) ||||||
| 常见的大 O 运行时间 O(log n),也叫对数时间，二分查找。 O(n), 也叫线性时间，简单查找。 O(n*log n), 快速排序---一种速度较快的排序算法。 O(n²), 选择排序---一种速度较慢的排序算法。 o(n!), 旅行商问题的解决方案----一种非常慢的算法。 练习： 时间复杂度练习(参考算法的效率规则判断) O(5) O( 1) O(2n +1 ) o (n ) o(n² + n +1 ) O( n² ) 0 ( 3n³ +1 ) o ( n³ ) 4、Python 内置解析模块 timeit 模块 这个模块定义了三个方便的函数和一个公共类，直接来 看主要的类 ||||||
| class | timeit.Timer |||||
| 作用： 类，用于为小代码段的执行速度计时 语法： ||||||
| class || timeit.Timer(stmt= | 'pass' ,setup= | 'pass' ,timer=<timer | function>, |
| globals || =None) | | | |
| 参数解析： ||||||
| # stmt 参数是要测试的代码语句( statment ) 默认值为" pass"。 # setup : 运行代码时需要的设置。默认值为" pass"。 #t imer : 是一个定时器函数，与平台有关。 # globals : 将名称空间传递给全局变量来控制执行 ||||||
| 类方法： ||||||
| Timer . timeit ||||||
作用： Timer类中测试语句执行++++速度的++++ 对象方法
语法：
参数解析：
number : 是测试代码时的测试次数，默认为1000000次
返回值：该方法返回执行代码的平均耗时， 一个 float 类型的秒数。
List 方法操作测试
from timeit import Timer
def test 1():
list_01 =\[\]
for i in range (1000 ):
list_ 01 =list_01 + i
def test2 ():
list _01 =\[\]
for i in range( 1000 ):
list_01.append (i)
def test3 ():
list_ 01 =i for i in range (1000)
def test4():
list_01 = list(range (1 000))
def test5():
list_01 =\[\]
for i in range (1000, -1,-1 ):
list_01. insert ( 0, i)
t1 =Timer( "test1(","from main import test1")
print(" concat ",t1.timeit(number= 1000),"s")
t2 = Timer( "test2()","from main import test2")
print(" append ",t2. timeit(number= 1000),"s")
t3 = Timer( "test3(","from main import test3")
print ("generate ",t 3.timeit(number= 1000),"s")
t4 = Timer( "test4 ()","from __main import test4") print ("list range ",t 4.timeit(number= 1000),"s ")
查看运行结果：
List 方法操作测试结果：
从测试情况来看创建一个新的列表， list 方法效率是最高的，其次就是生成式， append,insert, 最后是合并
但是我们观察看到同样是插入方法， append 和 i nsert 的执行效率差距为什么这么大尼， 前者从最后面插入，后者是从指定位置插入
pop 操作测试
查看运行结果：
pop_zero 2.07788574 5 s
pop_end 0.00010111199999940368 s
Process finished with exit code 0
pop 操作测试
从结果可以看出， pop 最后一个元素的效率远远高于 pop 第一个元素 list 内置操作的时间复杂度
|-------------------|--------------------------------------------|
| Operation | Big-O Eff icienc y |
| indexx\[\] | O(1) |
| index assignment | O(1) |
| append | O(1) |
| pop() | O(1) |
| pop(i) | O(n) |
| insert(i,item) | O(n) |
| del operator | O(n) |
| iteration | O(n) |
| contains (in) | O(n) |
| get slice x:y | O(k) |
| del slice | O(n) |
| set slice | O(n +k) |
| reverse | O(n) |
| concatenate | O(k) |
| so rt | O(n log n) |
| multiply | O(nk) |
Table 2.2:Big-O Efficiency of Python List Operators
数据结构
提出问题：
分析：
实际上当我们在思考这个问题的时候，我们已经用到了数据结构。
列表和字典都可以存储一个班的学生信息，但是想要在列表中获取一名同学的信息时，就要遍历这个列
表，时间复杂度为0(n),
当使用字典存储时，将学生姓名作为字典的键，学生信息作为值，查询时不需要遍历便可快速获取到学生 信息，时间复杂度为0(1)。
我们为了解决问题，需要将数据保存下来，然后根据数据的存储方式来设计算法实现进行 处理，
那么数据的存储方式不同就会导致需要不同的算法进行处理。
我们希望算法解决问题的效率越快越好，于是我们就需要考虑数据究竟如何保存的问题， 这就是数据结构。
在上面的问题中我们可以选择Python中的列表或字典来存储学生信息。列表和字典就是 Python内建帮我们封装好的两种数据结构。
概念：
数据是一个抽象的概念，将其进行分类后得到程序设计语言中的基本类型。如： int, float, char 等。
数据元素之间不是独立的，存在特定的关系，这些关系便是结构。数据结构指数据对 象中数据元素之间的关系。
Python 给我们提供了很多现成的数据结构类型，这些系统自己定义好的，不需要我们自己去定义的数据 结构叫做Python 的内置数据结构，比如列表、元组、字典。
而有些数据组织方式， Python 系统里面没有直接定义，需要我们自己去定义实现这些数据的组织方式， 这些数据组织方式称之为Python 的扩展数据结构，比如栈，队列等。
算法与数据结构的区别：
程序=数据结构+算法
总结：算法是为了解决实际问题而设计的，数据结构是算法需要处理的问题载体 抽象数据类型( Abstract Data Type)
抽象数据类型(ADT)的含义是指一个数学模型以及定义在此数学模型上的一组操作。
即把数据类型和数据类型上的运算捆在一起，进行封装。
引入抽象数据类型的目的是把数据类型的表示和数据类型上运算的实现与这些数据类型 和运算在程序中的引用隔开，使它们相互独立。
最常用的数据运算有五种：
#插入
#删除 #修改 #查找 # 排序