樹及其衍生演算法（Trees and tree algorithms）

阿新 • • 發佈：2018-12-08

1，二叉樹（Binary tree）

　　　　二叉樹：每一個節點最多兩個子節點，如下圖所示：

　　　　相關概念：節點Node，路徑path，根節點root，邊edge，子節點 children，父節點parent，兄弟節點sibling, 子樹subtree，葉子節點leaf node, 度level,樹高hight

節點Node：
路徑path：從一個節點到擰一個節點間的邊
根節點root，
邊edge：節點間的連線
子節點 children，
父節點parent，
兄弟節點sibling, 
子樹subtree，
葉子節點leaf node, 
度level：從當前節點到根節點的路徑中邊的數量
高度 hight：樹中所有節點的最大level

View Code

　　　　二叉樹可以通過多級列表的形式實現,多級列表形式如下，根節點r，有兩個子節點a , b，且a, b節點沒有子節點。

　　　　　　　　　　　mytree =[ r,

　　　　　　　　　　　　　　　　[ a, [ ], [ ] ], [ b, [ ], [ ] ]

　　　　　　　　　　　　　　　 ]

　　　　python實現程式碼如下：

#coding:utf-8


#多級列表實現
def binaryTree(r):
    return [r,[],[]]  #root[]為根節點,root[1]左子樹,root[2]右子樹 


def insertLeftTree(root,newbranch):
    t = root.pop(1)
    if len(t)>1:
        root.insert(1, [newbranch, t, []])
    else:
        root.insert(1,[newbranch, [], []])
    return root

def insertRightTree(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,val):
    root[0]= val

def getLeftChildren(root):
    return root[1]

def getRightChildren(root):
    return root[2]

r = binaryTree(3)
insertLeftTree(r,4)
insertLeftTree(r,5)
insertRightTree(r,6)
insertRightTree(r,7)
l = getLeftChildren(r)
print(l)

setRootVal(l,9)
print(r)
insertLeftTree(l,11)
print(r)
print(getRightChildren(getRightChildren(r)))

多級列表形式

　　　　二叉樹可以通過節點的形式實現，如下所示：

　　　　python實現程式碼如下：

class BinaryTree(object):
    def __init__(self,value):
        self.key = value
        self.leftChild = None
        self.rightChild = None

    def insertLeft(self,newNode):
        if self.leftChild != None:
            temp = BinaryTree(newNode)
            temp.leftChild = self.leftChild
            self.leftChild = temp
        else:
            self.leftChild = BinaryTree(newNode)

    def insertRight(self,newNode):
        if self.rightChild != None:
            temp = BinaryTree(newNode)
            temp.rightChild= self.rightChild
            self.rightChild = temp
        else:
            self.rightChild = BinaryTree(newNode)

    def getRootVal(self):
        return self.key

    def setRootVal(self,value):
        self.key = value

    def getLeftChild(self):
        return self.leftChild
    
    def getRightChild(self):
        return self.rightChild

節點形式

2，二叉樹的應用

　　2.1 解析樹（parse tree）

　　　　解析樹常用於表示真實世界的結構表示，如句子和數學表示式。如下圖是（（7+3）*（5-2））的解析樹表示，根據解析樹的層級結構，從下往上計算，能很好的代替括號的表示式中括號的作用

　　　　將一個全括號數學表示式轉化為解析樹的過程如下：

　　　　　　遍歷表示式：

　　　　　　　　　　1，若碰到“（”，為當前節點插入左節點，並移動到左節點

　　　　　　　　　　2，若碰到 + ,- ,* , /，設定當前節點的值為該符號，併為當前節點插入右節點，並移動到右節點

　　　　　　　　　　3，若碰到數字，設定當前節點的值為該數字，並移動到其父節點

　　　　　　　　　　4，若碰到“）”，移動到當前節點的父節點

　　　　　　python實現程式碼如下：（Stack 參見資料結構之棧）

from stackDemo import Stack  #參見資料結構之棧

