数据结构性能
1、大O记法
如果将每一步看成基本计算单位，那么可以将算法的执行时间描述成解决问题所需的步骤数。
对于累加算法，计算总和所用的赋值语句的数目就是一个很好的基本计算单位。
在函数中，赋值语句数是1加上n的运行次数。可以将其定义成函数T，令T(n) = 1 + n，参数n常被称作问题规模
可以将函数解读为“当问题规模为n时，解决问题所需的时间是T(n) ，即需要1 + n步”
精确的步骤数并没有T(n) 函数中取决定性作用的部分重要。也就是说，随着问题规模的增长，T(n) 函数的某一部分会比其余部分增长得更快
最后比较的其实就是这一起决定作用的部分。
数量级函数描述的就是，当n增长是，T(n) 增长最快的部分。
数量级（order of magnitude)常被称作大O记法，记作O(f(n))
对于T(n) = 1 + n，随着n越来越大，常数1对最终结果的影响越来越小。
如果要给出T(n)的近似值，可以舍去1，直接说执行时间是O(n)
def sumOFN(n):
theSum = 0
for i in range(1, n+1)
theSum = theSum + i
return theSum
基本数据结构
1、线性数据结构
栈、队列、双端队列和列表都是有序的数据集合，其元素的顺序取决于添加顺序和移除顺序。
一旦某个元素被添加进来，它与前后元素的相对位置将保持不变。这样的数据集合经常被称为线性数据结构
2、栈：LIFO (last-in first-out)
栈的Python实现
1）列表尾部作为栈的顶端
class Stack:
def __init__(self):
self.items = []
def isEmpty(self):
return self.items == []
def push(self, item):
self.items.append(item)
def pop(self):
return self.items.pop()
def peek(self):
return self.items[len(self.items)-1]
def size(self):
return len(self.items)
2） 列表头部作为栈的顶端
class Stack:
def __init__(self):
self.items = []
def isEmpty(self):
return self.items == []
def push(self, item):
self.items.insert(0, item)
def pop(self):
return self.items.pop(0)
def peek(self):
return self.items[0]
def size(self):
return len(self.items)
3）模块实现
from pythonds.basic import Stack
使用栈解决问题
匹配括号
编写一个算法，它从左到右读取一个括号串，然后判断其中的括号是否匹配
from pythonds.basic import Stack
inp1 = "((()()))(()))"
inp2 = "((()())(()))"
def detect(string):
s = Stack()
for i in string:
if i == "(":
s.push(i)
else:
try:
s.pop()
except IndexError:
return False
return True
print(detect(inp1))
print(detect(inp2))
3、队列：FIFO（first-in first-out）
队列的Python实现
在列表头部添加元素，在列表尾部移出元素
扫描二维码关注公众号，回复：
12889092 查看本文章
class Stack:
def __init__(self):
self.items = []
def isEmpty(self):
return self.items == []
def enqueue(self, item):
self.items.insert(0, item)
def dequeue(self):
return self.items.pop()
def size(self):
return len(self.items)
串土豆程序
from pythonds.basic import Queue
def hotPotato(namelist, num):
q = Queue()
for i in name:
q.enqueue(i)
# 当队列只剩一个元素时结束循环
while q.size() > 1:
# 循环num次
for i in range(num):
# 将从尾部移除的元素添加到头部
q.enqueue(q.dequeue())
# 移除头部元素
q.dequeue()
return q.dequeue()
print(hotPotato(["1","2","3","4","5","6"], 7))
4、双端队列
双端队列对在哪一端添加和移除元素没有任何限制
双端队列的Python实现
class Deque:
def __init__(self):
self.items = []
def isEmpty(self):
return self.items == []
def addFront(self, item):
self.items.append(item)
def addRear(self, item):
self.items.insert(0, item)
def removeFront(self):
return self.items.pop()
def removeRear(self):
return self.items.pop(0)
def size(self):
return len(self.items)
列表
实现无续的列表：链表
无序列表需要维持元素之间的相对位置，但是并不需要在连续的内存空间中维护这些位置信息。
结点的Python实现
class Node:
def __init__(self, initdata):
self.data = initdata
self.next = None
def getData(self):
return self.data
def getNext(self):
return self.next
def setData(self, newdata):
self.data = newdata
def setNext(self, newnext):
self.next = newnext
链表的Python实现、
链表其实是由一个个结点组成的。
class UnorderList:
def __init__(self):
self.head = None
def isEmpty(self):
return self.head == None
def add(self, item):
temp = Node(item)
temp.setNext(self.head)
self.head = temp
def pop(self):
current = self.head
if current != None:
previous = current
self.head = current.getNext()
return previous.getData()
def length(self):
current = self.head
count = 0
while current != None:
count = count + 1
current = current.getNext()
return count
def search(self, item):
current = self.head
found = False
while current != None and not found:
if current.getData() == item:
found = True
else:
current = current.getNext()
return found
def remove(self, item):
current = self.head
previous = None
found = False
while not found:
if current.getData() == item:
found = True
else:
previous = current
current = current.getNext()
if previous == None:
self.head = current.getNext()
else:
previous.setNext(current.getNext())