数据结构与算法（Python）Day1（算法介绍、时间复杂度、timeit模块、数据结构介绍）

数据结构与算法（Python）

算法的概念

算法是计算机处理信息的本质，因为计算机程序本质上是一个算法告诉计算机确切的步骤来执行一个指定的任务。一般地，当算法在处理信息时，会从输入设备或数据的存储地址读取数据，把结果写入输出设备或某个存储地址供以后再调用。
算法是独立存在的一种解决问题的方法和思想。

算法的五大特征

1.输入：算法具有0个或多个输入
2.输出：算法至少有1个或多个输出
3.有穷性：算法有限的步骤之后会自动结束而不会无限循环，并且每一个步骤可以在可接受的时间内完成
4.确定性：算法中的每一步都有确定的含义，不会出现二义性
5.可行性：算法的每一步都是可行的，也就是说每一步都能执行有限的次数完成

题目：如果a+b+c=1000，且a²+b²=c²（a,b,c为自然数），如何求而出所有a、b、c可能的组合？

#（枚举法）
import time
start_time=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**2:
                print("a,b,c:%d,%d,%d"%(a,b,c))
end_time=time.time()
print("time:%d"%(end_time-start_time))
print("finished")

优化

时间复杂度“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)。

#优化
#a
#b
#c=1000-a-b
#T(n)=n²(1+max(0,1))=O(n²)
import time
start_time=time.time()
for a in range(1001):
    for b in range(1001):
        c=1000-a-b
        if a**2+b**2==c**2:
            print("a,b,c:%d,%d,%d"%(a,b,c))
end_time=time.time()
print("time:%d"%(end_time-start_time))
print("finished")

最坏时间复杂度：算法完成工作最多需要多少操作，提供了一种保证，表明算法在此种程度的基本操作中一定能完成工作。
最优时间复杂度：算法完成工作最少需要多少操作。
平均时间复杂度：算法完成工作平均需要多少操作。

时间复杂度的几条基本计算规则

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

常见时间复杂度

Python内置类型性能分析

timeit模块

timeit模块可以用来测试一小段Python代码的执行速度。
timeit.Timer(stmt=‘pass’,setup=‘pass’,timer=<timer function>)
Timer是测量小段代码执行速度的类。
stmt参数是要测试的代码语句（statment）;
setup参数是运行代码时需要的设置；
timer参数是一个定时器函数，与平台有关。

timeit.Timer.timeit(number=1000000)
Timer类中测试语句执行速度的对象方法。number参数是测试代码时的测试次数，默认为1000000次。方法返回执行代码的平均耗时，一个float类型的秒数。

#coding:utf-8

import timeit

def t1():
    li=[]
    for i in range(10000):
        li.append(i)
def t2():
    li=[]
    for i in range(10000):
        li+=[i]
#li+=[i]是对li=li+[i]的优化，li=li+[i]更加慢，对于此例要100多秒
def t3():
    li=[i for i in range(10000)]
def t4():
    li=list(range(10000))
def t5():
    li=[]
    for i in range(10000):
        li.extend([i])

timer1=timeit.Timer("t1()","from __main__ import t1")#在__main__中运行
print("append:",timer1.timeit(1000))
timer2=timeit.Timer("t2()","from __main__ import t2")
print("+:",timer2.timeit(1000))
timer3=timeit.Timer("t3()","from __main__ import t3")
print("[i for i in range]:",timer3.timeit(1000))
timer4=timeit.Timer("t4()","from __main__ import t4")
print("list(range()):",timer4.timeit(1000))
timer5=timeit.Timer("t5()","from __main__ import t5")
print("extend:",timer5.timeit(1000))

def t6():
    li=[]
    for i in range(10000):
        li.append(i) #队尾添加
def t7():
    li=[]
    for i in range(10000):
        li.insert(0,i) #列表头添加

timer6=timeit.Timer("t6()","from __main__ import t6")
print("append(尾):",timer6.timeit(1000))
timer7=timeit.Timer("t7()","from __main__ import t7")
print("insert(头):",timer7.timeit(1000))

同理,pop（头）比pop(尾，默认）慢。这与列表的存储方式有关。

list内置操作的时间复杂度

#set slice O(n+k)
li=[1,3,4,5,6,7,8,9]
li[0:3]=[55,66,77,88,99,100]
print(li)

dict内置操作的时间复杂度

数据结构引入

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

算法和数据结构的区别

数据结构只是静态的描述了数据元素之间的关系。
高效的程序需要在数据结构的基础上设计和选择算法。
程序=数据结构+算法
总结：算法是为了解决实际问题而设计的，数据结构是算法需要处理的问题载体。

抽象数据类型（Abstract Data Type）

抽象数据类型（ADT）的含义是指一个数学模型以及定义在此数学模型上的一组操作。即把数据类型和数据类型上的运算捆在一起，进行封装。引入抽象数据类型的目的是把带数据类型的表示和数据类型上运算的实现与这些数据类型和运算在程序中的引用隔开，使它们相互独立。
最常用的数据运算有五种：
插入
删除
修改
查找
排序