python数据结构与算法分析_python之数据结构和基础算法

#coding=utf-8

import time

start_time = time.time()

# 注意是三重循环

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))

end_time = time.time()

print("elapsed: %f" % (end_time - start_time))

print("complete!")

"""

a, b, c: 0, 500, 500

a, b, c: 200, 375, 425

a, b, c: 375, 200, 425

a, b, c: 500, 0, 500

elapsed: 914.520365

complete!

"""

#算法是独立存在的一种解决问题的方法和思想。算法的五大特性;输入: 算法具有0个或多个输入;输出: 算法至少有1个或多个输出;有穷性: 算法在有限的步骤之后会自动结束而不会无限循环，并且每一个步骤可以在可接受的时间内完成;确定性：算法中的每一步都有确定的含义，不会出现二义性;可行性：算法的每一步都是可行的，也就是说每一步都能够执行有限的次数完成

import time

start_time = time.time()

# 注意是两重循环

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))

end_time = time.time()

print("elapsed: %f" % (end_time - start_time))

print("complete!")

"""

a, b, c: 0, 500, 500

a, b, c: 200, 375, 425

a, b, c: 375, 200, 425

a, b, c: 500, 0, 500

elapsed: 0.873705

complete!

"""

#算法的时间效率，我们可以用“大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)

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

#算法分析

#第一次尝试的算法核心部分

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(n**3)

#第二次尝试的算法核心部分

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(n**2)

#常见时间复杂度

"""

执行次数函数举例                        阶                       非正式术语

12                                     O(1)                     常数阶

2n+3                                   O(n)                     线性阶

3n**2+2n+1                             O(n2)                    平方阶

5log2n+20                              O(logn)                  对数阶

2n+3nlog2n+19                          O(nlogn)                 nlogn阶

6n**3+2n**2+3n+4                           O(n3)                    立方阶

2**n                                       O(2n)                    指数阶

#注意，经常将log2n(以2为底的对数)简写成logn

"""

#时间从小到大:O(1) 

#Python内置类型性能分析

#timeit模块可以用来测试一小段Python代码的执行速度。class timeit.Timer(stmt='pass', setup='pass', timer=)

#Timer是测量小段代码执行速度的类;stmt参数是要测试的代码语句(statment)；setup参数是运行代码时需要的设置；timer参数是一个定时器函数，与平台有关。

import timeit

def test1():

    n=0

    for i in range(101):

        n+=i

    return n

t = timeit.Timer("test1()","from __main__ import test1")

print(t.timeit(number=1000000))#6.2553928

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

#list的操作测试

def test1():

   l = []

   for i in range(1000):

      l = l + [i]

def test2():

   l = []

   for i in range(1000):

      l.append(i)

def test3():

   l = [i for i in range(1000)]

def test4():

   l = list(range(1000))

from timeit import Timer

t1 = Timer("test1()", "from __main__ import test1")

print("concat ",t1.timeit(number=1000), "seconds")#concat  1.5456573000000002 seconds

t2 = Timer("test2()", "from __main__ import test2")

print("append ",t2.timeit(number=1000), "seconds")#append  0.09663730000000115 seconds

t3 = Timer("test3()", "from __main__ import test3")

print("comprehension ",t3.timeit(number=1000), "seconds")#comprehension  0.05408239999999864 seconds

t4 = Timer("test4()", "from __main__ import test4")

print("list range ",t4.timeit(number=1000), "seconds")#list range  0.014456300000000866 seconds

#pop操作测试

from timeit import Timer

x = list(range(2000000))

pop_zero = Timer("x.pop(0)","from __main__ import x")

print("pop_zero ",pop_zero.timeit(number=1000), "seconds")#pop_zero  1.8344147 seconds

x = list(range(2000000))

pop_end = Timer("x.pop()","from __main__ import x")

print("pop_end ",pop_end.timeit(number=1000), "seconds")#pop_end  0.00020119999999979044 seconds

#测试pop操作：从结果可以看出，pop最后一个元素的效率远远高于pop第一个元素

#append操作测试

from timeit import Timer

x = list(range(2000000))

pop_zero = Timer("x.append(0)","from __main__ import x")

print("append ",pop_zero.timeit(number=1000), "seconds")#append  0.010801700000000025 seconds

x = list(range(2000000))

pop_end = Timer("x.insert(0,0)","from __main__ import x")

print("insert ",pop_end.timeit(number=1000), "seconds")#insert  1.9234961 seconds

#测试pop操作：从结果可以看出，pop最后一个元素的效率远远高于pop第一个元素

#Python的 list 数据结构

"""

操作                      操作说明                                             时间复杂度

index(value)                查找list某个元素的索引                                   O(1)

a = index(value)            索引赋值                                               O(1)

append(value)               队尾添加                                               O(1)

pop()                       队尾删除                                               O(1)

pop(index)                  根据索引删除某个元素                                  O(n)

insert(index, value)        根据索引插入某个元素                                  O(n)

iterration                  列表迭代                                               O(n)

search(in)                  列表搜索(其实就是in关键字)                         O(n)

slice [x:y]                 切片, 获取x, y为O(1), 获取x,y 中间的值为O(k)            O(k)

del slice [x:y]             删除切片，删除切片后数据需要重新移动/合并                 O(n)

reverse                     列表反转                                               O(n)

sort                        排序                                                 O(nlogn)

"""

#Python dict 数据结构

"""

操作              操作说明                时间复杂度

copy                复制                  O(n)

get(value)          获取                  O(1)

set(value)          修改                  O(1)

delete(value)       删除                  O(1)

search(in)          字典搜索                O(1)

iterration          字典迭代                O(n)

"""

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

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

#顺序表的操作

#增加元素:a. 尾端加入元素，时间复杂度为O(1);b. 非保序的加入元素(插入不常见)，时间复杂度为O(1);c. 保序的元