day11数据结构
目录:
- 数据结构
- 栈
- 队列
- 双端队列
- 链表
- 二叉树
- 算法：
- 二分查找
- 冒泡
- 选择
- 快速
- 插入
- 希尔
- 排序二叉树
什么是算法分析？
- 刚接触编程的学生经常会将自己编写的程序和别人的程序做比对，获取在比对的过程中会发现双方编写的程序很相似但又各不相同。那么就会出现一个有趣的现象：两组程序都是用来解决同一个问题的，但是两组程序看起来又各不相同，那么哪一组程序更好呢？
- a+b+c = 1000 a2 + b2 = c**2 (a,b,c均为自然数)，求出a,b,c可能的组合？
1
for a in range(0,1001):
for b in range(0,1001):
for c in range(0,1001):
if a+b+c == 1000 and a**2 + b**2 == c**2:
print(a,b,c)2
for a in range(0,1001):
for b in range(0,1001):
c = 1000 - a - b
if a+b+c == 1000 and a**2 + b**2 == c**2:
print(a,b,c)---->
0 500 500
200 375 425
375 200 425
500 0 500评判程序优劣的方法
- 消耗计算机资源和执行效率（无法直观）
- 计算算法执行的耗时
- 时间复杂度（推荐）
时间复杂度
- 评判规则：量化算法执行的操作/执行步骤的数量
- 最重要的项：时间复杂度表达式中最有意义的项
- 使用大O记法来表示时间复杂度:O(算法执行步骤数量表达式中最有意义的一项)
def sumOfN(n):
theSum = 0
for i in range(1,n+1):
theSum = theSum + i
return theSumprint(sumOfN(10))
---->55
案例：计算下列算法的时间复杂度
a=5 b=6 c=10 for i in range(n): for j in range(n): x = i * i y = j * j z = i * j for k in range(n): w = a*k + 45 v = b*b d = 33 ########################### 3 + 3*n*n + 2*n + 1 3n**2 +2n + 4 O(n**2)常见的时间复杂度：
- O(1) < O(logn) < O(n) < O(nlogn) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)
数据结构
概念：对于数据（基本类型的数据（int,float,char））的组织方式就被称作为数据结构。数据结构解决的就是一组数据如何进行保存，保存形式是怎样的。
案例： 需要存储一些学生的学生信息（name,score）,那么这些数据应该如何组织呢？查询某一个具体学生的时间复杂度是什么呢？（三种组织方式）
[
[name,score],
[name1,score1],
]
O(n)(
[name,score],
[name1,score1],
)
O(n){
{'name':'bobo'},
{'score':100},
}
{
name:{score:100},
name2:{score:99}
}
O(1)三种组织形式基于查询的时间复杂度？
使用不同的形式组织数据，在基于查询时的时间复杂度是不一样的。因此认为算法是为了解决实际问题而设计的，数据结构是算法需要处理问题的载体。
list(for in range()) 速度最快
其次是 [] 推到式
然后是???
栈
- 特性：先进后出的数据结构
栈顶，栈尾
应用：每个 web 浏览器都有一个返回按钮。当你浏览网页时，这些网页被放置在一个栈中（实际是网页的网址）。你现在查看的网页在顶部，你第一个查看的网页在底部。如果按‘返回’按钮，将按相反的顺序浏览刚才的页面。
- Stack() 创建一个空的新栈。 它不需要参数，并返回一个空栈。
- push(item)将一个新项添加到栈的顶部。它需要 item 做参数并不返回任何内容。
- pop() 从栈中删除顶部项。它不需要参数并返回 item 。栈被修改。
- peek() 从栈返回顶部项，但不会删除它。不需要参数。 不修改栈。
- isEmpty() 测试栈是否为空。不需要参数，并返回布尔值。
size() 返回栈中的 item 数量。不需要参数，并返回一个整数。
class Stack():
def __init__(self):
self.items = []
def push(self,item):
self.items.append(item)
def drop(self):
return self.items.pop()
def isEmpty(self):
return self.items == []
def size(self):
return len(self.items)
s = Stack()
s.push(1)
len(s.items)
print(s.drop())
print(s.isEmpty())
print(s.size())
s.push('第一')
s.push('第二')
s.push('第三')
s.items # ['第一', '第二', '第三']
# print(s.drop()) # 后进先出对的 # '第三--->
1
True
0s = Stack()
def getRequest(url):
s.push(url)
def showCurenrUrl():
print('当前页面展示的url：'+s.pop())
def back():
print('回退按钮点击后显示的url：',s.pop())
getRequest('www.1.com')
getRequest('www.2.com')
getRequest('www.3.com')
showCurenrUrl()
back()
back()
---->
当前页面展示的url：www.3.com
回退按钮点击后显示的url： www.2.com
回退按钮点击后显示的url： www.1.com队列
- 队列：先进先出
- 应用场景：
- 我们的计算机实验室有 30 台计算机与一台打印机联网。当学生想要打印时，他们的打印任务与正在等待的所有其他打印任务“一致”。第一个进入的任务是先完成。如果你是最后一个，你必须等待你前面的所有其他任务打印
- Queue() 创建一个空的新队列。 它不需要参数，并返回一个空队列。
- enqueue(item) 将新项添加到队尾。 它需要 item 作为参数，并不返回任何内容。
- dequeue() 从队首移除项。它不需要参数并返回 item。 队列被修改。
- isEmpty() 查看队列是否为空。它不需要参数，并返回布尔值。
- size() 返回队列中的项数。它不需要参数，并返回一个整数。
class Queue():
def __init__(self):
self.items = []
def push(self,index,item):
self.items.insert(index,item)
def drop(self):
return self.items.pop()
def isEmpty(self):
return self.items == []
def size(self):
return len(self.items)
def peek(self): #最后一个的位置 因为从零开始
return len(self.items)-1
q = Queue()
q.push(0,'第一')
q.push(0,'第二')
q.push(0,'第三')
q.items # ['第三', '第二', '第一']
# q.drop() # '第一'
q.peek()烫手的山芋游戏
- 案例：烫手的山芋
- 烫手山芋游戏介绍：6个孩子围城一个圈，排列顺序孩子们自己指定。第一个孩子手里有一个烫手的山芋，需要在计时器计时1秒后将山芋传递给下一个孩子，依次类推。规则是，在计时器每计时7秒时，手里有山芋的孩子退出游戏。该游戏直到剩下一个孩子时结束，最后剩下的孩子获胜。请使用队列实现该游戏策略，排在第几个位置最终会获胜。
- 结论：
- 七秒即时到了之后，山芋被传递了6次。
- 保证手里有山芋的孩子永远站在队列的头部
class Queue():
def __init__(self):
self.items = []
def push(self,index,item):
self.items.insert(index,item)
def drop(self):
return self.items.pop()
def isEmpty(self):
return self.items == []
def size(self):
return len(self.items)
def peek(self): #最后一个的位置 因为从零开始
return len(self.items)-1
# 7 秒 ,去除第一个人中手上不传出的1秒
q1 = Queue()
kids = ['A','B','C','D','E','F']
for kid in kids :
q1.push(0,kid) # 把数据添加进去
q1.items
while len(q1.items)>1: # 当数据只有1个时,为游戏的胜者
for i in range(6):
a = q1.drop() # 先删,后添加到最初位置,就是换顺序
q1.push(0,a) # ,一个个往后走,然后保证山芋在第一位
q1.drop() # 删除第一位
q1.items 双端队列
同同列相比，有两个头部和尾部。可以在双端进行数据的插入和删除，提供了单数据结构中栈和队列的特性
- Deque() 创建一个空的新 deque。它不需要参数，并返回空的 deque。
- addFront(item) 将一个新项添加到 deque 的首部。它需要 item 参数 并不返回任何内容。
- addRear(item) 将一个新项添加到 deque 的尾部。它需要 item 参数并不返回任何内容。
- removeFront() 从 deque 中删除首项。它不需要参数并返回 item。deque 被修改。
- removeRear() 从 deque 中删除尾项。它不需要参数并返回 item。deque 被修改。
- isEmpty() 测试 deque 是否为空。它不需要参数，并返回布尔值。
size() 返回 deque 中的项数。它不需要参数，并返回一个整数。
class Queue():
def __init__(self):
self.items = []
# 队列方式加到栈首
def addfront(self,index,item):
self.items.insert(index,item)
# 栈模式,从前面取,就是双端队列
def addback(self,item):
self.items.append(item)
def dropfront(self):
return self.items.pop()
def dropback(self):
return self.items.pop(0) # 123 先进先出
def isEmpty(self):
return self.items == []
def size(self):
return len(self.items)
def peek(self): #最后一个的位置 因为从零开始
return len(self.items)-1
q = Queue()
q.addfront(0,1)
q.addfront(0,2)
q.addfront(0,3)
q.items
q.dropfront()
q.dropfront()
q.dropfront()
# 首先进先出
q.addback(1)
q.addback(2)
q.addback(3)
q.dropfront()
q.dropfront()
q.dropfront()
q.items
# 栈 删除方式就是栈了 [1]
q.addback(1)
q.addback(2)
q.addback(3)
q.items
q.dropback()
q.dropback()
q.dropback()
# 后进后厨
尾先进新出: 两边都是 双端队列应用案例：回文检查
回文是一个字符串，读取首尾相同的字符，例如，radar toot madam。
抄的老师的:
ab = 'abcdaddcba'
def huiwen(st):
q = Queue()
ex = 'True'
for s in st:
q.addback(s)
while len(q.items)>1:
if q.dropback()!= q.dropfront():
ex = 'False'
break
return ex
print(huiwen(ab)) False内存
- 计算机的作用
- 用来存储和运算二进制的数据
- 衡量计算机内存大小的单位：
- bit（位）:
- 字节：8bit
- kb:1024字节
- mb：1024kb
- 问题：计算机如何计算1+2？
- 必须先在计算机的内存开辟内存空间
- 才将对应的数值存储到该内存中
- 变量的概念
- a = 10 在计算机中表示的含义（内存图）
- 内存空间开辟好了之后，每一块内存空间都会有两个默认的属性
- 内存空间的大小：算机内存大小的单位
- 内存空间的地址：十六进制的数值
- 地址作用：用来定位（追踪）指定内存空间，就可以获取该内存空间中存储的数据
- 变量本质表示的是内存空间的地址，通常变量想要表示的就是内存地址对应的内存空间
- 理解a=10的内存图（引用，指向）
- 引用：变量
- 指向：如果某一个变量/引用存储了某一块内存空间的地址后，则表示该变量指向了该内存地址所对应的内存空间。
- 不同数据占用内存空间的大小
顺序表
- 容器/数据结构中存储的元素是有顺序的，顺序表的结构可以分为两种形式：单数据类型(numpy)和多数据类型(list)。
python中的列表和元组就属于多数据类型的顺序表
单数据类型顺序表的内存图（内存连续开启）
多数据类型顺序表的内存图（内存非连续开辟）
顺序表的弊端：顺序表的结构需要预先知道数据大小来申请连续的存储空间，而在进行扩充时又需要进行数据的搬迁。
链表：
相对于顺序表，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理且进行扩充时不需要进行数据搬迁。
- 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是不像顺序表一样连续存储数据，而是每一个结点（数据存储单元）里存放下一个结点的信息（即地址）
要求
. is_empty()：链表是否为空
. length()：链表长度
. travel()：遍历整个链表
. add(item)：链表头部添加元素
. append(item)：链表尾部添加元素
. insert(pos, item)：指定位置添加元素
. remove(item)：删除节点
. search(item)：查找节点是否存在建立节点
class Node():
def __init__(self,item): #建立一个节点,新节点,后续的还不知道,所以没有next
self.item = item # 添加的值
self.next = None # 链子指向,因为是新值,还没来得及建链,故None
node = Node(3) # 实例化一个
class Link():
def __init__(self):
# 建立一个空链表
self._head = None # 第一个指向None ,还没有添加进来
def add(self,item): # 链表头部添加元素
node = Node(item) # 实例化一个, 没有后续,next=None item=item
node.next = self._head
# 之前的head 1 空, 2次添加是上一个node,因为head被重新赋值了
# 变成了上一个的node(实例化的) 下面一行代码 ,然后一直迭代
self._head = node # 给head指向,实例化的那个Node 第一次 
- 这两个函数都是用的一样的逻辑:
- 都是不知道循环次数,所以用while循环,然后,一直next ,直到为空,然后退出
def travel(self): # 遍历整个链表
cur = self._head # 地址
while cur: # 最后为空
print(cur.item) # 值
cur = cur.next # 下一个 def length(self): # 链表长度
cur = self._head # 地址
count = 0
while cur: # 最后为空
print(cur.item) # 值
count += 1
cur = cur.next # 下一个
# print('长度为',count)
return count- 不要忘了_head就是代表的 节点
def isEmpty(self):
return self._head == None
- for 循环 然后返回 find为True说明找到了 ,找不到,和上面一样的思想,next往下走
def search(self,item): #查找节点是否存在
cur = self._head
find = 'False'
for i in range(self.length()):
if cur.item == item :
find = 'True'
else:
cur = cur.next
return find- 犯得两个错误,因为copy的,结果冒号是中文,还没发现
- 下面的cur,pre循环,链子的拼接
#加到最后
#最后一个指向为none ,主要是对前一个操作
#因为最后一个next = None,而前一个,指向的是最后一个,所以要链一下最后一个,一条链
def append(self,item):
node = Node(item)
cur = self._head # 地址
# 注意的项:
# 第一次添加,没有前一项 # 的时候直接,没有最后一个,next
if self.isEmpty():
self._head = node
return # 不要忘了,return 退出
pre = None
while cur: # 最后为空
pre = cur # 前一个
cur = cur.next # 下一个
pre.next = node # 插入
# 没想到不难,会了append之后,改一下链子,别的不大动,
# 值的注意的点,范围插入时,
def insert(self, pos, item):
node = Node(item)
cur = self._head # 地址
if 0 > pos or pos > self.length()+1:
print(pos,'超范围,没法插入,请重新插入')
return
pre = None
# 最后为空
for i in range(1,pos): # 第几个位置 前面添加后天添加建立两个连接
pre = cur # 前一个
cur = cur.next # 下一个
node.next = pre.next # node.next ✔
# 顺序不能错了,先把后面的链子给了中间的
pre.next = node # 然后给前面的链子,中间的 #删除节点
def remove(self,item):
node = Node(item)
cur = self._head # 地址
if self.search(item)=='False': #用搜索,查,在里面然后删
return '不在里面,不用删除'
if self.length()==1 or self.length(): #1个或者多个的时候不走下面循环
self._head == None
return
pre = None
# 最后为空
for i in range(1,self.length()): # 第几个位置 前面添加后天添加建立两个连接
pre = cur # 前一个
cur = cur.next # 下一个
pre.next = cur.next #上一个的链连接下一个的下一个的链,所以下一个断开连接
print('长度',self.length()) 结果打印
link = Link()
link.add(1)
link.add(2)
link.add(3)
# link.append(1)
# link.append(2)
# link.append(3)
# link.insert(2,4)
# link.insert(2,4)
# link.insert(4,4)
# link.insert(44,4)# 超范围的不行
# link.travel()
# link.length()
# link.isEmpty()
# link.search(-1)
link.remove(1)
print(link.remove(4))
# link.search(1)3
2
1
3
2
1
3
2
1
3
2
1
不在里面,不用删除