def buildParseTree(expstr):
    explist = expstr.split()
    s = Stack()
    t = BinaryTree('')
    s.push(t)
    current = t
    for token in explist:
        #token = token.strip()
        if token =='(':
            current.insertLeft('')
            s.push(current)
            current = current.getLeftChild()
        elif token in ['*','/','+','-']:
            current.setRootVal(token)
            current.insertRight('')
            s.push(current)
            current = current.getRightChild()
        elif token not in ['(','*','/','+','-',')']:
            current.setRootVal(token)
            current = s.pop()
        elif token==')':
            current = s.pop()
        else:
            raise ValueError
    return t

t = buildParseTree("( ( 10 + 5 ) * 3 )")

構造解析樹

　　　　計算解析樹：數學表示式轉化為解析樹後，可以對其進行計算，python程式碼如下：　

import operator
def evaluate(parseTree):
    operators={'+':operator.add,'-':operator.sub,'*':operator.mul,'/':operator.div }
    rootval = parseTree.getRootVal()
    left = parseTree.getLeftChild()
    right = parseTree.getRightChild()

    if left and right:
        fn = operators[rootval]
        return fn(evaluate(left),evaluate(right))
    else:
        return parseTree.getRootVal()

計算解析樹

　　　　中序遍歷解析樹，可以將其還原為全括號數學表示式，python程式碼如下：

#解析樹轉換為全括號數學表示式
def printexp(tree):
    val = ''
    if tree:
        val = '('+printexp(tree.getLeftChild())
        val = val +str(tree.getRootVal())
        val = val +printexp(tree.getRightChild())+')'
        if tree.getLeftChild()==None and tree.getRightChild()==None:
            val = val.strip('()')
    return val

t = buildParseTree("( ( 10 + 5 ) * 3 )")
exp = printexp(t)
print exp

View Code

3，樹的遍歷

　　　　樹的遍歷包括前序遍歷(preorder)，中序遍歷(inorder)和後序遍歷(postorder).

　　　　前序遍歷：先訪問根節點，再訪問左子樹，最後訪問右子樹（遞迴），python程式碼實現如下：

def preorder(tree):
    if tree:
        print tree.getRootVal()
        preorder(tree.getLeftChild())
        preorder(tree.getRightChild())

#定義在類中的前序遍歷
# def preorder(self):
#     print self.key
#     if self.leftChild:
#         self.leftChild.preorder()
#     if self.rightChild:
#         self.rightChild.preorder()

preorder

　　　　中序遍歷：先訪問左子樹，再訪問根節點，最後訪問右子樹（遞迴），python程式碼實現如下：

#中序遍歷inorder
def inorder(tree):
    if tree:
        preorder(tree.getLeftChild())
        print tree.getRootVal()
        preorder(tree.getRightChild())

View Code

　　　　後續遍歷：先訪問左子樹，再訪問右子樹，最後訪問根節點，python程式碼實現如下：

def postorder(tree):
    if tree :
        postorder(tree.getLeftChild())
        postorder(tree.getRightChild())
        print(tree.getRootVal())

View Code

4，優先佇列和二叉樹（priority queue and binary heap）

　　　　優先佇列：優先佇列和佇列類似，enqueue操作能加入元素到佇列末尾，dequeue操作能移除佇列首位元素，不同的是優先佇列的元素具有優先順序，首位元素具有最高或最小優先順序，因此當進行enqueue操作時，還需要根據元素的優先順序將其移動到適合的位置。優先佇列一般利用二叉堆來實現，其enqueue和dequeue的複雜度都為O(logn)。（也可以用list來實現，但list的插入複雜度為O(n)，再進行排序的複雜度為O(n logn)）

　　　　二叉堆：二叉堆是一顆完全二叉樹，當父節點的鍵值總是大於或等於任何一個子節點的鍵值時為最大堆，當父節點的鍵值總是小於或等於任何一個子節點的鍵值時為最小堆。（完全二叉樹：除最後一層外，每一層上的節點數均達到最大值；在最後一層上只缺少右邊的若干結點；滿二叉樹：除葉子結點外的所有結點均有兩個子結點。節點數達到最大值。所有葉子結點必須在同一層上）

　　　　最小堆示例及操作如下：（父節點的值總是小於或等於子節點）

BinaryHeap() #建立空的二叉堆
insert(k)   #插入新元素
findMin()    #返回最小值，不刪除
delMin()     #返回最小值，並刪除
isEmpty()
size()
buildHeap(list)  #通過list建立二叉堆

