『資料結構』樹(Tree)

weixin_33850890發表於2018-07-11

資料結構

1. 概念

雙親
左右孩子
左右子樹
森林
結點,葉子,邊,路徑
高度 h
遍歷(前中後層)
結點數 n
<a id="markdown-2-二叉查詢樹" name="2-二叉查詢樹"></a>

2. 二叉查詢樹

又名排序二叉樹,對於每個結點, 如果有,其左孩子不大於它,右孩子不小於它

通過前序遍歷或者後序遍歷就可以得到有序序列(升序,降序)

常用三種操作, 插入,刪除,查詢,時間複雜度是
h是樹高, 但是由於插入,刪除而導致樹不平衡, 即可能

2.1. 隨機構造的二叉查詢樹

下面可以證明,隨機構造,即輸入序列有中, 每種概率相同的情況下, 期望的樹高

(直接搬運演算法導論上面的啦>_<)

2.2. 平均結點深度

一個較上面定理弱的結論:

一棵隨機構造的二叉查詢樹,n 個結點的平均深度為

類似 RANDOMIZED-QUICKSORT 的證明過程, 因為快排遞迴的過程就是一個遞迴二叉樹.
隨機選擇樞紐元就相當於這裡的某個子樹的根結點在所有結點的大小隨機排名, 如 i. 然後根結點將剩下的結點劃分為左子樹(i-1)個結點, 右子樹(n-i)個結點.

2.3. 不同的二叉樹數目(Catalan num)

給定,組成二叉查詢樹的數目.
由上面的證明過程, 可以容易地分析得出, 任選第 i 個數作為根, 由於二叉查詢樹的性質, 其左子樹
應該有 i-1個結點, 右子樹有 n-i個結點.
如果記 n 個結點的二叉查詢樹的數目為
則有遞推公式

然後我們來看<<演算法導論>>(p162,思考題12-4)上怎麼求的吧( •̀ ω •́ )y
設生成函式

下面證明
易得
對比的 x 的各次係數,分別是
當 k=0,
當 k>0

所以
由此解得

在點 x=0 處,
用泰勒公式得

所以對應係數

這個數叫做 Catalan 數
<a id="markdown-24-好括號列" name="24-好括號列"></a>

2.4. 好括號列

王樹禾的<<圖論>>(p42)上用另外的方法給出Catalan數, 並求出n結點二叉查詢數的個數

首先定義好括號列,有:

空列,即沒有括號叫做好括號列
若A,B都是好括號列, 則串聯後 AB是好括號列
若A是好括號列, 則 (A)是好括號列

充要條件: 好括號列左右括號數相等, 且從左向右看, 看到的右括號數不超過左括號數

定理: 由 n個左括號,n個右括號組成的好括號列個數為

證明:
由 n左n右組成的括號列有個.
設括號列為壞括號列,
由充要條件, 存在最小的 j, 使得中右括號比左括號多一個,
由於是最小的 j, 所以為右括號, 為右括號
把中的左括號變為右括號, 右變左,記為

則括號列為好括號列
可好可壞,且有n-1個右,n+1個左, 共有個.

所以壞括號列與括號列 , 有個

那麼好括號列有

推論: n個字元,進棧出棧(出棧可以在棧不為空的時候隨時進行), 則出棧序列有 c(n)種

這種先入後出的情形都是這樣

3. 基數樹(radixTree)

4. 字典樹(trie)

又叫字首樹(preifx tree).適用於儲存有公共字首的字串集合. 如果直接儲存, 而很多字串有公共字首, 會浪費掉儲存空間.
字典樹可以看成是基數樹的變形, 每個結點可以有多個孩子, 每個結點儲存的是一個字元, 從根沿著結點走到一個結點,走過的路徑形成字元序列, 如果有合適的單詞就可以輸出.

當然,也可以同理得出字尾樹
<a id="markdown-41-ac-自動機" name="41-ac-自動機"></a>

4.1. AC 自動機

Aho-Corasick automation,是在字典樹上新增匹配失敗邊(失配指標), 實現字串搜尋匹配的演算法.

