二叉树
概念
二叉树是n(n>=0)个结点的有限集合,该集合或者为空集(称为空二叉树),
或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树组成。
特点
每个结点最多有两颗子树,所以二叉树中不存在度大于2的结点
左子树和右子树是有顺序的,次序不能任意颠倒
即使树中某结点只有一棵子树,也要区分它是左子树还是右子树
性质
1)在二叉树的第 i 层上最多有 2i-1 个节点 。(i>=1)
2)二叉树中如果深度为k,那么最多有 2k-1 个节点。 (k>=1)
3)n0=n2+1 n0表示度数为0的节点数,n2表示度数为2的节点数。
4)在完全二叉树中,具有n个节点的完全二叉树的深度为[log2n]+1,其中[log2n]是向下取整。
5)若对含 n 个结点的完全二叉树从上到下且从左至右进行 1 至 n 的编号,则对完全二叉树中任意一个编号为 i 的结点有如下特性:
(1) 若 i=1,则该结点是二叉树的根,无双亲, 否则,编号为 [i/2] 的结点为其双亲结点;
(2) 若 2i>n,则该结点无左孩子, 否则,编号为 2i 的结点为其左孩子结点;
(3) 若 2i+1>n,则该结点无右孩子结点, 否则,编号为2i+1 的结点为其右孩子结点。
层
度
类型
斜树
所有的结点都只有左子树的二叉树叫左斜树。
所有结点都是只有右子树的二叉树叫右斜树。
这两者统称为斜树。
满二叉树
在一棵二叉树中。
如果所有分支结点都存在左子树和右子树,
并且所有叶子都在同一层上,这样的二叉树称为满二叉树。
满二叉树的特点有:
1)叶子只能出现在最下一层。出现在其它层就不可能达成平衡。
2)非叶子结点的度一定是2。
3)在同样深度的二叉树中,满二叉树的结点个数最多,叶子数最多。
完全二叉树
对一颗具有n个结点的二叉树按层编号
如果编号为 i(1<=i<=n) 的结点与同样深度的满二叉树中编号为 i 的结点在二叉树中位置完全相同
则这棵二叉树称为完全二叉树。
特点
1)叶子结点只能出现在最下层和次下层。
2)最下层的叶子结点集中在树的左部。
3)倒数第二层若存在叶子结点,一定在右部连续位置。
4)如果结点度为1,则该结点只有左孩子,即没有右子树。
5)同样结点数目的二叉树,完全二叉树深度最小。
注:满二叉树一定是完全二叉树,但反过来不一定成立。
存储结构
顺序存储
二叉树的顺序存储结构就是使用一维数组存储二叉树中的结点,
并且结点的存储位置,就是数组的下标索引。
二叉链表
既然顺序存储不能满足二叉树的存储需求,那么考虑采用链式存储。
由二叉树定义可知,二叉树的每个结点最多有两个孩子。
因此,可以将结点数据结构定义为一个数据和两个指针域。
二叉树实现
定义一个左子树, 定义一个柚子树, 以及值
classBinTree:def __init__(self,value=None,left=None,right=None):
self.value=value
self.left=left #左子树
self.right=right #右子树
二叉树遍历
先序遍历
先处理根, 之后是左子树, 然后是右子树
中序遍历
先处理左子树, 之后是根, 然后是右子树
后序遍历
先处理左子树, 之后是右子树, 最后是根
代码示例
defpreTraverse(root):'''先序遍历'''
if root is notNone:print(root.value)
preTraverse(root.left)
preTraverse(root.right)defmidTraverse(root):'''中序遍历'''
if root is notNone:
midTraverse(root.left)print(root.value)
midTraverse(root.right)defafterTraverse(root):'''后序遍历'''
if root is notNone:
afterTraverse(root.left)
afterTraverse(root.right)print(root.value)
堆
最大堆 / 最小堆
最大 / 小堆是一棵完全二叉树,非叶子结点的值不大 / 小于左孩子和右孩子的值
构建原理
初始数组为:9,3,7,6,5,1,10,2
按照完全二叉树,将数字依次填入。
填入后,找到最后一个结点(本示例为数字2的节点),从它的父节点(本示例为数字6的节点)
开始调整。根据性质,小的数字往上移动;至此,第1次调整完成。
注意,被调整的节点,还有子节点的情况,需要递归进行调整。
第二次调整,是数字6的节点数组下标小1的节点(比数字6的下标小1的节点是数字7的节点),
用刚才的规则进行调整。以此类推,直到调整到根节点。
元素插入
以上个最小堆为例,插入数字0。
数字0的节点首先加入到该二叉树最后的一个节点,依据最小堆的定义,自底向上,递归调整。
元素删除
代码实现
最小堆
classMinHeap(object):"""最小堆"""
def __init__(self):
self.data= [] #创建堆
self.count = len(self.data) #元素数量
#def __init__(self, arr):
#self.data = copy.copy(arr)
#self.count = len(self.data)
#i = self.count / 2
#while i >= 1:
#self.shiftDown(i)
#i -= 1
defsize(self):returnself.countdefisEmpty(self):return self.count ==0definsert(self, item):#插入元素入堆
self.data.append(item)
self.count+= 1self.shiftup(self.count)defshiftup(self, count):#将插入的元素放到合适位置,保持最小堆
while count > 1 and self.data[(count / 2) - 1] > self.data[count - 1]:
self.data[(count/ 2) - 1], self.data[count - 1] = self.data[count - 1], self.data[(count / 2) - 1]
count/= 2
defextractMin(self):#出堆
if self.count >0:
ret=self.data[0]
self.data[0], self.data[self.count- 1] = self.data[self.count - 1], self.data[0]
self.data.pop()
self.count-= 1self.shiftDown(1)returnretdefshiftDown(self, count):#将堆的索引位置元素向下移动到合适位置,保持最小堆
while 2 * count <=self.count:#证明有孩子
j = 2 *countif j + 1 <=self.count:#证明有右孩子
if self.data[j] < self.data[j - 1]:
j+= 1
if self.data[count - 1] <= self.data[j - 1]:#堆的索引位置已经小于两个孩子节点,不需要交换了
breakself.data[count- 1], self.data[j - 1] = self.data[j - 1], self.data[count - 1]
count= j
最大堆
"""最大堆"""
classMaxHeap(object):#def __init__(self):
#self.data = [] # 创建堆
#self.count = len(self.data) # 元素数量
def __init__(self, arr):
self.data=copy.copy(arr)
self.count=len(self.data)
i= self.count / 2
while i >= 1:
self.shiftDown(i)
i-= 1
defsize(self):returnself.countdefisEmpty(self):return self.count ==0definsert(self, item):#插入元素入堆
self.data.append(item)
self.count+= 1self.shiftup(self.count)defshiftup(self, count):#将插入的元素放到合适位置,保持最大堆
while count > 1 and self.data[(count / 2) - 1] < self.data[count - 1]:
self.data[(count/ 2) - 1], self.data[count - 1] = self.data[count - 1], self.data[(count / 2) - 1]
count/= 2
defextractMax(self):#出堆
if self.count >0:
ret=self.data[0]
self.data[0], self.data[self.count- 1] = self.data[self.count - 1], self.data[0]
self.data.pop()
self.count-= 1self.shiftDown(1)returnretdefshiftDown(self, count):#将堆的索引位置元素向下移动到合适位置,保持最大堆
while 2 * count <=self.count:#证明有孩子
j = 2 *countif j + 1 <=self.count:#证明有右孩子
if self.data[j] > self.data[j - 1]:
j+= 1
if self.data[count - 1] >= self.data[j - 1]:#堆的索引位置已经大于两个孩子节点,不需要交换了
breakself.data[count- 1], self.data[j - 1] = self.data[j - 1], self.data[count - 1]
count= j
heapq 模块
官方文档 这里
Python 自带的用于堆结构方便的模块
创建堆 - 最小堆
单个添加创建堆 - heappush
importheapq
data= [1,5,3,2,8,5]
heap=[]for n indata:
heapq.heappush(heap, n)
对已存在的序列转化为堆 - heapify
importheapq
data= [1,5,3,2,8,5]
heapq.heapify(data)
对多个序列转化为堆 - merge
importheapq
num1= [32, 3, 5, 34, 54, 23, 132]
num2= [23, 2, 12, 656, 324, 23, 54]
num1=sorted(num1)
num2=sorted(num2)
res=heapq.merge(num1, num2)print(list(res)) #[2, 3, 5, 12, 23, 23, 23, 32, 34, 54, 54, 132, 324, 656]
创建堆 - 最大堆
用法同最小堆, 创建的时候将所有的值取相反数
然后在取出堆顶, 在进行取反, 即可获得原值
importheapq
data= [1, 5, 3, 2, 8, 5]
li=[]for i indata:
heapq.heappush(li,-i)print(li) #[-8, -5, -5, -1, -2, -3]
print(-li[0]) #8
访问堆内容
查看最小值 - [0]
importheapq
data= [1, 5, 3, 2, 8, 5]
heapq.heapify(data)print(data[0]) #1
弹出最小值 - heappop
会改变原数据, 类似于列表的 pop
importheapq
data= [1, 5, 3, 2, 8, 5]
heapq.heapify(data)print(heapq.heappop(data)) #1
print(data) #[2, 5, 3, 5, 8]
向堆内推送值 - heappush
importheapq
data= [1, 5, 3, 2, 8, 5]
heapq.heapify(data)
heapq.heappush(data,10)print(data) #[1, 2, 3, 5, 8, 5, 10]
弹出最小值并加入一个值 - heappushpop
弹出最小值, 添加新值, 且自动排序保持是最小堆
importheapq
data= [1, 5, 3, 2, 8, 5]
heapq.heapify(data)print(heapq.heappushpop(data, 1)) #1
print(data) #[1, 2, 3, 5, 8, 5]
弹出最小值并加入一个值 - heapreplace
弹出最小值, 添加新值, 且自动排序保持是最小堆
是 heappushpop 的高效版本, 在py3 中适用
importheapq
data= [1, 5, 3, 2, 8, 5]
heapq.heapify(data)print(heapq.heapreplace(data, 10)) #1
print(data) #[2, 5, 3, 10, 8, 5]
k 值问题 - nlargest / nsmallest
找出堆中最小 / 大的 k 个值
importheapq
data= [1, 5, 3, 2, 8, 5]
heapq.heapify(data)print(data) #[1, 2, 3, 5, 8, 5]
print(heapq.nlargest(2, data)) #[8, 5]
print(heapq.nsmallest(2, data)) #[1, 2]
可以接收一个参数 key , 用于指定选项进行选取
用法类似于 sorted 的 key
importheapqfrom pprint importpprint
portfolio=[
{'name': 'IBM', 'shares': 100, 'price': 91.1},
{'name': 'AAPL', 'shares': 50, 'price': 543.22},
{'name': 'FB', 'shares': 200, 'price': 21.09},
{'name': 'HPQ', 'shares': 35, 'price': 31.75},
{'name': 'YHOO', 'shares': 45, 'price': 16.35},
{'name': 'ACME', 'shares': 75, 'price': 115.65}
]
cheap= heapq.nsmallest(3, portfolio, key=lambda s: s['price'])
expensive= heapq.nlargest(3, portfolio, key=lambda s: s['price'])
pprint(cheap)
pprint(expensive)"""输出:
[{'name': 'YHOO', 'price': 16.35, 'shares': 45},
{'name': 'FB', 'price': 21.09, 'shares': 200},
{'name': 'HPQ', 'price': 31.75, 'shares': 35}]
[{'name': 'AAPL', 'price': 543.22, 'shares': 50},
{'name': 'ACME', 'price': 115.65, 'shares': 75},
{'name': 'IBM', 'price': 91.1, 'shares': 100}]"""