07_Python算法+数据结构笔记-链表总结-哈希表-树-二叉树-二叉搜索树
b站视频:路飞IT学城
https://www.bilibili.com/video/BV1mp4y1D7UP
文章目录
- #61 链表总结
- #62 哈希表
- #63 哈希表实现
- #64 哈希表应用
- #65 树的概念
- #66 树的实例：模拟文件系统
- #67 二叉树概念
- #68 二叉树遍历
- #69 二叉搜索树的概念
- #70 二叉搜索树：插入
个人博客
https://blog.csdn.net/cPen_web
#61 链表总结
###### 链表——复杂度分析
# 顺序表（列表/数组）与 链表
# 按元素值查找 #注：复杂度都是O(n)
# 按下标查找 #注：顺序表快 顺序表O(1)，链表O(n)
# 在某元素后插入 #注：顺序表O(n) ，链表O(1)
# 删除某元素 #注：顺序表O(n) ，链表O(1)
#注：顺序表：Python里的列表 ，C里的数组 是 挨个存的
# 顺序表（列表/数组）与 链表
# 按元素值查找
# 注：复杂度都是O(n)，一个一个查找，找到为止 (顺序表 不考虑排序)
# 按下标查找
# 注：顺序表快 顺序表O(1)，链表O(n)因为下标是10，得从头开始数
# 在某元素后插入 顺序表O(n) ，链表O(1)
# 删除某元素 顺序表O(n) ，链表O(1)
#注：链表相对于 顺序表，在插入和删除 2方面非常快
###### 链表与顺序表
# 链表在插入和删除的操作上明显快于顺序表
# 链表的内存可以更灵活的分配
#注：链表节点通过指针/next串起来，是分开的内存，而其他语言队列满了就没办法了
# 试利用链表重新实现栈和队列
# 链表这种链式存储的数据结构对树和图的结构有很大的启发性
#62 哈希表
#注：哈希表(散列表)
#注：Python的字典、集合 都是用哈希表 实现的
###### 哈希表
# 哈希表一个通过哈希函数来计算数据存 储位置的数据结构，通常支持如下操作：
# insert(key, value)：插入键值对(key,value)
# get(key)：如果存在键为key的键值对则返回其value，否则返回空值
# delete(key)：删除键为key的键值对
#注：这个操作 就是字典的操作
#注：哈希表有key、有value。没有value 只有key 那就是集合(而且key不能重复)
###### 直接寻址表
# 当关键字的全域U比较小时，直接寻址是一种简单而有效的方法。
#注：左边的圆 是 U全域 和 key。根据这个U建了一个T 列表
#注：插入很快，查找很快，删除很快(把元素置成空)
# 直接寻址技术缺点：
# ·当域U很大时，需要消耗大量内存，很不实际 #注：T列表的大小 根据U的，很大的U 列表很大 浪费内存
# ·如果域U很大而实际出现的key很少，则大量空间被浪费 #注：U很大，但字典值很少，浪费内存
# ·无法处理关键字不是数字的情况 #注：key是字符串 有问题
#注：直接寻址表 上面 + 哈希函数，就成为 哈希表
###### 哈希
# 直接寻址表：key为k的元素放到k位置上 #注：比如 key是2的 就放到2的位置上。哈希不是
# 改进直接寻址表：哈希（Hashing）
# ·构建大小为m的寻址表T
# ·key为k的元素放到h(k)位置上
# ·h(k)是一个函数，其将域U映射到表T[0,1,...,m-1] #注：即 输出的值 是0到m-1，m是T列表的长度
#注：之前T 是根据U的大小建的，现在T 自己选个大小。之前 key是k的元素放到k的位置上，现在key为k的元素放到h(k)位置上
#注：h是个函数，能传的参数 是U域里所有的值，输出的值是 0到m-1, m是T列表的大小
#注：h是哈希函数
###### 哈希表
# 哈希表（Hash Table，又称为散列表），是一种线性表的存储结构。哈希表由一个直接寻址表和一个哈希函数组成。哈希函数h(k)将元素关键字k作为自变量，返回元素的存储下标。
#注：哈希表是线性的，不是图 也不是树
# 假设有一个长度为7的哈希表，哈希函数h(k)=k%7。元素集合{14,22,3,5}的存储方式如下图。
# 注：如果是直接寻址表，14存不了，只能存0到6
# 14 % 7 = 0 存到 0这个位置
# 22 % 7 = 1 存到1这个位置
# 3……、5……
# #注：哈希函数h(k)的取值范围 只能是0到6 （因为取余）
# #注：这就是非常经典的哈希函数，除法哈希
#注：再插入一个0 怎么办？ 0 这个位置 已经有值了
###### 哈希冲突
# 由于哈希表的大小是有限的，而要存储的值的总数量是无限的，因此对于任何哈希函数，都会出现两个不同元素映射到同一个位置上的情况，这种情况叫做哈希冲突。
# 比如h(k)=k%7, h(0)=h(7)=h(14)=...
#注：哈希冲突一定会存在，因为开的哈希表 大小是有限的，肯定会有哈希函数2个key 对应1个位置。
#注：哈希函数 2个key 都到了一个位置上，这种现象叫做哈希冲突
###### 解决哈希冲突 -- 开放寻址法
# 开放寻址法：如果哈希函数返回的位置已经有值，则可以向后探查新的位置来存储这个值。
# 线性探查：如果位置i被占用，则探查i+1, i+2,……
# 二次探查：如果位置i被占用，则探查i+1^2 ,i-1^2 ,i+2^2 ,i-2^2 ,……
# 二度哈希：有n个哈希函数，当使用第1个哈希函数h1发生冲突时，则尝试使用h2, h3,……
#注：如果插入 有值 ，插入到其他地方。线性探查：i+1……；二次探查；二度哈希
#-----------
### 注：开放寻址法的 线性查找
#注：哈希表如何查值？比如：22，先找它的哈希函数 h(22),22%7=1，那就到1的位置上去找，直接找 找到了
#注：现在 比如说找0,0%7=0,0 位置找不到，怎么办？先在这查，如果不是 往后找，如果不是，往后找，直到找到空位为止。找到空位如果还没有找到，那么这个哈希表里面肯定没有0
#注：查找也需要 按照 线性探查方式 查找。插入的探查方式 和 查找的探查方式一样，到空位为止
#注：线性探查的效率并不是很高，它的装载因子过大。它的好多东西都特别密，很多东西都在一块
#-----------
### 注：开放寻址表的 二次探查
#注：i+1, i-1, i+4, i-4. i+9, i-9……
#注：它是跳着的，越跳越多
#-----------
### 注：开放寻址表 二度哈希
#注：有好多个哈希函数，如果一个哈希函数冲突了，换另一个
#注：开放寻址表 不太好，哈希表可能满了
###### 解决哈希冲突 -- 拉链法
# 拉链法：哈希表每个位置都连接一个链表，当冲突发生时，冲突的元素将被加到该位置链表的最后。
#注：拉链法：哈希表的一个格子里不是存一个元素，而是存一个链表
#注：冲突元素 如果发现冲突了，就放到这个链表后面 或者前面
#注：插入元素，如果位置是空的，就往后接一个；如果不是空，就在链表最后面或者最前面插一个 （头插尾插 都可以）
#注：查找的话 ，比如 查 155 在这个表里是否有。首先带入哈希函数，发现值是11，那就到11这个位置上来找，然后 就遍历这个链表， 91 不是 ，155 找到了
#注：删除：删除 先找到之后 再删。找到155 后 把它删除，链表的删除 也是O(1)的
#注：拉链法很经典，虽然没有直接寻址表快，但是直接寻址表 可能实现不了
#注：查找复杂度 不好说：如果哈希函数 足够好 ，节点足够平均分到哈希表上，整个的 有n个数，表长度是m。一个位置 有n/m个元素，那最多 只要查n/m次
#注：图示的 哈希函数 是对 16取余数
###### 哈希表 -- 常见哈希函数 *
# 除法哈希法：
# ·h(k) = k % m
# 乘法哈希法：
# ·h(k) = floor(m*(A*key%1))
# 全域哈希法：
# ·ha,b(k) = ((a*key + b) mod p) mod m a,b=1,2,...,p-1
#注：除法哈希 很经典，最好理解的一种哈希。直接对哈希表的长度m 取余数，拿到的值 就是它的下标
#注：乘法哈希 k是 关键字，m是 哈希表大小 ,A是一个值(A是一个小数)， A*key%1， A乘以k对1取模，对1取模 就是取它的小数部分，再向下取整。floor是向下取整，比如说 3.6 向下取3
#注：全域哈希 ha,b(k) = ((a*key + b) mod p) mod m a,b=1,2,...,p-1
#注：a、b 2个参数 a*key + b，mod p 对p取模 (%),括起来对 m取模
#63 哈希表实现
#注：写哈希表 之前，先写个链表
#注：链表的创建
class LinkList: #注：链表类
class Node: #注：链表里的节点
def __init__(self, item=None):
self.item = item
self.next = None
class LinkListIterator: #注：这个类是一个迭代器 因为 支持__next__
def __init__(self, node):
self.node = node
def __next__(self):
if self.node: #注：如果node不是空
cur_node = self.node
self.node = cur_node.next
return cur_node.item
else:
raise StopIteration
def __iter__(self):
return self
def __init__(self, iterable=None): #注：构造函数。传一个列表
self.head = None
self.tail = None
if iterable: #注：如果有列表
self.extend(iterable)
#注：extend()接受一个列表参数 [1,2].extend([1,2,3]) [1,2,1,2,3]
#注：append()接受一个对象参数 [1,2].append([1,2,3]) [1,2,[1,2,3]]
def append(self, obj): #注：尾插
s = LinkList.Node(obj) #注：创建节点
if not self.head: #注：如果head是空
self.head = s
self.tail = s
else: #注：如果head不是空，插到尾巴上
self.tail.next = s
self.tail = s
def extend(self, iterable): #注：循环调appdend 就有extend了
for obj in iterable:
self.append(obj)
def find(self, obj): #注：在链表里查找，for循环查
for n in self: #注：self是linklist对象，self是迭代的支持这种写法
if n == obj:
return True
else:
return False
def __iter__(self): #注：写迭代器的 支持迭代
return self.LinkListIterator(self.head)
def __repr__(self): #注：转换成字符串
return "<<"+", ".join(map(str, self))+">>"
#注：map对于可迭代对象的每个元素 转换成字符串str
lk = LinkList([1,2,3,4,5]) #注：可迭代对象
for element in lk:
print(element)
#结果为
# 1
# 2
# 3
# 4
# 5
print(lk)
#结果 <<1, 2, 3, 4, 5>>
#链表创建 精简代码
class LinkList:
class Node:
def __init__(self, item=None):
self.item = item
self.next = None
class LinkListIterator:
def __init__(self, node):
self.node = node
def __next__(self):
if self.node:
cur_node = self.node
self.node = cur_node.next
return cur_node.item
else:
raise StopIteration
def __iter__(self):
return self
def __init__(self, iterable=None):
self.head = None
self.tail = None
if iterable:
self.extend(iterable)
def append(self, obj):
s = LinkList.Node(obj)
if not self.head:
self.head = s
self.tail = s
else:
self.tail.next = s
self.tail = s
def extend(self, iterable):
for obj in iterable:
self.append(obj)
def find(self, obj):
for n in self:
if n == obj:
return True
else:
return False
def __iter__(self):
return self.LinkListIterator(self.head)
def __repr__(self):
return "<<"+", ".join(map(str, self))+">>"
#注：在这基础上 写 哈希表
# 类似于集合的结构
class HashTable:
def __init__(self, size=101): #注：哈希表的构造函数,size哈希表的大小
self.size = size
self.T = [LinkList() for i in range(self.size)] #注：开一个T列表，每个位置都是一个链表（拉链法）
#注：刚开始T列表 每一个位置都是一个空链表 LinkList()
def h(self, k): #注：哈希函数
return k % self.size #注：对self.size取模
def insert(self, k): #注：插入
#注：计算哈希函数 返回的哈希值
i = self.h(k)
#注：k这个元素 要插到i这个位置上去
#注：判断这个元素在不在里面
if self.find(k): #注：如果找到了，我就不插入。达到哈希 去重的目的
print("Duplicated Insert.") #注：重复插入 提醒
else: #注：如果没找到，插入
self.T[i].append(k) #注：插入
def find(self, k): #注：先写 查找函数
i = self.h(k) #注：先找到k的哈希值
return self.T[i].find(k) #注：T[i] 是个链表
#注：哈希表 删除功能 没写。写删除的话 链表就得支持删除的功能
ht = HashTable() #注：创建HashTable对象
ht.insert(0)
ht.insert(1)
# ht.insert(0)
# #注：输入第3条语句时 ，提示 Duplicated Insert.
ht.insert(3)
ht.insert(102)
ht.insert(508)
print(",".join(map(str, ht.T)))
#注：打印这个哈希表，1和102在一个链表里，因为 哈希表的长度是101，102对101取余剩1
#注：508对101取余剩3
# <<0>>,<<1, 102>>,<<>>,<<3, 508>>,<<>>,<<>>,<<>>,…………
print(ht.find(3))
#结果为 True
print(ht.find(102)) #注：也能找到，它是个链表， 先去1那个位置上找，发现1 不是，102 是，找到了
#结果为 True
print(ht.find(203))
#结果为 False #注：因为发现 1 不是，102 不是，没了 返回一个false
#注：集合实现 跟它差不错
#哈希表 精简代码
# 类似于集合的结构
class HashTable:
def __init__(self, size=101):
self.size = size
self.T = [LinkList() for i in range(self.size)]
def h(self, k):
return k % self.size
def insert(self, k):
i = self.h(k)
if self.find(k):
print("Duplicated Insert.")
else:
self.T[i].append(k)
def find(self, k):
i = self.h(k)
return self.T[i].find(k)
ht = HashTable()
ht.insert(0)
ht.insert(1)
ht.insert(3)
ht.insert(102)
ht.insert(508)
#print(",".join(map(str, ht.T)))
print(ht.find(203))
#64 哈希表应用
#注：哈希表 的应用：Python里的 集合和字典 底层就是哈希表
###### 哈希表的应用 -- 集合与字典
# 字典与集合都是通过哈希表来实现的。
# ·a = {'name': 'Alex', 'age': 18, 'gender': 'Man'}
# 使用哈希表存储字典，通过哈希函数将字典的键映射为下标。假设h('name') = 3, h('age') = 1, h('gender') = 4，则哈希表存储为[None, 18, None, 'Alex', 'Man'] #注：3 1 4 号位置
# 如果发生哈希冲突，则通过拉链法或开发寻址法解决
#注：用哈希表来存，首先 把key传到 哈希函数里去(比如说key='name')，得到一个值 比如说等于3 ( h('name')=3 )，把'Alex'放到3号位置上 ……
#注：之前讲的哈希函数 它的参数 都是整数，字符串 也可以转换成一个整数，以某种方式
a = {'name': 'Alex', 'age': 18, 'gender': 'Man'}
h('name') = 3, h('age') = 1, h('gender') = 4
[None, 18, None, 'Alex', 'Man'] #注：哈希表存储
#注：如果说 字典 条目比较少的话，哈希函数够好，一个内存里 基本上不会拉链拉特别长，可能拉一个到两个，这样 你的按键查找会非常快，包括集合的查找
#注：一个列表 跟一个集合 去查，肯定是集合要快，因为这是 哈希表的查找速度指定的
#注：哈希表的应用 -- md5算法
#注：密码学 主要2个方面：1、加密 解密 2、哈希 比如说md5
#注：md5值 用的最多的是文件，可以用md5值 判断文件是不是一样的，如果这2个文件哈希值一样 其实不能说 这2个文件肯定一样，只能说很大很大概率 这2个文件一样。
#注：因为 md5值 也是一个哈希，有哈希 就一定有哈希冲突。文件可以哈希、字符串也可以哈希，什么都可以md5，哈希值一定是有限的，虽然是128位，2的128次方，但是必然会有2个文件的哈希值 是一样的。
#注：但是 md5值 要求 不能 有限的时间 人工构造，偶然碰上 概率太小
#注：防止的是 人工构造 ，或者说是欺骗
#注：md5 已经被破解了。在安全的方面不是特别重要的 地方可以用：比如 不太重要的网站、比较文件 ；但是 保密特别强的场合 不要用了
#注：2 云存储服务商 比如说 百度云 上传 电影
#注：密码学的哈希函数
#注：SHA-224 就是224位 ，256 就是256 位
#注：SHA-2、MD5 也是 哈希的一个应用，只不过 它的应用不是在存储方面，主要 用在 安全方面的一些校验 、比对 上
#注：哈希值不能反解的，相当于 证明SHA2 安全性 是不可破解的
#注：Python hashlib库里 有对应的函数
#注：哈希表 是一个 很高效的 做查找的数据结构
#65 树的概念
#注：之前讲了很多 线性的 数据结构：列表、链表、栈、队列、哈希表
#注：接下来看 树状数据结构
#注：树是一种数据结构 比如：目录结构
#注：树是一种可以递归定义的数据结构
#注：树是由n个节点组成的集合：
# 如果n=0，那这是一棵空树 #注：相当于递归的终止条件
# 如果n>0，那存在1个节点作为树的根节点，其他节点可以分为m个集合，每个集合本身又是一棵树
#注：n > 0，A是根节点，下面分了m个，m是6。最后都递归完了 汇拢在一起 发现是树
# 一些概念
# 根节点 #注：汇拢起来，最头上那个节点
# 叶子节点 #注：没有孩子的都叫做 叶子节点，因为叶子到头了
# 树的深度（高度） #注：示图 是4 往下走几层。A的深度是1，E的深度是2，J的深度是3，Q的深度是4
# 树的度 #注：节点的度 就是这个节点 分几个叉，比如E节点分2个叉 这个节点的度是2；F节点的度是3
#注：树的度 是这个树里边 所有节点的 最大的那个度。图示 树的度是 6
# 孩子节点/父节点 #注：A是D的父亲节点，D是A的一个孩子节点
# 子树 #注：E I J P Q 也是一棵树，以E为根节点的一棵树，这个树 是整个树的一棵子树，因为它是递归定义的，所以任意一个节点也是一棵子树 比如 节点 B
#66 树的实例：模拟文件系统
#注：树是由节点组成的，树的核心是节点
class Node: #注：先定义树的节点
def __init__(self, name, type='dir'):
self.name = name #注：文件名
self.type = type #"dir" or "file" #注：文件类型 默认dir
#注：节点和节点之间的关联
self.children = []
#注：链表有一个self.next 找它的下一个但是 树 这个下面可能有很多 不是有一个
#注：所以搞一个列表，好多next都放到这个列表里
self.parent = None #注：相当于 指向它的父母
# 链式存储
def __repr__(self):
return self.name #注：只打印 文件名
n = Node("hello") #注：文件夹 hello
n2 = Node("world")
n.children.append(n2) #注：这样 把hello文件夹下面的world文件夹 连起来
#注：这个操作 就相当于单链表，只不过 这里有很多个next
#注：这就是从 hello 找到 world，children 把n 连到n2
n2.parent = n #注：父母只有一个，树的结构决定的，所以不是列表
#注：这样 n2 也可以往回找了
#注：这样就有点像 双链表了。children往下找，相当于 链表 往后找；parent往上找，相当于链表的往前找
#注：一般来说 实现树的时候 children都是有的，parent属性有没有 看自己的需求。实现一棵只是往下链的树也行，只是不能往回找。往回找他的父亲的话，加一个parent
#注：linux文件系统
# /abc.txt
# /var/
class FileSystemTree: #注：写 树的类
def __init__(self): #注：初始化
self.root = Node("/") #注：首先 维护一个根
self.now = self.root #注：还需要 存现在 在哪个目录下
#注：模拟构造操作系统的命令
def mkdir(self, name): #注：传一个name
# name 以 / 结尾
if name[-1] != "/": #注：如果name结尾不是斜杠
name += "/" #注：就补上 /
node = Node(name) #注：创建一个文件夹
#注：再把这个文件夹 跟现在这个文件夹 连起来
self.now.children.append(node) #注：正着连上
node.parent = self.now #注：反着连过去
def ls(self): #注：展示
return self.now.children #注：打印当前目录的children
def cd(self, name): #注：切换目录 绝对路径与相对路径。这里 只可以进入下一级
"../var/python/"
#注：先按斜杠split 然后再一条一条进去，先执行.. 再循环执行这个函数
#注：如果支持绝对路径，还是先按照斜杠split，然后 第一个斜杠 前面肯定是个空，判断如果有空，你不是从now 走，而是从root开始走
#注：相对路径是从now开始走，绝对路径是从root开始走
#注：如果是文件进来的话，还要控制文件，不能让他append东西
if name[-1] != "/":
name += "/"
if name == "../": #注：cd支持向上返回一级
self.now = self.now.parent
return
for child in self.now.children: #注：如果children里有这个name
if child.name == name:
self.now = child #注：就切换目录
return
raise ValueError("invalid dir") #注：如果没有 就报错
tree = FileSystemTree() #注：新建一个树
tree.mkdir("var/")
tree.mkdir("bin/")
tree.mkdir("usr/")
print(tree.root.children)
#结果为 [var/, bin/, usr/]
print(tree.ls())
#结果为 [var/, bin/, usr/]
tree.cd("bin/") #注：进入 bin目录
tree.mkdir("python/") #注：在bin目录下创建 文件夹python
print(tree.ls())
#结果为 [python/]
tree.cd("../")
print(tree.ls()) #注：cd 回去
#结果为 [var/, bin/, usr/]
#注：树 在绝大部分的存储，都是跟链表一样 链式存储。通过往下走 往后指childre，往上 指parent。通过节点和节点之间相互连接的方式 组成树的数据结构
#精简代码
class Node:
def __init__(self, name, type='dir'):
self.name = name
self.type = type #"dir" or "file"
self.children = []
self.parent = None
# 链式存储
def __repr__(self):
return self.name
class FileSystemTree:
def __init__(self):
self.root = Node("/")
self.now = self.root
def mkdir(self, name):
# name 以 / 结尾
if name[-1] != "/":
name += "/"
node = Node(name)
self.now.children.append(node)
node.parent = self.now
def ls(self):
return self.now.children
def cd(self, name):
if name[-1] != "/":
name += "/"
if name == "../":
self.now = self.now.parent
return
for child in self.now.children:
if child.name == name:
self.now = child
return
raise ValueError("invalid dir")
tree = FileSystemTree()
tree.mkdir("var/")
tree.mkdir("bin/")
tree.mkdir("usr/")
tree.cd("bin/")
tree.mkdir("python/")
tree.cd("../")
print(tree.ls())
#结果为 [var/, bin/, usr/]
#67 二叉树概念
#注：二叉树 特殊的树，度不超过2的树，一个节点 最多分2个叉 有区别 左孩子和右孩子
#注：堆排序那里讲了 二叉树的线性存储方式，堆的存储 把数存成一个列表 [0, 1, 2, 3, ……]，父亲找孩子 是 0 找 2i+1 ,2i+2。这种存储方式比较适用于完全二叉树（右边少，左边不会少东西）
#注：这个树 A左边少了好多节点，那这些节点就为空的，如果这个树非常不完全 差很多，那这些空的地方 就浪费空间，所以用另一种存储方式 链式存储
#注：跟树的存储方式是一样的。 只不过 刚才的树 是self.children是个列表，这里二叉树 不用列表 lchid ,rchild 2孩子
#注： lchid ,rchild 2 孩子 左孩子 右孩子 ，往下指2个指针。如果还需要往上面的话，加一个self.parent,不需要 就不用了
#注：data用来存节点的数据
###### 二叉树
# 二叉树的链式存储：将二叉树的节点定义为一个对象，节点之间通过类似链表的链接方式来连接。
# 节点定义：
class BitreeNode: #注：二叉树的节点
def __init__(self, data): #注：构造函数
self.data = data #注：存放数据
self.lchild = None # 左孩子
self.rchild = None # 右孩子
a = BitreeNode("A") #注：手动创建节点
b = BitreeNode("B")
c = BitreeNode("C")
d = BitreeNode("D")
e = BitreeNode("E")
f = BitreeNode("F")
g = BitreeNode("G")
e.lchild = a #注：连起来 ，e的左孩子
e.rchild = g
a.rchild = c
c.lchild = b
c.rchild = d
g.rchild = f #注：这个树连接完事了
root = e
print(root.lchild.rchild.data) #注：打印root左孩子的右孩子 其实就是节点
#结果为 C
#精简代码
class BitreeNode:
def __init__(self, data):
self.data = data
self.lchild = None # 左孩子
self.rchild = None # 右孩子
#68 二叉树遍历
#注：线性的数据结构 都比较好遍历 ：列表 好遍历 for循环，链表 也好遍历 一直去next 取到空为止，栈、队列都好遍历
#注：二叉树怎么遍历？注：二叉树的遍历方式 有4种
###### 二叉树的遍历方式：
# 前序遍历：EACBDGF
# 中序遍历：ABCDEGF
# 后序遍历：BDCAFGE
# 层次遍历：EAGCFBD
class BitreeNode:
def __init__(self, data):
self.data = data
self.lchild = None # 左孩子
self.rchild = None # 右孩子
a = BitreeNode("A") #注：创建节点
b = BitreeNode("B")
c = BitreeNode("C")
d = BitreeNode("D")
e = BitreeNode("E")
f = BitreeNode("F")
g = BitreeNode("G")
e.lchild = a
e.rchild = g
a.rchild = c
c.lchild = b
c.rchild = d
g.rchild = f
root = e
######------注：二叉树的 前序遍历
#注：这个其实是 递归的定义的
def pre_order(root): #注：传一个节点进去
if root: #注：如果root不是空 （是空 就不打印了）
#注：root是空 相当于 是递归的终止条件
print(root.data, end=',') #注：先打印根节点
pre_order(root.lchild) #注：然后访问它的左子树
pre_order(root.rchild) #注：然后访问它的右子树
#注：pre_order(root) 如果不是空，先访问根，再访问左子树，再访问右子树
pre_order(root)
#结果为 E,A,C,B,D,G,F, #注：每个节点都打印一次
# 前序遍历：EACBDGF
#注：pre_order(root) 如果不是空，先访问根，再访问左子树，再访问右子树
#注：图示里面 先访问E，访问完了E， 再去访问 左子树A 递归的(A B C D) 再去访问右子树 (G F)
#注：在(A B C D) 里 ，先访问A ，然后递归左(没有) 递归右(B C D)
#注：(B C D) 里面 先访问 C ，再递归左 B 递归右 D
#注：访问G F ，先访问G ,递归左(没有)，递归右(F)
#注：顺序 EACBDGF 前序遍历
######------注：二叉树的 中序遍历
#注：中序遍历 和 前序遍历不同的是 访问次序不一样
def in_order(root):
if root:
in_order(root.lchild) #注：先 递归左子树 访问左子树
print(root.data, end=",") #注：然后访问自己
in_order(root.rchild) #注：然后 递归右子树
#注：先递归左子树 访问自己 递归右子树
in_order(root)
#结果为 A,B,C,D,E,G,F,
#注：和前序遍历 差别是 访问的顺序不一样了。没有前序遍历那么直观
#注：中序遍历不太直观
#注：先递归左子树 访问自己 递归右子树
#注：所以E在中间…… (先把根节点放中间) 如图
######------注：二叉树的 后序遍历
#注：前序遍历 访问自己在最前面；中序遍历 访问自己在中间；后序遍历 访问自己在最后
def post_order(root):
if root:
post_order(root.lchild) #注：先 递归左
post_order(root.rchild) #注：然后 递归右
print(root.data, end=",") #注：最后 打印自己
#注：后序遍历，先 递归左；然后 递归右；最后 打印自己
post_order(root)
#结果为 B,D,C,A,F,G,E,
#注：先左(A B C D) 后右(G F) 最后自己 E ……
#注：先确定打印的 即最后的 放最后面
#注：这三种遍历 在面试中 被问到的比较多
#注：它还有一个别的类型的问题
#注：知道一棵二叉树的 前序遍历和 中序遍历，确定这棵树 并给出 后续遍历
#注：一但给2个遍历的序列，就能确定这个树
# 前序遍历：EACBDGF
# 中序遍历：ABCDEGF
#注：前序遍历 先访问自己，第1个一定是根 ：E是根
#注：中序序列 根在最中间：知道E是根了 对应的去看中序序列；A B C D 是E的左孩子，G F 是E的右孩子
#注：前序序列 ：A B C D 里，A是根 递归的
#注：再看 中序序列 ：A B C D ,说明A 左子树 是空的，右子树 是 B C D
#注：接下来看B C D, 看前序序列 ：C B D ,C是根
#注：再看中序序列， C是根 B C D ,B是C的左孩子，D是C的右孩子
#注：A、B、C、D 出来了，看G F
#注：看前序序列 G F,G是根
#注：F 看中序序列，G F ，F在右边，所以F是G的右孩子，G的左孩子是空
#注：这就是 前序序列 和 中序序列 还原出来这棵树，有了树之后，就可以画 后序序列了
#注：这是 给前中 可以推；同样给后序和中序 也可以画出来
#注：前序的时候 看第一个是根，后序的时候 最后一个是根，所以倒着看 同样的道理
#注：面试：实现 二叉树的 三种遍历方式：递归的写法。给2个序列，确定最后一个序列，或者说 给你2个序列，让你写函数 来构造出来这棵树
######------注：二叉树的 层次遍历
#注：很好理解 按层来 E A G C F B D ,一层一层的 每一层 从左到右
#注：怎么写？用到 队列 ：刚开始访问E 没有问题，E出队 接下来E的孩子们进队 A G进队，现在队列里是A G
#注：A出队,A的孩子C进队， 队列里剩下 G C；G出队 ，G的孩子F进队，队列里剩下 C F;接下来 C出队 ，B D 进队；F 出队，没有孩子进队；B出队 没有孩子进队；D出队 没有孩子进队
#注：所以这个序列就是 层次遍历的序列 ：EAGCFBD
#注：层次遍历 不光适用于 二叉树 ，多叉树 也可以。二叉树 左孩子进队 右孩子进队；多叉树 children 挨个进队
from collections import deque #注：使用之前queue队列
def level_order(root):
queue = deque() #注：首先创建空队列
queue.append(root) #注：然后 root进队
while len(queue) > 0: # 只要队不空，一直访问
#注：先出队一个元素 ，然后把它的孩子进队
node = queue.popleft() #注：出队
print(node.data, end=',') #注：打印
if node.lchild: #注：判断node的左孩子是不是有
queue.append(node.lchild) #注：如果有，就append node左孩子
if node.rchild: #注：如果node的右孩子有，它也进队
queue.append(node.rchild)
level_order(root)
#结果为 E,A,G,C,F,B,D,
#精简代码
class BitreeNode:
def __init__(self, data):
self.data = data
self.lchild = None # 左孩子
self.rchild = None # 右孩子
a = BitreeNode("A") #注：创建节点
b = BitreeNode("B")
c = BitreeNode("C")
d = BitreeNode("D")
e = BitreeNode("E")
f = BitreeNode("F")
g = BitreeNode("G")
e.lchild = a
e.rchild = g
a.rchild = c
c.lchild = b
c.rchild = d
g.rchild = f
root = e
#------ 前序遍历
def post_order(root):
if root:
post_order(root.lchild)
post_order(root.rchild)
print(root.data, end=",")
pre_order(root)
# 前序遍历：EACBDGF
#------ 中序遍历
def in_order(root):
if root:
in_order(root.lchild)
print(root.data, end=",")
in_order(root.rchild)
in_order(root)
# 中序遍历：ABCDEGF
#------ 后序遍历
def post_order(root):
if root:
post_order(root.lchild)
post_order(root.rchild)
print(root.data, end=",")
post_order(root)
# 后序遍历：BDCAFGE
#------ 层次遍历
from collections import deque
def level_order(root):
queue = deque()
queue.append(root)
while len(queue) > 0: # 只要队不空
node = queue.popleft()
print(node.data, end=',')
if node.lchild:
queue.append(node.lchild)
if node.rchild:
queue.append(node.rchild)
level_order(root)
# 层次遍历：EAGCFBD
#注：层次遍历 不光适用于 二叉树 还适用于 多叉树
#69 二叉搜索树的概念
#注：具体的 二叉树 一种用法：二叉搜索树
###### 二叉搜索树 (binary search tree bst)
# 二叉搜索树是一棵 二叉树 且满足性质：设x是二叉树的一个节点。如果y是x左子树的一个节点，那么y.key ≤ x.key；如果y是x右子树的一个节点，那么y.key ≥ x.key。
# 二叉搜索树的操作：查询、插入、删除
#注：y.key 就是y上存的那个值，可以存键值对 ，也可以只存一个键。左子树上的 所有节点的值 都比它小，右子树上的 所有节点的值 都比它大
#注：一个节点 左子树上的 所有节点的值 都比它小，右子树上的 所有节点的值 都比它大。如果所有节点 都满足这个性质，那么 他就是二叉搜索树
#注：有了这个性质后，可以做的操作：查询、插入、删除
#注：有了这个性质后，查询 非常好查：比如说 查11 在不在这个树里面，先和根比，11比根小，所以如果11在的话 一定在根的左边；那就到左边查，跟5比，发现11比5大，如果11存在，那一定在5的右边；然后发现11 找到了
#注：找7 ，跟17比 ，往左边找；跟5比 往右边找；跟11比 往左边找；跟9比 往左边找；跟8比往左边找 但是8左边是空了，没有了 找不到了
#注：所以 查询操作 只要执行 树的深度次 就可以了
#注：插入操作： 插入32 ，插肯定往叶子节点插 ，往最下面这层插；32 跟17比 ，往右边走，插到它的右子树上来；跟35 比，插到它的左边来；跟29比 ，插到它的右边 ，右边只要没有 ，就插到这来
#注：插入和查询差不多，反正就是 往深处走，走到一个地方，只要这个地方没有了 ，那就插在这
#注：查询 和 插入 复杂度 大概 logn 跟二分查找不一样 但是差不多，每次都少一半
#70 二叉搜索树：插入
class BiTreeNode: #注：树的节点
def __init__(self, data):
self.data = data
self.lchild = None # 左孩子
self.rchild = None # 右孩子
self.parent = None #注：查询和插入操作 不用它也行，但删除操作要用
#注：加了parent就是双链表
class BST:
def __init__(self, li=None): #注：构造函数 可以传一个列表进来
self.root = None #注：构造函数 先创造一个根节点
if li: #注：如果li不是None
for val in li: #注：就使用非递归的方法 把val插进来 。因为递归方法 慢
self.insert_no_rec(val)
#注：递归的写法
def insert(self, node, val): #注：插入函数 ,node就是递归的插到哪个节点上去
if not node: #注：如果node是空,就找到这个位置了，把值插入
node = BiTreeNode(val) #注：相当于创建一个节点，但还没和树连起来
#注：如果node不为空，分3种情况
elif val < node.data: #注：如果val比node节点小，往左走,递归调左孩子
node.lchild = self.insert(node.lchild, val) #注：左孩子传进来，递归左孩子。并把值传给node.lchild 因为返回它自己
#注：这是 插到node的左孩子里，让它两连起来；还要连parent
node.lchild.parent = node #注：它的左孩子的父亲是它
elif val > node.data: #注：如果 val > node.data ， 递归右孩子，从右孩子里面找
node.rchild = self.insert(node.rchild, val)
node.rchild.parent = node #注：连parent
# else: #注：第3种情况 如果说 等于了
#注：如果说 等于的话，其实可以，但是一般情况下 默认键(值) 不能相等。等于 可以统一规定去右边(或者左边)。查找的话 只能说查找一个
#注：一般说 要求是 键值对，键不能重复。如果有这种情况 但是键会重复 ，可以给这个节点 加一个数据域，叫做count ,等于了 给这个节点count +1
return node
#注：这是 递归的写法
#注：非递归的写法 一般来说 非递归的比递归的快一点
def insert_no_rec(self, val):
#注：首先 一层层往下找(指针也好，其他也好)，找一个p
p = self.root #注：p刚开始等于root
#注：如果来的节点 比它小，那p就往它左孩子走，……右孩子走
if not p: #注：空树的情况下，特殊处理下
self.root = BiTreeNode(val) #注：直接给root赋值一个就可以了
return
while True: #注：如果不是空树，循环 3种情况
if val < p.data: #注：往左子树上走；需要判断它左子树上 有没有
#注：如果左子树上有，那么p=左子树；如果左子树是None,就把val插到这
if p.lchild: #注：如果p的左子树 不是None
p = p.lchild #注：p往左子树上走一下
else: #注：左孩子不存在
p.lchild = BiTreeNode(val) #注：就把值插到这
p.lchild.parent = p #注：双向的指定 ，连接parent
return
elif val > p.data: #注：第2种情况，和上面一样的，把l换成r
if p.rchild: #注：如果 右孩子存在
p = p.rchild #注：p就往右孩子上走
else: #注：如果 右孩子不存在
p.rchild = BiTreeNode(val) #注：它的右孩子 就等于 一个新的节点
p.rchild.parent = p #注：再建立parent连接
return
else: #注：等于的情况，什么都不干
return
#注：Python的集合也是这样，插入的时候 如果重复，什么都不提示，但是它没有插入
#注：前面讲的 三种遍历：前序遍历、中序遍历、后序遍历
def pre_order(self,root):
if root:
print(root.data, end=",")
self.pre_order(root.lchild)
self.pre_order(root.rchild)
def in_order(self,root):
if root:
self.in_order(root.lchild)
print(root.data, end=",")
self.in_order(root.rchild)
def post_order(self,root):
if root:
self.post_order(root.lchild)
self.post_order(root.rchild)
print(root.data, end=",")
tree = BST([4,6,7,9,2,1,3,5,8])
tree.pre_order(tree.root)
print("")
tree.in_order(tree.root)
print("")
tree.post_order(tree.root)
#结果为
# 4,2,1,3,6,5,7,9,8,
# 1,2,3,4,5,6,7,8,9,
# 1,3,2,5,8,9,7,6,4,
#注：由前序和中序，可以画出这棵树，这肯定是一个满足二叉搜索树的情况
#注：中序遍历 1,2,3,4,5,6,7,8,9, 是排好序的，是巧合吗？
import random
li = list(range(500))
random.shuffle(li)
tree = BST(li)
tree.in_order(tree.root) #注：中序序列 排好序的，不是巧合
#结果为 0,1,2,3,4,5,6,7,8,9,10
#注：二叉搜索树的 中序序列 一定是升序的
#注：中序序列 先左，再自己，再右。所以 先输出的 一定是整个序列最小的，因为 左孩子永远是最小的
#注：在 二叉搜索树里，左比中小，右比中大；左先出去 小的先出，然后中 右，从小到大
#精简代码
import random
class BiTreeNode:
def __init__(self, data):
self.data = data
self.lchild = None # 左孩子
self.rchild = None # 右孩子
self.parent = None
class BST:
def __init__(self, li=None):
self.root = None
if li:
for val in li:
self.insert_no_rec(val)
# 递归写法
def insert(self, node, val):
if not node:
node = BiTreeNode(val)
elif val < node.data:
node.lchild = self.insert(node.lchild, val)
node.lchild.parent = node
elif val > node.data:
node.rchild = self.insert(node.rchild, val)
node.rchild.parent = node
return node
# 不递归的写法
def insert_no_rec(self, val):
p = self.root
if not p: # 空树
self.root = BiTreeNode(val)
return
while True:
if val < p.data:
if p.lchild:
p = p.lchild
else: # 左孩子不存在
p.lchild = BiTreeNode(val)
p.lchild.parent = p
return
elif val > p.data:
if p.rchild:
p = p.rchild
else:
p.rchild = BiTreeNode(val)
p.rchild.parent = p
return
else:
return
# 三种排序
def pre_order(self, root):
if root:
print(root.data, end=',')
self.pre_order(root.lchild)
self.pre_order(root.rchild)
def in_order(self, root):
if root:
self.in_order(root.lchild)
print(root.data, end=',')
self.in_order(root.rchild)
def post_order(self, root):
if root:
self.post_order(root.lchild)
self.post_order(root.rchild)
print(root.data, end=',')
li = list(range(500))
random.shuffle(li)
tree = BST(li)
tree.pre_order(tree.root)
print("")
tree.in_order(tree.root)
print("")
tree.post_order(tree.root)
#结果为
# 前序遍历……
# 中序遍历0,1,2,3,4,5,6,7,……
# 后序遍历……