圖中藍色結點表示存在字串, 灰色表示不存在.
黑色邊是父親到子結點的邊, 藍色邊就是失配指標.

藍色邊(終點稱為起點的字尾結點): 連線字串終點到在圖中存在的, 最長嚴格字尾的結點. 如 caa 的嚴格字尾為 aa,a, 空. 而在圖中存在, 且最長的是字串 a, 則連線到這個字串的終點 a.

綠色邊(字典字尾結點): 終點是起點經過藍色有向邊到達的第一個藍色結點.

下面摘自 wiki

在每一步中，演算法先查詢當前節點的 “孩子節點”，如果沒有找到匹配，查詢它的字尾節點(suffix) 的孩子，如果仍然沒有，接著查詢字尾節點的字尾節點的孩子, 如此迴圈, 直到根結點，如果到達根節點仍沒有找到匹配則結束。

當演算法查詢到一個節點，則輸出所有結束在當前位置的字典項。輸出步驟為首先找到該節點的字典字尾，然後用遞迴的方式一直執行到節點沒有字典字首為止。同時，如果該節點為一個字典節點，則輸出該節點本身。

輸入 abccab 後演算法的執行步驟如下：

5. 平衡二叉樹

上面的二叉查詢樹不平衡,即經過多次插入,刪除後, 其高度變化大, 不能保持的效能
而平衡二叉樹就能.
平衡二叉樹都是經過一些旋轉操作, 使左右子樹的結點高度相差不大,達到平衡
有如下幾種
<a id="markdown-51-avl-tree" name="51-avl-tree"></a>

5.1. AVL Tree

平衡因子: 右子樹高度 - 左子樹高度
定義: 每個結點的平衡因子屬於{0,-1,1}

AVL_Tree_Example(from wiki).gif

from wiki

5.2. splayTree

伸展樹, 它的特點是每次將訪問的結點通過旋轉旋轉到根結點.
其實它並不平衡. 但是插入,查詢,刪除操作的平攤時間是
有三種旋轉,下面都是將訪問過的 x 旋轉到根部
<a id="markdown-521-zig-step" name="521-zig-step"></a>

5.2.1. Zig-step

zig

5.2.2. Zig-zig step

zig-zig

5.2.3. Zig-zag step

zig-zag

5.3. read-black Tree

同樣是平衡的二叉樹, 以後單獨寫一篇關於紅黑樹的.

5.4. treap

前面提到, 隨機構造的二叉查詢樹高度為 ,以及在演算法 general 中說明了怎樣隨機化(shuffle)一個給定的序列.

所以,為了得到一個平衡的二叉排序樹,我們可以將給定的序列隨機化, 然後再進行構造二叉排序樹.

但是如果不能一次得到全部的資料,也就是可能插入新的資料的時候,該怎麼辦呢? 可以證明,滿足下面的條件構造的結構相當於同時得到全部資料, 也就是隨機化的二叉查詢樹.

treap

這種結構叫 treap, 不僅有要排序的關鍵字 key, 還有隨機生成的,各不相等的關鍵字priority,代表插入的順序.

二叉查詢樹的排序性質: 雙親結點的 key 大於左孩子,小於右孩子
最小(大)堆的堆序性質: 雙親的 prority小於(大於) 孩子的 prority

插入的實現: 先進行二叉查詢樹的插入,成為葉子結點, 再通過旋轉實現 上浮(堆中術語).
將先排序 key, 再排序 prority(排序prority 時通過旋轉保持 key 的排序)

6. 總結