View Code

　　　　對於完全二叉樹，若根節點的序號為p，則左右節點的序號應該為2p和2p+1，結合上圖可以發現，可以用一個佇列（首位元素為0）來表示二叉堆的結構。最小堆的python實現程式碼如下：（heaplist中第一個元素為0，不會用到，只是為了保證二叉堆的序列從1開始，方便進行除和乘2p，2p+1）

#coding:utf-8

class BinaryHeap(object):
    def __init__(self):
        self.heapList=[0]
        self.size = 0

    #將元素加到完全二叉樹末尾，然後再根據其大小調整其位置
    def insert(self,k):
        self.heapList.append(k)
        self.size = self.size+1
        self._percUp(self.size)

    # 如果當前節點比父節點小，和父節點交換位置，一直向上重複該過程
    def _percUp(self,size):
        i = size
        while i>0:
            if self.heapList[i]<self.heapList[i//2]:
                temp = self.heapList[i]
                self.heapList[i] = self.heapList[i//2]
                self.heapList[i//2] = temp
            i=i//2

    # 將根元素返回，並將最末尾元素移動到根元素保持完全二叉樹結構不變，再根據大小，將新的根元素向下移動到合適的位置
    def delMin(self):
        temp = self.heapList[1]
        self.heapList[1]=self.heapList[self.size]
        self.size = self.size-1
        self.heapList.pop()
        self._percDown(1)
        return temp

    # 如果當前節點比最小子節點大，和該子節點交換位置，一直向下重複該過程
    def _percDown(self,i):
        while (2*i)<=self.size:
            mc = self._minChild(i)
            if self.heapList[i]>self.heapList[mc]:
                temp = self.heapList[i]
                self.heapList[i]=self.heapList[mc]
                self.heapList[mc] =temp
            i = mc

    #返回左右子節點中較小子節點的位置
    def _minChild(self,i):
        if (2*i+1)>self.size:
            return 2*i
        else:
            if self.heapList[2*i] < self.heapList[2*i+1]:
                return 2*i
            else:
                return 2*i+1

    #通過一個list建立二叉堆
    def buildHeap(self,list):
        i = len(list)//2
        self.heapList = [0]+list[:]
        self.size = len(list)
        while i>0:
            self._percDown(i)
            i = i-1

View Code

　　　　 insert()插入過程示例圖如下：將元素加到完全二叉樹末尾，然後再根據其大小調整其位置

　　　　delMin()操作過程示例如下：將根元素返回，並將最末尾元素移動到根元素保持完全二叉樹結構不變，再根據大小，將新的根元素向下移動到合適的位置

　　　　insert和delMin的複雜度都為O(log n), buildHeap的複雜度為O(n)，利用二叉堆對list進行排序，複雜度為O(n log n)，程式碼如下：

#通過list構造二叉堆，然後不斷將堆頂元素返回，就得到排序好的list
alist = [54,26,93,17,98,77,31,44,55,20]
h = BinaryHeap()
h.buildHeap(alist)
s=[]
while h.size>0:
    s.append(h.delMin())
print s

View Code

5，二叉搜尋樹（Binary Search Tree, bst）

　　　　二叉搜尋樹：左節點的值，總是小於其父節點的值，右節點的值總是大於其父節點的值(bst property)。如下圖所示：

　　　　利用二叉搜尋樹實現map（字典），常用操作如下：

Map()   # 建立字典
put(key,val)    #  字典中插入資料
get(key)        #  取鍵值
del                 # 刪除
len()              # 求長度
in              #  是否存在

View Code

　　　　python實現map程式碼如下：

#coding:utf-8

class TreeNode(object):
    def __init__(self,key, value, leftChild=None,rightChild=None,parent=None):
        self.key = key
        self.value = value
        self.leftChild = leftChild
        self.rightChild = rightChild
        self.parent = parent
        self.balanceFactor =0

    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.leftChild or self.rightChild)

    def hasAnyChildren(self):
        return self.leftChild or self.rightChild

    def hasBothChildren(self):
        return self.leftChild and self.rightChild

    def replaceNodeData(self,key,value,lc=None,rc=None):
        self.key=key
        self.value = value
        self.leftChild = lc
        self.rightChild = rc
        if self.hasLeftChild():
            self.leftChild.parent = self
        if self.hasRightChild():
            self.rightChild = self

    def __iter__(self):
        if self:
            if self.hasLeftChild():
                for elem in self.leftChild:  #呼叫self.leftChiLd.__iter__()，所以此處是遞迴的
                    yield elem
            yield self.key, self.value, self.balanceFactor
            if self.hasRightChild():
                for elem in self.rightChild:  #呼叫self.rightChiLd.__iter__()
                    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 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


class BinarySearchTree(object):

    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,value):
        if self.root:
            self._put(key,value,self.root)
        else:
            self.root = TreeNode(key,value)
        self.size = self.size+1

    def _put(self,key,value,currentNode):
        if currentNode.key<key:
            if currentNode.hasRightChild():
                self._put(key,value,currentNode.rightChild)
            else:
                currentNode.rightChild=TreeNode(key,value,parent=currentNode)
        elif currentNode.key>key:
            if currentNode.hasLeftChild():
                self._put(key,value,currentNode.leftChild)
            else:
                currentNode.leftChild=TreeNode(key,value,parent=currentNode)
        else:
            currentNode.replaceNodeData(key,value)

    def __setitem__(self, key, value):
        self.put(key,value)

    #獲取元素值
    def get(self,key):
        if self.root:
            node = self._get(key,self.root)
            if node:
                return node.value
            else:
                return None
        else:
            return None

    def _get(self,key,currentNode):
        if not currentNode:
            return None
        if currentNode.key==key:
            return currentNode
        elif currentNode.key<key:
            return self._get(key,currentNode.rightChild)  #rightChild可能不存在
        else:
            return self._get(key,currentNode.leftChild)  #leftChild可能不存在

    # def _get(self,key,currentNode):
    #     if currentNode.key == key:
    #         return currentNode
    #     elif currentNode.key<key:
    #         if currentNode.hasRightChild():
    #             return self._get(key,currentNode.rightChild)
    #         else:
    #             return None
    #     else:
    #         if currentNode.hasLeftChild():
    #             return self._get(key,currentNode.leftChild)
    #         else:
    #             return None

    def __getitem__(self, key):
        return self.get(key)

    def __contains__(self, key): #實現 in 操作
        if self._get(key,self.root):
            return True
        else:
            return False

    def delete(self,key):
        if self.size>1:
            node = self._get(key,self.root)
            if node:
                self._del(node)
                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 _del(self,currentNode):
        if currentNode.isLeaf():
            if currentNode.isLeftChild():
                currentNode.parent.leftChild = None
            elif currentNode.isRightChild():
                currentNode.parent.rightChild = None
        elif currentNode.hasBothChildren():
            successor = currentNode.findSuccessor()  #此處successor為其右子樹的最小值，即最左邊的值
            successor.spliceOut()
            currentNode.key = successor.key
            currentNode.value = successor.value
        elif currentNode.hasAnyChildren():
            if currentNode.hasLeftChild():
                if currentNode.isLeftChild():
                    currentNode.parent.leftChild = currentNode.leftChild
                    currentNode.leftChild.parent = currentNode.parent
                elif currentNode.isRightChild():
                    currentNode.parent.rightChild = currentNode.leftChild
                    currentNode.leftChild.parent = currentNode.parent
                else:  # currentNode has no parent (is root)
                    currentNode.replaceNodeData(currentNode.leftChild.key,
                                        currentNode.leftChild.value,
                                        currentNode.leftChild.leftChild,
                                        currentNode.leftChild.rightChild)
            elif currentNode.hasRightChild():
                if currentNode.isLeftChild():
                    currentNode.parent.leftChild = currentNode.rightChild
                    currentNode.rightChild.parent = currentNode.parent
                elif currentNode.isRightChild():
                    currentNode.parent.rightChild = currentNode.rightChild
                    currentNode.rightChild.parent = currentNode.parent
                else:  # currentNode has no parent (is root)
                    currentNode.replaceNodeData(currentNode.rightChild.key,
                                        currentNode.rightChild.value,
                                        currentNode.rightChild.leftChild,
                                        currentNode.rightChild.rightChild)

    def __delitem__(self, key):
        self.delete(key)
if __name__ == '__main__':
    mytree = BinarySearchTree()
    mytree[8]="red"
    mytree[4]="blue"
    mytree[6]="yellow"
    mytree[5]="at"
    mytree[9]="cat"
    mytree[11]="mat"

    print(mytree[6])
    print(mytree[5])
    for x in mytree:
        print x

    del mytree[6]
    print '-'*12
    for x in mytree:
        print x

View Code

　　　　在上述程式碼中最複雜的為刪除操作，刪除節點時有三種情況：節點為葉子節點，節點有兩個子節點，節點有一個子節點。當節點有兩個子節點時，對其刪除時，應該用其右子樹的最小值來代替其位置（即右子樹中最左邊的值）。

　　　　對於map進行復雜度分析，可以發現put，get取決於tree的高度，當節點隨機分配時複雜度為O(log n)，但當節點分佈不平衡時，複雜度會變成O(n)，如下圖所示：

6, 平衡二叉搜尋樹（Balanced binary search tree, AVL tree）

　　　　平衡二叉搜尋樹：又稱為AVL Tree，取名於發明者G.M. Adelson-Velskii 和E.M. Landis，在二叉搜尋樹的基礎上引入平衡因子（balance factor），每次插入和刪除節點時都保持樹平衡，從而避免上面出現的搜尋二叉樹複雜度會變成O(n)。一個節點的balance factor的計算公式如下，即該節點的左子樹高度減去右子樹高度。

　　　　當樹所有節點的平衡因子為-1,0,1時，該樹為平衡樹，平衡因子大於1或小於-1時，樹不平衡需要調整，下圖為一顆樹的各個節點的平衡因子。（1時樹left-heavy，0時完全平衡，-1時right-heavy）

　　　　相比於二叉搜尋樹，AVL樹的put和delete操作後，需要對節點的平衡因子進行更新，如果某個節點不平衡時，需要進行平衡處理，主要分為左旋轉和右旋轉。

　　　　左旋轉：如圖，節點A的平衡因子為-2（right heavy），不平衡，對其進行左旋轉，即以A為旋轉點，AB邊逆時針旋轉。

　　　　　　　　詳細操作為：1，A的右節點B作為新的子樹根節點

　　　　　　　　　　　　　　2，A成為B的左節點，如果B有左節點時，將其左節點變為A的右節點（A的右節點原來為B，所以A的右節點現在為空）

　　　　右旋轉：如圖，節點E的平衡因子為2（left heavy），不平衡，對其進行右旋轉，即以E為旋轉點，EC邊順時針旋轉。

　　　　　　　　詳細操作為：1，E的左節點C作為新的子樹根節點

　　　　　　　　　　　　　　2，E成為C的右節點，如果C有右節點時，將其右節點變為E的左節點（E的左節點原來為C，所以E的左節點現在為空）

　　　　特殊情況：當出現下面的情況時，如圖所示，A依舊為right heavy，但若進行左旋轉，又會出現left heavy，無法完成平衡操作。所以在進行左旋轉和右旋轉前需要進行一步判斷，具體操作如下：

　　　　　　1，如果某節點需要進行左旋轉平衡時（right heavy），檢查其右子節點的平衡因子，若右子節點為left heavy，先對右子節點右旋轉，然後對該節點左旋轉

　　　　　　2，如果某節點需要進行右旋轉平衡時（left heavy），檢查其左子節點的平衡因子，若左子節點為right heavy，先對左子節點左旋轉，然後對該節點右旋轉

　　　　AVL tree用python實現的程式碼如下：

#coding:utf-8

from binarySearchTree import TreeNode, BinarySearchTree

# class AVLTreeNode(TreeNode):
#
#     def __init__(self,*args,**kwargs):
#         self.balanceFactor = 0
#         super(AVLTreeNode,self).__init__(*args,**kwargs)

class AVLTree(BinarySearchTree):

    def _put(self,key,value,currentNode):
        if currentNode.key<key:
            if currentNode.hasRightChild():
                self._put(key,value,currentNode.rightChild)
            else:
                currentNode.rightChild=TreeNode(key,value,parent=currentNode)
                self.updateBalance(currentNode.rightChild)
        elif currentNode.key>key:
            if currentNode.hasLeftChild():
                self._put(key,value,currentNode.leftChild)
            else:
                currentNode.leftChild=TreeNode(key,value,parent=currentNode)
                self.updateBalance(currentNode.leftChild)
        else:
            currentNode.replaceNodeData(key,value)

    def _del(self,currentNode):
        if currentNode.isLeaf():
            if currentNode.isLeftChild():
                currentNode.parent.leftChild = None
                currentNode.parent.balanceFactor -=1
            elif currentNode.isRightChild():
                currentNode.parent.rightChild = None
                currentNode.parent.balanceFactor += 1
            if currentNode.parent.balanceFactor>1 or currentNode.parent.balanceFactor<-1:
                self.reblance(currentNode.parent)
        elif currentNode.hasBothChildren():
            successor = currentNode.findSuccessor()  #此處successor為其右子樹的最小值，即最左邊的值
            # 先更新parent的balanceFactor
            if successor.isLeftChild():
                successor.parent.balanceFactor -= 1
            elif successor.isRightChild():
                successor.parent.balanceFactor += 1
            successor.spliceOut()
            currentNode.key = successor.key
            currentNode.value = successor.value

            # 刪除後，再判斷是否需要再平衡，然後進行再平衡操作
            if successor.parent.balanceFactor>1 or successor.parent.balanceFactor<-1:
                self.reblance(successor.parent)
        elif currentNode.hasAnyChildren():

            #先更新parent的balanceFactor
            if currentNode.isLeftChild():
                currentNode.parent.balanceFactor -= 1
            elif currentNode.isRightChild():
                currentNode.parent.balanceFactor += 1

            if currentNode.hasLeftChild():
                if currentNode.isLeftChild():
                    currentNode.parent.leftChild = currentNode.leftChild
                    currentNode.leftChild.parent = currentNode.parent
                elif currentNode.isRightChild():
                    currentNode.parent.rightChild = currentNode.leftChild
                    currentNode.leftChild.parent = currentNode.parent
                else:  # currentNode has no parent (is root)
                    currentNode.replaceNodeData(currentNode.leftChild.key,
                                        currentNode.leftChild.value,
                                        currentNode.leftChild.leftChild,
                                        currentNode.leftChild.rightChild)
            elif currentNode.hasRightChild():
                if currentNode.isLeftChild():
                    currentNode.parent.leftChild = currentNode.rightChild
                    currentNode.rightChild.parent = currentNode.parent
                elif currentNode.isRightChild():
                    currentNode.parent.rightChild = currentNode.rightChild
                    currentNode.rightChild.parent = currentNode.parent
                else:  # currentNode has no parent (is root)
                    currentNode.replaceNodeData(currentNode.rightChild.key,
                                        currentNode.rightChild.value,
                                        currentNode.rightChild.leftChild,
                                        currentNode.rightChild.rightChild)
             #刪除後，再判斷是否需要再平衡，然後進行再平衡操作
            if currentNode.parent!=None: #不是根節點
                if currentNode.parent.balanceFactor>1 or currentNode.parent.balanceFactor<-1:
                    self.reblance(currentNode.parent)

    def updateBalance(self,node):
        if node.balanceFactor>1 or node.balanceFactor<-1:
            self.reblance(node)
            return
        if node.parent!=None:
            if node.isLeftChild():
                node.parent.balanceFactor +=1
            elif node.isRightChild():
                node.parent.balanceFactor -=1
            if node.parent.balanceFactor!=0:
                self.updateBalance(node.parent)

    def reblance(self,node):
        if node.balanceFactor>1:
            if node.leftChild.balanceFactor<0:
                self.rotateLeft(node.leftChild)
            self.rotateRight(node)
        elif node.balanceFactor<-1:
            if node.rightChild.balanceFactor>0:
                self.rotateRight(node.rightChild)
            self.rotateLeft(node)

    def rotateLeft(self,node):
        newroot = node.rightChild
        node.rightChild = newroot.leftChild
        if newroot.hasLeftChild():
            newroot.leftChild.parent = node
        newroot.parent = node.parent
        if node.parent!=None:
            if node.isLeftChild():
                node.parent.leftChild = newroot
            elif node.isRightChild():
                node.parent.rightChild = newroot
        else:
            self.root = newroot
        newroot.leftChild = node
        node.parent = newroot
        node.balanceFactor = node.balanceFactor+1-min(newroot.balanceFactor,0)
        newroot.balanceFactor = newroot.balanceFactor+1+max(node.balanceFactor,0)

    def rotateRight(self,node):
        newroot = node.leftChild
        node.leftChild = newroot.rightChild
        if newroot.rightChild!=None:
            newroot.rightChild.parent = node
        newroot.parent = node.parent
        if node.parent!=None:
            if node.isLeftChild():
                node.parent.leftChild = newroot
            elif node.isRightChild():
                node.parent.rightChild = newroot
        else:
            self.root = newroot
        newroot.rightChild = node
        node.parent = newroot
        node.balanceFactor = node.balanceFactor-1-max(newroot.balanceFactor,0)
        newroot.balanceFactor = newroot.balanceFactor-1+min(node.balanceFactor,0)

if __name__ == '__main__':
    
    mytree = AVLTree()
    mytree[8]="red"
    mytree[4]="blue"
    
    mytree[6]="yellow"
    
    mytree[5]="at"
    
    mytree[9]="cat"
    
    mytree[11]="mat"
    
    print(mytree[6])
    print(mytree[5])
    
    print '-'*12
    print ('key','value','balanceFactor')
    for x in mytree:
        print x
    print 'root:',mytree.root.key


    del mytree[6]
    print '-'*12
    print ('key','value','balanceFactor')
    for x in mytree:
        print x
    print 'root:',mytree.root.key

View Code

　　　　AVL Tree繼承了二叉搜尋樹，對其插入和刪除方法進行了重寫，另外對TreeNode增加了balanceFactor屬性。再進行左旋轉和右旋轉時，對於balanceFactor的需要計算一下，如圖的左旋轉過程中，D成為了新的根節點，只有B和D的平衡因子發生了變化，需要對其進行更新。（右旋轉和左旋轉類似）

　　　　　　B的平衡因子計算過程如下：（newBal(B)為左旋轉後B的平衡因子，oldBal(B)為原來的節點B的平衡因子，h為節點的高度）

　　　　　　D的平衡因子計算過程如下：

　　　　由於AVL Tree總是保持平衡，其put和get操作的複雜度能保持為O(log n)

7.總結

　　　　到目前為止，對於map（字典）資料結構，用二叉搜尋樹和AVL樹實現了，也用有序列表和雜湊表實現過，對應操作的複雜度如下：

參考：http://interactivepython.org/runestone/static/pythonds/Trees/toctree.html

樹及其衍生演算法（Trees and tree algorithms）

樹及其衍生演算法（Trees and tree algorithms）

圖及其衍生演算法（Graphs and graph algorithms）

樹狀數組（Binary Indexed Tree,BIT）

LeetCode 222. 完全二叉樹的節點個數（Count Complete Tree Nodes）

資料庫設計採用左右值編碼來儲存無限分級樹形結構_2 預排序遍歷樹演算法（modified preorder tree traversal algorithm ）

STL之劃分與排序演算法（Partions and Sorting）

演化演算法及其衍生演算法的主要思想

AVL平衡二叉樹的各種問題（Balanced Binary Tree）

#資料結構與演算法學習筆記#劍指Offer35：是否平衡二叉樹/AVL樹 + 測試用例（Java、C/C++）

二叉樹遍歷演算法（遞迴實現先序中序和後續遍歷）（非遞迴實現中序和先續）

【資料結構與演算法】利用哈夫曼樹進行檔案壓縮（部分借鑑網上內容）

R語言-決策樹演算法（C4.5和CART）的實現

分治演算法（divide and conquer）

“樹”據結構一：二叉搜尋樹（Binary Search Tree, BST）

機器學習 —— 決策樹及其整合演算法(Bagging、隨機森林、Boosting)

二叉樹的各種演算法（一)python

機器學習回顧篇（7）：決策樹演算法（ID3、C4.5）

Guice 學習（七）常量和屬性的註入（ Constant and Property Inject）

二叉樹刪除前面節點（C語言初始版）

BZOJ4837：[Lydsy1704月賽]LRU演算法（雙指標&模擬）

樹及其衍生演算法（Trees and tree algorithms）

相關推薦