数据结构与算法Python版之北大慕课笔记(四)
一、树
- 树是一种非线性的数据结构,一般数据结构的图示把根放在上方,叶放在下方。
- 树是一种分层结构,越接近顶部的层越普遍,越接近底部的层越独特。
- 分类树的第二个特征:一个节点的子节点与另一个节点的子节点相互之间是隔离、独立的。
- 分类树的第三个特征:每一个叶节点都具有唯一性。可以用从根开始到达每个种的完全路径来唯一标识每个物种。
1. 树结构相关术语
- 节点Node:组成树的基本部分,每个节点具有名称,或“键值”,节点还可以保存额外数据项,数据项根据不同的应用而变。
- 边Edge:边是组成树的另一个基本部分。每条边恰好连接两个节点,表示节点之间具有关联,边具有出入方向;每个节点(除根节点)恰有一条来自另一节点的入边;每个节点可以有多条连到其他节点的出边。
- 根Root:树中唯一一个没有入边的节点。
- 路径Path:由边依次连接在一起的节点的有序列表。
- 子节点Children:入边均来自于同一个节点的若干节点,称为这个节点的子节点。
- 父节点Parent:一个节点是其所有出边所连接节点的父节点。
- 兄弟节点Sibling:具有同一个父节点的节点之间称为兄弟节点。
- 子树Subtree:一个节点和其所有子孙节点,以及相关边的集合。
- 叶节点Leaf:没有子节点的节点称为叶节点。
- 层级Level:从根节点开始到达一个节点的路径,所包含的边的数量,称为这个节点的层级。根节点层级为0。
- 高度:树中所有节点的最大层级称为树的高度。
2. 树的定义
2.1 树的定义1
树由若干节点,以及两两连接节点的边组成,并具有以下性质:
- 其中一个节点被设定为根;
- 每个节点n(除根节点),都恰连接一条来自节点p的边,p是n的父节点;
- 每个节点从根开始的路径是唯一的。
- 如果每个节点最多有两个子节点,这样的树称为“二叉树”。
2.2 树的定义2(递归定义)
树是:
- 空集;或者由根节点及0或多个子树构成(其中子树也是树),每个子树的根到根节点具有边相连。
二、实现树
1. 嵌套列表法
-
首先我们尝试用Python List来实现二叉树数据结构。
-
递归的嵌套列表实现二叉树,由具有3个元素的列表实现: [root, left, right]
- 第1个元素为根节点的值;
- 第2个元素是左子树(所以也是一个列表);
- 第3个元素是右子树(所以也是一个列表)。
-
对于二叉树,根是myTree[0],左子树myTree[1],右子树myTree[2]。
-
嵌套列表法的优点:子树的结构与树相同,是一种递归数据结构;很容易扩展到多叉树,仅需要增加列表元素即可。
嵌套列表法代码:
def BinaryTree(r): # 创建仅有根节点的二叉树
return [r, [], []]
def insertLeft(root,newBranch): # 将新节点插入树中作为其直接的左子节点
t = root.pop(1)
if len(t) > 1:
root.insert(1,[newBranch,t,[]])
else:
root.insert(1,[newBranch,[],[]])
return root
def insertRight(root,newBranch): # 将新节点插入树中作为其直接的右子节点
t = root.pop(2)
if len(t) > 1:
root.insert(2,[newBranch,[],t])
else:
root.insert(2, [newBranch, [], []])
return root
def getRootVal(root): # 取得根节点
return root[0]
def setRootVal(root,newVal): # 设置根节点
root[0] = newVal
def getLeftChild(root): # 返回左子树
return root[1]
def getRightChild(root): # 返回右子树
return root[2]
代码运行示例:
2. 节点链接法
每个节点保存根节点的数据项,以及指向左右子树的链接。
节点链接法代码:
class BinaryTree:
def __init__(self,rootObj):
self.key = rootObj # 成员key保存根节点数据项
self.leftChild = None # 成员leftChild保存指向左子树的引用
self.rightChild = None # 成员rightChild保存指向右子树的引用
def insertLeft(self,newNode):
if self.leftChild == None:
self.leftChild = BinaryTree(newNode)
else:
t = BinaryTree(newNode)
t.leftChild = self.leftChild
self.leftChild = t
def insertRight(self,newNode):
if self.rightChild == None:
self.rightChild = BinaryTree(newNode)
else:
t = BinaryTree(newNode)
t.rightChild = self.rightChild
self.rightChild = t
def getRightChild(self):
return self.rightChild
def getLeftChild(self):
return self.leftChild
def setRootVal(self,obj):
self.key = obj
def getRootVal(self):
return self.key
代码运行示例:
三、树的应用:表达式解析
- 可以将表达式表示为树结构,叶节点保存操作数,内部节点保存操作符。
- 表达式层次决定计算的优先级,越底层的表达式,优先级越高。例如全括号表达式:((7+3)*(5-2))
- 树中的每个子树都表示一个子表达式。将子树替换为子表达式值的节点,即可实现求值。
1. 创建表达式解析树:过程
- 首先,全括号表达式要分解为单词Token列表。其单词分为括号、操作符和操作数这几类,左括号是表达式的开始,而右括号是表达式的结束。对于全括号表达式:(3+(4*5))
2. 建立表达式解析树:规则
从左到右扫描全括号表达式的每个单词,依据规则建立解析树。
-
如果当前单词是 “(”:为当前节点添加一个新节点作为其左子节点,当前节点下降为这个新节点;
-
如果当前单词是操作符 “+, -, *, /”:将当前节点的值设为此符号,为当前节点添加一个新节点作为其右子节点,当前节点下降为这个新节点;
-
如果当前单词是操作数:将当前节点的值设为此数,当前节点上升到父节点;
-
如果当前单词是 “)”:则当前节点上升到父节点。
3. 建立表达式解析树:思路
创建树过程中关键的是对当前节点的跟踪,我们可以用一个栈来记录跟踪父节点。当前节点下降时,将下降前的节点push入栈;当前节点需要上升至父节点时,上升到pop出栈的节点即可。
建立表达式解析树代码实现:
def buildParseTree(fpexp):
fplist = fpexp.split()
pStack = Stack()
eTree = BinaryTree('')
pStack.push(eTree) # 入栈下降
currentTree = eTree
for i in fplist:
if i == '(': # 表达式开始
currentTree.insertLeft('')
pStack.push(currentTree) # 入栈下降
currentTree = currentTree.getLeftChild()
elif i not in ['+','-','*','/',')']: # 操作数
currentTree.setRootVal(int(i))
parent = pStack.pop() # 出栈上升
currentTree = parent
elif i in ['+','-','*','/']: # 操作符
currentTree.setRootVal(i)
currentTree.insertRight('')
pStack.push(currentTree)
currentTree = currentTree.getRightChild()
elif i == ')': # 表达式结束
currentTree = pStack.pop() # 出栈上升
else:
raise ValueError
return eTree
4. 利用表达式解析树求值:思路
-
由于二叉树BinaryTree是一个递归数据结构,自然可以用递归算法来处理。
-
求值递归函数evaluate,可从树的底层子树开始,逐步向上层求值,最终得到整个表达式的值。
-
求值递归函数evaluate的递归三要素:
- 基本结束条件:叶节点是最简单的子树,没有左右子节点,其根节点的数据项即为子表达式树的值。
- 缩小规模:将表达式树分为左子树、右子树,即为缩小规模。
- 调用自身:分别调用evaluate计算左子树和右子树的值,然后将左右子树的值依根节点的操作符进行计算,从而得到表达式的值。
-
一个增加程序可读性的技巧:函数引用
import operator op = operator.add n = op(1,2)
表达式解析树求值代码实现:
import operator
def evaluate(parseTree):
opers = {'+':operator.add, '-':operator.sub,
'*':operator.mul, '/':operator.truediv}
# 缩小规模:
leftC = parseTree.getLeftChild()
rightC = parseTree.getRightChild()
if leftC and rightC:
fn = opers[parseTree.getRootVal()]
return fn(evaluate(leftC),evaluate(rightC)) # 递归调用
else:
return parseTree.getRootVal() # 基本结束条件
四、树的遍历Tree Traversals
按照对节点访问次序的不同来区分3种遍历:
- 前序遍历(preorder):先访问根节点,再递归地前序访问左子树、最后前序访问右子树。
- 中序遍历(inorder):先递归地中序访问左子树,再访问根节点,最后中序访问右子树。
- 后序遍历(postorder):先递归地后续访问左子树,再后续访问右子树,最后访问根节点。
前序遍历的例子:
树的遍历:递归算法代码
# 树的遍历:递归算法代码
# 前序遍历:
def preorder(tree):
if tree:
print(tree.getRootVal())
preorder(tree.getLeftChild())
preorder(tree.getRightChild())
# 后序遍历:
def postorder(tree):
if tree:
postorder(tree.getLeftChild())
postorder(tree.getRightChild())
print(tree.getRootVal())
# 中序遍历:
def inorder(tree):
if tree:
inorder(tree.getLeftChild())
print(tree.getRootVal())
inorder(tree.getRightChild())
在BinaryTree类里实现前序遍历,需要加入子树是否为空的判断:
def preorder(self):
print(self.key)
if self.leftChild:
self.leftChild.preorder()
if self.rightChild:
self.rightChild.preorder()
后序遍历:表达式求值
# 后序遍历:表达式求值
def postordereval(tree):
opers = {'+':operator.add, '-':operator.sub,
'*':operator.mul, '/':operator.truediv}
res1 = None
res2 = None
if tree:
res1 = postordereval(tree.getLeftChild()) # 左子树
res2 = postordereval(tree.getRightChild()) # 右子树
if res1 and res2:
return opers[tree.getRootVal()](res1,res2) # 根节点
else:
return tree.getRootVal()
五、优先队列Priority Queue
-
队列有一种变体称为“优先队列”。优先队列的出队跟队列一样从队首出队;
-
但在优先队列内部,数据项的次序却是由“优先级”来确定:
1. 高优先级的数据项排在队首,而低优先级的数据项排在后面。
2. 这样,优先队列的入队操作就比较复杂,需要将数据项根据其优先级尽量挤到队列前方。
- 实现优先队列的经典方案是采用二叉堆数据结构,二叉堆能够将优先队列的入队和出队复杂度都保持在O(logn)。
- 二叉堆的有趣之处在于,其逻辑结构上像二叉树,却是用非嵌套的列表来实现的。
- 最小key排在队首的称为“最小堆min heap”;反之,最大key排在队首的是“最大堆max heap”。
1. 用非嵌套列表实现二叉堆
-
为了使堆操作能保持在对数水平上,就必须采用二叉树结构。
-
同样,如果要使操作始终保持在对数数量级上,就必须始终保持二叉树的平衡,树根左右子树拥有相同数量的节点。
-
或者采用“完全二叉树”的结构来近似实现平衡。完全二叉树,叶节点最多只出现在最底层和次底层,而且最底层的叶节点都连续集中在最左边,每个内部节点都有两个子节点,最多可有1个节点例外。
-
完全二叉树由于其特殊性,可以用非嵌套列表以简单的方式实现,如下图:如果节点的下标为p,那么其左子节点下标为2p,右子节点为2p+1,其父节点下标为p//2。
2. 堆次序Heap Order
任何一个节点x,其父节点p中的key均小于x中的key。这样,符合“堆”性质的二叉树,其中任何一条路径,均是一个已排序数列,根节点的key最小。
3. 二叉堆操作的实现
-
二叉堆初始化,采用一个列表来保存堆数据,其中表首下标为0的项无用,但为了后面代码可以用到简单的整数乘除法,仍保留它。
-
insert(key)方法:首先,为了保持完全二叉树的性质,新key应该添加到列表末尾。新key加在列表末尾,显然无法保持堆次序,虽然对其它路径的次序没有影响,但对于其到根的路径可能破坏次序。需要将新key沿着路径来“上浮”到其正确位置。注意:新key的上浮不会影响其他路径节点的堆次序。
-
delMin()方法:移走整个堆中最小的key,根节点heapList[1],为了保持完全二叉树的性质,只用最后一个节点来代替根节点。同样,这操作还是破坏了堆次序。解决方法:将新的根节点沿着一条路径下沉,直到比两个子节点都小。下沉的路径选择:如果比子节点大,那么选择较小的子节点交换下沉。
-
buildHeap(lst)方法:从无序表生成堆。用下沉法,能将总代价控制在O(n)。
代码实现:
# 二叉堆操作的实现
class BinHeap:
def __init__(self):
self.heapList = [0]
self.currentSize = 0
def percUp(self,i):
while i//2 > 0:
if self.heapList[i] < self.heapList[i//2]:
temp = self.heapList[i//2]
self.heapList[i//2] = self.heapList[i] # 与父节点交换
self.heapList[i] = temp
i = i//2 # 沿路径向上
def insert(self,k):
self.heapList.append(k) # 添加到末尾
self.currentSize = self.currentSize + 1
self.percUp(self.currentSize) # 新key上浮
def percDown(self,i):
while (i * 2) <= self.currentSize:
mc = self.minChild(i)
if self.heapList[i] > self.heapList[mc]:
tmp = self.heapList[i]
self.heapList[i] = self.heapList[mc] # 交换下沉
self.heapList[mc] = tmp
i = mc # 沿路径向下
def minChild(self,i):
if i*2 + 1 > self.currentSize:
return i*2 # 唯一子节点
else:
if self.heapList[i*2] < self.heapList[i*2+1]:
return i*2
else: # 返回较小的
return i*2+1
def delMin(self):
retval = self.heapList[1] # 移走堆顶
self.heapList[1] = self.heapList[self.currentSize]
self.currentSize = self.currentSize - 1
self.heapList.pop()
self.percDown(1) # 新顶下沉
return retval
def buildHeap(self,alist):
i = len(alist) // 2 # 从最后节点的父节点开始,因叶节点无需下沉
self.currentSize = len(alist)
self.heapList = [0] + alist[:]
print(len(self.heapList),i)
while (i > 0):
print(self.heapList,i)
self.percDown(i)
i = i-1
print(self.heapList,i)
六、二叉查找树Binary Search Tree
1. 二叉查找树BST的性质
- 比父节点小的key都出现在左子树,比父节点大的key都出现在右子树。
- 按照70,31,93,94,14,23,73的顺序插入。注意:插入顺序不同,生成的BST也不同。
2. 二叉搜索树的实现
-
put(key,val)方法:插入key构造BST。首先看BST是否为空,如果一个节点都没有,那么key成为根节点root,否则,就调用一个递归函数_put(key, val, root)来放置key。
-
_put(key,val,self.root)的流程:如果key比currentNode小,那么_put到左子树,但如果没有左子树,那么key就成为左子节点;如果key比currentNode大,那么_put到右子树,但如果没有右子树,那么key就成为右子节点。
-
BST.get方法:在树中找到key所在的节点取到payload。
-
TreeNode类中的__iter__迭代器,迭代器函数中用了for迭代,实际上是递归函数,yield是对每次迭代的返回值。
-
BST.delete方法:用_get找到要删除的节点,然后调用remove来删除,找不到则提示错误。
-
从BST中remove一个节点,还要求仍然保持BST的性质,分以下三种情况:这个节点没有子节点;这个节点有1个子节点;这个节点有2个子节点。
-
没有子节点的情况,直接删除。
-
被删节点有1个子节点,解决方法:将这个唯一的子节点上移,替换掉被删节点的位置。
- 被删节点有2个子节点。这时无法简单地将某个子节点上移替换被删节点。但可以找到另一个合适地节点来替换被删节点,这个合适节点就是被删节点的下一个key值节点,即被删节点右子树中最小的那个,称为后继。
代码实现:
class BinarySearchTree:
def __init__(self):
self.root = None
self.size = 0
def length(self):
return self.size
def __len__(self):
return self.size
def __iter__(self):
return self.root.__iter__()
def put(self,key,val):
if self.root:
self._put(key,val,self.root)
else:
self.root = TreeNode(key,val)
self.size = self.size + 1
def _put(self,key,val,currentNode):
if key < currentNode.key:
if currentNode.hasLeftChild():
self._put(key,val,currentNode.leftChild) # 递归左子树
else:
currentNode.leftChild = TreeNode(key,val,parent=currentNode)
else:
if currentNode.hasRightChild():
self._put(key,val,currentNode.rightChild) # 递归右子树
else:
currentNode.rightChild = TreeNode(key,val,parent=currentNode)
def __setitem__(self, k, v):
self.put(k,v)
def get(self,key):
if self.root:
res = self._get(key,self.root) # 递归函数
if res:
return res.payload # 找到节点
else:
return None
else:
return None
def _get(self,key,currentNode):
if not currentNode:
return None
elif currentNode.key == key:
return currentNode
elif key < currentNode.key:
return self._get(key,currentNode.leftChild)
else:
return self._get(key,currentNode.rightChild)
def __getitem__(self, key):
return self.get(key)
def __contains__(self, key):
if self._get(key,self.root):
return True
else:
return False
def delete(self, key):
if self.size > 1:
nodeToRemove = self._get(key, self.root)
if nodeToRemove:
self.remove(nodeToRemove)
self.size = self.size - 1
else:
raise KeyError('Error, key not in tree')
elif self.size == 1 and self.root.key == key:
self.root = None
self.size = self.size - 1
else:
raise KeyError('Error, key not in tree')
def __delitem__(self,key):
self.delete(key)
def remove(self,currentNode):
if currentNode.isLeaf(): #leaf
if currentNode == currentNode.parent.leftChild:
currentNode.parent.leftChild = None
else:
currentNode.parent.rightChild = None
elif currentNode.hasBothChildren(): #interior
succ = currentNode.findSuccessor()
succ.spliceOut()
currentNode.key = succ.key
currentNode.payload = succ.payload
else: # this node has one child
if currentNode.hasLeftChild():
if currentNode.isLeftChild(): # 左子节点删除
currentNode.leftChild.parent = currentNode.parent
currentNode.parent.leftChild = currentNode.leftChild
elif currentNode.isRightChild(): # 右子节点删除
currentNode.leftChild.parent = currentNode.parent
currentNode.parent.rightChild = currentNode.leftChild
else: # 根节点删除
currentNode.replaceNodeData(currentNode.leftChild.key,
currentNode.leftChild.payload,
currentNode.leftChild.leftChild,
currentNode.leftChild.rightChild)
else:
if currentNode.isLeftChild(): # 左子节点删除
currentNode.rightChild.parent = currentNode.parent
currentNode.parent.leftChild = currentNode.rightChild
elif currentNode.isRightChild(): # 右子节点删除
currentNode.rightChild.parent = currentNode.parent
currentNode.parent.rightChild = currentNode.rightChild
else: # 根节点删除
currentNode.replaceNodeData(currentNode.rightChild.key,
currentNode.rightChild.payload,
currentNode.rightChild.leftChild,
currentNode.rightChild.rightChild)
class TreeNode:
def __init__(self,key,val,left=None,right=None,parent=None):
self.key = key # 键值
self.payload = val # 数据项
self.leftChild = left # 左子节点
self.rightChild = right # 右子节点
self.parent = parent # 父节点
def hasLeftChild(self):
return self.leftChild
def hasRightChild(self):
return self.rightChild
def isLeftChild(self):
return self.parent and self.parent.leftChild == self
def isRightChild(self):
return self.parent and self.parent.rightChild == self
def isRoot(self):
return not self.parent
def isLeaf(self):
return not (self.rightChild or self.leftChild)
def hasAnyChildren(self):
return self.rightChild or self.leftChild
def hasBothChildren(self):
return self.rightChild and self.leftChild
def replaceNodeData(self,key,value,lc,rc):
self.key = key
self.payload = value
self.leftChild = lc
self.rightChild = rc
if self.hasLeftChild():
self.leftChild.parent = self
if self.hasRightChild():
self.rightChild.parent = self
def findSuccessor(self):
succ = None
if self.hasRightChild():
succ = self.rightChild.findMin()
else:
if self.parent:
if self.isLeftChild():
succ = self.parent
else:
self.parent.rightChild = None
succ = self.parent.findSuccessor()
self.parent.rightChild = self
return succ
def findMin(self):
current = self
while current.hasLeftChild(): # 到左下角
current = current.leftChild
return current
def spliceOut(self):
if self.isLeaf():
if self.isLeftChild(): # 摘出叶节点
self.parent.leftChild = None
else:
self.parent.rightChild = None
elif self.hasAnyChildren():
if self.hasLeftChild():
if self.isLeftChild():
self.parent.leftChild = self.leftChild
else:
self.parent.rightChild = self.leftChild
self.leftChild.parent = self.parent
else:
if self.isLeftChild():
self.parent.leftChild = self.rightChild # 摘出带右子节点的节点
else:
self.parent.rightChild = self.rightChild
self.rightChild.parent = self.parent
# 中序遍历的迭代:
def __iter__(self):
if self:
if self.hasLeftChild():
for elem in self.leftChild:
yield elem
yield self.key
if self.hasRightChild():
for elem in self.rightChild:
yield elem
3. 平衡二叉查找树:AVL树的定义
-
AVL树能在key插入时一直保持平衡。AVL是发明者名字的缩写。
-
AVL树的实现中,需要对每个节点跟踪“平衡因子 balance factor”参数。
-
平衡因子是根据节点的左右子树的高度来定义的,确切地说,是左右子树的高度差:balanceFactor = height(leftSubTree) - height(rightSubTree)。如果平衡因子大于0,称为“左重left-heavy”,小于零称为“右重right-heavy”,平衡因子等于0,则称作平衡。
-
如果一个二叉查找树中每个节点的平衡因子都在-1, 0, 1之间,则把这个二叉搜索树称为平衡树。
-
在平衡树操作过程中,有节点的平衡因子超出此范围,则需要一个重新平衡的过程。
分析AVL树最差情况下的性能:
-
即平衡因子为1或者-1。下图为平衡因子为1的左重AVL树,树的高度从1开始,来看看问题规模(总节点数N)和比对次数(树的高度h)之间的关系如何?
-
观察上图h = 1~4时,总节点数N的变化:
h = 1, N = 1
h = 2, N = 2 = 1+ 1
h = 3, N = 4 = 1 + 1 + 2
h = 4, N = 7 = 1 + 2 + 4
可得通式:Nh = 1 + Nh-1 + Nh-2 ,观察这个通式,很接近斐波那契。
对上图打红色问号的式子存在疑问,两边同时取对数,等号左边应该是log(Nh + 1)才对啊,希望有大神看到能为我解答困惑!
4. 保持AVL树的平衡性质
-
首先,作为BST,新key必定以叶节点形式插入到AVL树中。
-
叶节点的平衡因子是0,其本身无需重新平衡,但会影响其父节点的平衡因子:作为左子节点插入,则父节点平衡因子会增加1;作为右子节点插入,则父节点平衡因子会减少1.
-
这种影响可能随着其父节点到根节点的路径一直传递上去,直到:传递到根节点为止;或者某个父节点的平衡因子被调整到0,不再影响上层节点的平衡因子为止。
rebalance重新平衡:
- 主要手段:将不平衡的子树进行旋转rotation。视左重或者右重进行不同方向的旋转,同时更新相关父节点引用,更新旋转后被影响节点的平衡因子。
-
如上图,是一个右重子树A的左旋转(并保持BST性质)。将右子节点B提升为子树的根,将旧根节点A作为新根节点B的左子节点;如果新根节点B原来有左子节点,则将此节点设置为A的右子节点(A的右子节点一定有空)。
-
更复杂的情况:如下图左重的子树右旋转。旋转后,新根节点将旧根节点作为右子节点,但是新根节点原来已有右子节点,需要将原有的右子节点重新定位;原有的右子节点D改到旧根节点E的左子节点,同样,E的左子节点在旋转后一定有空。
- 左旋转对平衡因子的影响:
- 下图右重子树,单纯的左旋转无法实现平衡,左旋转后变成左重了,左重再右旋转,还回到右重。
- 所以,在左旋转之前检查右子节点的因子,如果右子节点左重的话,先对它进行右旋转,再实施原来的左旋转;同样,在右旋转之前检查左子节点的因子,如果左子节点右重的话,先对它进行左旋转,再实施原来的右旋转。
AVL树算法代价:
- 经过复杂的put方法,AVL树始终维持平衡,get方法也始终保持O(logn)高性能。
- 将AVL树的put方法分为两个部分:需要插入的新节点是叶节点,更新其所有父节点和祖先节点的代价最多为O(logn),如果插入的新节点引发了不平衡,重新平衡最多需要两次旋转,但旋转的代价与问题规模无关,旋转代价是常数O(1)。所以整个put方法的时间复杂度还是O(logn)。
七、ADT Map实现方法小结
推荐使用散列表和AVL树。
==================================================================
以上均为个人学习笔记总结,学习代码见week18
课程名称:数据结构与算法Python版_北京大学_中国大学MOOC(慕课)
课程主页: http://gis4g.pku.edu.cn/course/pythonds/