還有很多有趣的樹結構,
比如斜堆, 競賽樹(贏者樹,輸者樹,線段樹, 索引樹,B樹, fingerTree(不知道是不是譯為手指樹233)...
這裡就不詳細介紹了, 如果以後有時間,可能挑幾個單獨寫一篇文章

7. 附程式碼

github地址

7.1. 二叉樹(binaryTree)

from functools import total_ordering

@total_ordering
class node:
    def __init__(self,val,left=None,right=None,freq = 1):
        self.val=val
        self.left=left
        self.right=right
        self.freq = freq
    def __lt__(self,nd):
        return self.val<nd.val
    def __eq__(self,nd):
        return self.val==nd.val
    def __repr__(self):
        return 'node({})'.format(self.val)

class binaryTree:
    def __init__(self):
        self.root=None
    def add(self,val):
        def _add(nd,newNode):
            if nd<newNode:
                if nd.right is None:nd.right = newNode
                else:_add(nd.right,newNode)
            elif nd>newNode:
                if nd.left is None:nd.left = newNode
                else : _add(nd.left,newNode)
            else:nd.freq +=1
        _add(self.root,node(val))
    def find(self,val):
        prt= self._findPrt(self.root,node(val),None)
        if prt.left and prt.left.val==val:
            return prt.left
        elif  prt.right and prt.right.val==val:return prt.right
        else :return None
    def _findPrt(self,nd,tgt,prt):
        if nd==tgt or nd is None:return prt
        elif nd<tgt:return self._findPrt(nd.right,tgt,nd)
        else:return self._findPrt(nd.left,tgt,nd)
    def delete(self,val):
        prt= self._findPrt(self.root,node(val),None)
        if prt.left and prt.left.val==val:
            l=prt.left
            if l.left is None:prt.left = l.right
            elif l.right is None : prt.left = l.left
            else:
                nd = l.left
                while nd.right is not None:nd = nd.right
                nd.right = l.right
                prt.left = l.left
        elif  prt.right and prt.right.val==val:
            r=prt.right
            if r.right is None:prt.right = r.right
            elif r.right is None : prt.right = r.left
            else:
                nd = r.left
                while nd.right is not None:nd = nd.right
                nd.right = r.right
                prt.left = r.left

    def preOrder(self):
        def _p(nd):
            if nd is not None:
                print(nd)
                _p(nd.left)
                _p(nd.right)
        _p(self.root)

7.2. 字首樹(Trie)

class node:
    def __init__(self,val = None):
        self.val = val
        self.isKey = False
        self.children = {}
    def __getitem__(self,i):
        return self.children[i]
    def __iter__(self):
        return iter(self.children.keys())
    def __setitem__(self,i,x):
        self.children[i] = x
    def __bool__(self):
        return self.children!={}
    def __str__(self):
        return 'val: '+str(self.val)+'\nchildren: '+' '.join(self.children.keys())
    def __repr__(self):
        return str(self)

class Trie(object):

    def __init__(self):
        self.root=node('')
        self.dic ={'insert':self.insert,'startsWith':self.startsWith,'search':self.search}

    def insert(self, word):
        """
        Inserts a word into the trie.
        :type word: str
        :rtype: void
        """
        if not word:return
        nd = self.root
        for i in word:
            if i in nd:
                nd = nd[i]
            else:
                newNode= node(i)
                nd[i] = newNode
                nd = newNode
        else:nd.isKey = True
    def search(self, word,matchAll='.'):
        """support matchall function  eg,  'p.d' matchs 'pad' , 'pid'
        """
        self.matchAll = '.'
        return self._search(self.root,word)
    def _search(self,nd,word):
        for idx,i in enumerate(word):
            if i==self.matchAll :
                for j in nd:
                    bl =self._search(nd[j],word[idx+1:])
                    if bl:return True
                else:return False
            if i  in nd:
                nd = nd[i]
            else:return False
        else:return nd.isKey
    def startsWith(self, prefix):
        """
        Returns if there is any word in the trie that starts with the given prefix.
        :type prefix: str
        :rtype: bool
        """
        nd = self.root
        for i in prefix:
            if i in  nd:
                nd= nd[i]
            else:return False
        return True
    def display(self):
        print('preOrderTraverse  data of the Trie')
        self.preOrder(self.root,'')
    def preOrder(self,root,s):
        s=s+root.val
        if  root.isKey:
            print(s)
        for i in root:
            self.preOrder(root[i],s)

7.3. 贏者樹(winnerTree)

class winnerTree:
    '''if i<lowExt    p = (i+offset)//2
       else           p = (i+n-1-lowExt)//2
       offset is a num 2^k-1 just bigger than n
        p is the index of tree
        i is the index of players
        lowExt is the double node num of the lowest layer of the tree
    '''
    def __init__(self,players,reverse=False):
        self.n=len(players)
        self.tree = [0]*self.n
        players.insert(0,0)
        self.players=players
        self.reverse=reverse
        self.getNum()
        self.initTree(1)
    def getNum(self):
        i=1
        while 2*i< self.n:i=i*2
        if 2*i ==self. n:
            self.lowExt=0
            self.s = 2*i-1
        else:
            self.lowExt = (self.n-i)*2
            self.s = i-1
        self.offset = 2*i-1
    def treeToArray(self,p):
        return 2*p-self.offset if p>self.s else 2*p+self.lowExt-self.n+1
    def arrayToTree(self,i):
        return (i+self.offset)//2 if i<=self.lowExt else (i-self.lowExt+ self.n-1)//2
    def win(self,a,b):
        return a<b if self.reverse else a>b
    def initTree(self,p):
        if p>=self.n:
            delta = p%2  #!!! good job  notice delta mark the lchild or rchlid
            return self.players[self.treeToArray(p//2)+delta]
        l = self.initTree(2*p)
        r = self.initTree(2*p+1)
        self.tree[p] = l if self.win(l,r) else r
        return self.tree[p]
    def winner(self):
        idx = 1
        while 2*idx<self.n:
            idx = 2*idx if self.tree[2*idx] == self.tree[idx] else idx*2+1
        num = self.treeToArray(idx)
        num = num+1 if self.players[num] !=self.tree[1] else num
        return self.tree[1],num
    def getOppo(self,i,x,p):
        oppo=None
        if 2*p<self.n:oppo=self.tree[2*p]
        elif i<=self.lowExt:oppo=self.players[i-1+i%2*2]
        else:
            lpl= self.players[2*p+self.lowExt-self.n+1]
            oppo = lpl if lpl!=x else self.players[2*p+self.lowExt-self.n+2]
        return oppo
    def update(self,i,x):
        ''' i is 1-indexed  which is the num of player
            and x is the new val of the player '''
        self.players[i]=x
        p = self.arrayToTree(i)
        oppo =self.getOppo(i,x,p)
        self.tree[p] = x if self.win(x,oppo) else oppo
        p=p//2
        while p:
            l = self.tree[p*2]
            r = None
            if 2*p+1<self.n:r=self.tree[p*2+1]   #notice this !!!
            else:r = self.players[2*p+self.lowExt-self.n+1]
            self.tree[p] = l if self.win(l,r) else r
            p=p//2

7.4. 左斜堆

from functools import total_ordering
@total_ordering

class node:
    def __init__(self,val,freq=1,s=1,left=None,right=None):
        self.val=val
        self.freq=freq
        self.s=s
        if left is None or right is None:
            self.left = left if left is not None else right
            self.right =None
        else:
            if left.s<right.s:
                left,right =right, left
            self.left=left
            self.right=right
            self.s+=self.right.s
    def __eq__(self,nd):
        return self.val==nd.val
    def __lt__(self,nd):
        return self.val<nd.val
    def __repr__(self):
        return 'node(val=%d,freq=%d,s=%d)'%(self.val,self.freq,self.s)

class leftHeap:
    def __init__(self,root=None):
        self.root=root
    def __bool__(self):
        return self.root is not None
    @staticmethod
    def _merge(root,t):  #-> int
        if root is None:return t
        if t is None:return root
        if root<t:
            root,t=t,root
        root.right = leftHeap._merge(root.right,t)
        if root.left is None or root.right is None:
            root.s=1
            if root.left is None:
                root.left,root.right = root.right,None
        else:
            if root.left.s<root.right.s:
                root.left,root.right = root.right,root.left
            root.s = root.right.s+1
        return root
    def insert(self,nd):
        if not isinstance(nd,node):nd = node(nd)
        if self.root is None:
            self.root=nd
            return
        if self.root==nd:
            self.root.freq+=1
            return
        prt =self. _findPrt(self.root,nd,None)
        if prt is None:
            self.root=leftHeap._merge(self.root,nd)
        else :
            if prt.left==nd:
                prt.left.freq+=1
            else:prt.right.freq+=1
    def remove(self,nd):
        if not isinstance(nd,node):nd = node(nd)
        if self.root==nd:
            self.root=leftHeap._merge(self.root.left,self.root.right)
        else:
            prt = self._findPrt(self.root,nd,None)
            if prt is not None:
                if prt.left==nd:
                    prt.left=leftHeap._merge(prt.left.left,prt.left.right)
                else:
                    prt.right=leftHeap._merge(prt.right.left,prt.right.right)
    def find(self,nd):
        if not isinstance(nd,node):nd = node(nd)
        prt = self._findPrt(self.root,nd,self.root)
        if prt is None or prt==nd:return prt
        elif prt.left==nd:return prt.left
        else:return prt.right
    def _findPrt(self,root,nd,parent):
        if not isinstance(nd,node):nd = node(nd)
        if root is None or root<nd:return None
        if root==nd:return parent
        l=self._findPrt(root.left,nd,root)
        return  l if l is not None else self._findPrt(root.right,nd,root)
    def getTop(self):
        return self.root
    def pop(self):
        nd = self.root
        self.remove(self.root.val)
        return nd
    def levelTraverse(self):
        li = [(self.root,0)]
        cur=0
        while li:
            nd,lv = li.pop(0)
            if cur<lv:
                cur=lv
                print()
                print(nd,end=' ')
            else:print(nd,end=' ')
            if nd.left is not None:li.append((nd.left,lv+1))
            if nd.right is not None:li.append((nd.right,lv+1))

js資料結構--樹(tree)
2019-01-18
JS資料結構
資料結構-Tree
2018-07-01
資料結構
資料結構：Expression Tree
2017-06-27
資料結構Express
前端樹形Tree資料結構使用-🤸🏻‍♂️各種姿勢總結
2024-02-25
前端資料結構
LayUI—tree樹形結構的使用
2019-09-01
UI
資料結構——樹
2018-11-16
資料結構
資料結構-樹
2018-10-13
資料結構
【資料結構】K-D Tree
2022-01-26
資料結構
php tree類的使用（樹形結構）
2017-01-17
PHP
資料結構-字典樹
2020-01-31
資料結構
資料結構之「樹」
2019-03-24
資料結構
資料結構 - AVL 樹
2022-04-18
資料結構
前端資料結構--樹
2021-05-08
前端資料結構
【資料結構】AVL樹！！！
2018-01-27
資料結構
資料結構（樹）：二叉樹
2021-06-04
資料結構二叉樹
七、基本資料結構（樹形結構）
2020-06-17
資料結構
28款jQuery Tree 樹形結構外掛
2013-05-22
jQuery
資料結構之樹（線段樹，字典樹）
2020-10-28
資料結構
資料結構-線段樹
2020-01-31
資料結構
資料結構--紅黑樹
2019-10-04
資料結構
資料結構之「B樹」
2019-04-09
資料結構
資料結構之「AVL樹」
2019-03-31
資料結構
[譯] Golang 資料結構：樹
2019-03-17
Golang資料結構
資料結構丨字首樹
2019-07-24
資料結構
資料結構之「霍夫曼樹」
2019-04-14
資料結構
資料結構-佇列-樹
2018-11-01
資料結構佇列
【資料結構】搜尋樹
2020-12-08
資料結構
資料結構——樹和森林
2020-10-04
資料結構
資料結構中樹形結構簡介
2024-04-15
資料結構
Java將List集合組裝成樹（Tree）樹結構組裝
2019-01-02
Java
大資料————決策樹（decision tree）
2022-10-20
大資料
【資料結構】淺談主席樹
2020-07-14
資料結構
資料結構--2-3樹
2019-10-03
資料結構
資料結構之「B+樹」
2019-04-11
資料結構
資料結構之「紅黑樹」
2019-04-02
資料結構
資料結構丨N叉樹
2019-07-16
資料結構
重溫資料結構系列--樹
2019-04-18
資料結構
資料結構-二叉樹
2022-03-27
資料結構二叉樹