python 算法 day9 二叉堆
为了使堆操作高效运行,我们将利用二叉树的操作复杂度为对数级这一性质来实现堆操作。同时使堆操作的复杂度始终保持在对数水平上，就必须保持二叉树的平衡，平衡二叉树树根左右子树有着相同的数量节点。完全二叉树，指每个内部节点都有两个子节点，最多可有一个节点列外。
完全树的另一个特性，我们可以用单个列表来实现完全树而不需要使用节点，如果节点在列表中的位置为p，那么其左子节点的位置为2p 右子节点位置为2p+1
堆次序：
指堆中任意一个节点x，其父节点p中的key均小于或等于x中的key 兄弟节点没有要求
实现一个二叉堆：可以采用一个列表来保存堆数据，构造函数初始化仅仅需要初始化一个列表和一个currentSize来跟踪记录当前堆的大小
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]: tmp = self.heapList[i//2] self.heapList[i//2] = self.heapList[i] self.heapList[i] = tmp i = i//2 def insert(self, k): self.heapList.append(k) self.currentSize = self.currentSize + 1 self.percUp(self.currentSize) def percDowm(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.heapList.pop()
self.currentSize = self.currentSize -1
self.percDowm(1)
return retval
def buildHeap(self,alist):
i = len(alist)//2
self.currentSize =len(alist)
self.heapList = [0] +alist[:]
while(i>0):
self.percDowm(i)
i = i -1
.如何恢复堆结构和堆次序：首先用最后一个节点来代替根节点，移走最后一个节点维持了堆结构的性质，简单替换 但很可能破坏堆次序
第二步 用新替换的节点来下沉恢复堆次序二叉堆的最后一个方法buildHeap是从无序表中生成一个堆，如果采用insert方法，复杂度是onlogn，多次调用insert是把数据一个个放进来，而buildheap是把整个列表中的所有元素全部放进来，再挑几个下沉在on复杂度下生成二叉堆，因为二叉堆只保证父子间的顺序，并不保证兄弟间的大小。
二叉搜索树
一个二叉搜索树，如果左子树的键值Key都小于父节点，而右子树中键值Key都大于父节点，我们将这种树称为BST搜索树
所有左子树的键值都小于右子树的键值
实现二叉搜索树，使用节点和引用方法
用put方法创建二叉搜索树BST，先检查树是否已经有根节点，如果没有，put将根据传入的参数创建一个新的TreeNode并把它作为树的根节点，作为子树的根，如果一个根节点已经到位，我们就调用它自己进行递归 用_put方法来搜索树：
首先，从树的根开始搜索，比较新的键值，如果新的键值小于当前根的值，搜索左子树，如果大于，就搜索右子树
当无左子树或右子树时，我们发现的位置就是安装新节点的位置
向树添加一个新的节点，在上一步发现插入对象的位置创建一个新的TreeNode。
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)
树被构建后，接下来就是给定键实现对值的检索，get采用递归的搜索子树，直到发现匹配的值就返回
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)
一些小TIPs
__contains__()方法 从而能够实用操作符 in
__setitem__()方法 重载[]为操作符
__getitem__()方法 可以使我们像访问字典一样调用
def __getitem__(self, item): return self.get(item) def __contains__(self, key): if self._get(key,self.root): return True else: return False def __setitem__(self, key, value): self.put(key,value)
删除方法：我们可以使用get方法去找到需要删除的树节点，一旦找到我们需要删除的键的节点，有三种情况：
1、要删除的节点没有子树 只需要父节点对此节点的引用指向None
2、要删除的节点只有一个子节点
如果当前节点有左子节点，我们只需要更新当前节点的左子节点指向当前节点的父节点引用，然后将父节点对当前节点的引用更新到当前节点的左子节点
如果当前节点有右子节点，我们只需要更新当前节点的右子节点指向当前节点的父节点引用，然后将父节点对当前节点的引用更新到当前节点的右子节点
如果当前节点为根节点（没有父节点）则只需更换键
3、要删除的节点有两个子节点
如果有两个子节点，我们不能简单的选其中一个提升至父节点的位置，这就需要寻找一个节点，用来替代一个计划删除的节点，还需要保持现有的 左右子树以及二叉搜索树的关系
符合该要求的是比要删节点大的第一个值 即在右子树上寻找最左子树 比如上图比5大的第一个值是7，我们通过寻找该节点，保证其没有一个以上的子节点，然后将其移动到删除节点处 并保证保证原有子树的位置
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: 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 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
找到继任者的函数findSuccessor() 需要考虑三种情况：
1、如果节点有右子节点，那么继任者是右子树中最小的键
2、如果节点没有右子节点，是其父节点的左子节点 ，则父节点是继任者
3、如果节点是其父节点的右子节点，而本身无右子节点，那么该节点的继任者是其父结点的继任者 不包括这个节点（因为父节点还有左子节点）
另外第三种情况移动继任者时 我们还需要再分割的节点处保持正确的顺序
findmin函数就不断对左子树进行循环取最小值
使用迭代器 重写__iter__()方法 采用yield记录函数目前运行的状态
完整代码
class BinarySearchTree: def __init__(self): self.root = None self.size = 0 def length(self): return self.size def __len__(self): return self.size 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, key, value): self.put(key,value) 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, item): return self.get(item) 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("key not in tree") elif self.size==1 and self.root.key ==key: self.root = None self.size = self.size -1 else: raise KeyError("key not in tree") def __delitem__(self, key): self.delete(key) 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: 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 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 remove(self,currentNode): if currentNode.isLeaf(): if currentNode ==currentNode.parent.leftChild: currentNode.parent.leftChild =None else: currentNode.parent.rightChild =None elif currentNode.hasBothChildren(): succ = currentNode.findSuccessor() succ.spliceOut() currentNode.key = succ.payload else: 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 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 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 mytree = BinarySearchTree() mytree[3]="red" mytree[4]="blue" mytree[6]="yellow" mytree[2]="at" print(mytree.root.key) print(mytree.root.hasleftChild().key) print(mytree[2])
搜索树分析
如果键是以随机顺序加到树中的，那么当节点的数目为n时，树的高度大概会在log2n
