2. 程式人生 > >二叉樹演算法整理

二叉樹演算法整理

阿新 • • 發佈：2019-01-14

演算法1， 序列化二叉樹（二叉樹的先序遍歷）

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
class Solution:
    def __init__(self):
        self.index = 0
        self.listS = []
    def RecursionSe(self, root):
        series = ''
        if root ==
 
 None:
            series += ',$'
        else:
            series += (',' + str(root.val))
            series += self.RecursionSe(root.left)
            series += self.RecursionSe(root.right)
        return series
    def Serialize(self, root):
        # write code here
        return self.RecursionSe(
 
root)[1:]

測試：

root = TreeNode(11)
root.left = TreeNode(2)
root.right = TreeNode(3)
series = Solution().Serialize(root)

輸出：
在這裡插入圖片描述

演算法2，反序列化二叉樹

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
class Solution:
    def __init__(
 
self):
        self.index = 0
        self.listS = []
    def RecursionDe(self):
        node = None
        if self.index < len(self.listS):
            if self.listS[self.index] == '$':
                self.index += 1   #將節點為空之後就直接返回了
            else:
                node = TreeNode(int(self.listS[self.index]))
                self.index += 1
                node.left = self.RecursionDe()
                node.right = self.RecursionDe()
        return node
    def Deserialize(self, s):
        # write code here
        self.listS = s.split(',')   #將序列化的字串變為陣列
        return self.RecursionDe()

測試：

root = Solution().Deserialize(series)
print(root.val)
print(root.left.val)
print(root.right.val)
print(root.right.right)

在這裡插入圖片描述

演算法3，層次化遍歷二叉樹

使用一個佇列層次遍歷

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
class Solution:
    # 返回從上到下每個節點值列表，例：[1,2,3]
    def PrintFromTopToBottom(self, root):
        # write code here
        list = []
        result = []  #注意兩個列表如果相等賦值，那麼一下就會更新兩個
        ####  list = result = []   !!!!錯誤
        if root == None:
            return list
        list.append(root)
        while list != []:
            treeNode = list.pop(0)
            result.append(treeNode.val)
            if treeNode.left:
                list.append(treeNode.left)
            if treeNode.right:
                list.append(treeNode.right)
        return result

演算法4，層次遍歷，每一層在一行輸出，“之”字型遍歷二叉樹

為了將每一層進行單獨輸出，需要統計這一行的個數toPrint，然後統計下一行的個數nextPrint
參考我之前的部落格：https://blog.csdn.net/weixin_36372879/article/details/83994160

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
class Solution:
    # 返回二維列表[[1,2],[4,5]]
    def Print(self, pRoot):
        # write code here
        if pRoot == None:
            return []
        queue = []
        toPrint = 1
        queue.append(pRoot)
        nextPrint = 0
        results = []
        result = []
        while queue != []:
            popNode = queue.pop(0)
            result.append(popNode.val)
            toPrint -= 1
            if popNode.left:
                queue.append(popNode.left)
                nextPrint += 1
            if popNode.right:
                queue.append(popNode.right)
                nextPrint += 1
            if toPrint == 0:
                results.append(result)  #這層遍歷完畢，加入到結果中
                toPrint = nextPrint  #下層需要遍歷的資料
                result = []   #這層遍歷完畢，清零
                nextPrint = 0   #下下層清零
        return results

“之字形列印二叉樹”：可以使用棧

演算法5，根據前序序列和中序序列重建二叉樹

演算法思想就是：先序遍歷的肯定是根節點，然後在中序遍歷序列中，找到這個節點，將樹的構造一分為二即可。

class TreeNode:
     def __init__(self, x):
         self.val = x
         self.left = None
         self.right = None
class Solution:
    # 返回構造的TreeNode根節點
    def construct(self, pre, tin, startPre, endPre, startTin, endTin):
        if startPre <= endPre:
            root = TreeNode(pre[startPre])
            i = startTin
            while tin[i] != pre[startPre]:   #在中序遍歷中，找到根節點，然後一分為二
                i += 1
            leftLength = i - startTin   #左子樹的長度
            if leftLength:
                root.left = self.construct(pre, tin, startPre + 1, startPre + leftLength, startTin, i - 1)
            if endTin - i:
                root.right = self.construct(pre, tin, startPre + leftLength + 1, endPre, i + 1, endTin)
        return root
    def reConstructBinaryTree(self, pre, tin):
        # write code here
        return self.construct(pre, tin, 0, len(pre) - 1, 0, len(tin) - 1)

演算法6，二叉樹和為某一值的路徑（回溯遍歷演算法）

題目描述
輸入一顆二叉樹的跟節點和一個整數，打印出二叉樹中結點值的和為輸入整數的所有路徑。路徑定義為從樹的根結點開始往下一直到葉結點所經過的結點形成一條路徑。(注意: 在返回值的list中，陣列長度大的陣列靠前)
演算法思想：為了記住中間的遍歷路徑，使用一個數組來記錄，最後判斷陣列的和，往左邊遍歷之後，需要回溯陣列，然後往右邊遍歷

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
class Solution:
    # 返回二維列表，內部每個列表表示找到的路徑
    def __init__(self):
        self.results = []
    def ListSum(self, l):
        sum = 0
        for i in l:
            sum += i
        return sum
    def RecursionFindPath(self, root, expectNumber, result):
        result.append(root.val)
        temp = result[:]  #儲存之前的結果
        if root.left == None and root.right == None and self.ListSum(result) == expectNumber:
            self.results.append(result)
        if root.left:
            self.RecursionFindPath(root.left, expectNumber, result)
        result = temp[:]  #回溯過程
        if root.right:
            self.RecursionFindPath(root.right, expectNumber, result)
    def QuickSort(self, results, start, end):   #對陣列進行快速排序
        if start >= end:
            return
        low, high = start, end
        pivot = results[start]
        while low < high:
            while low < high and len(results[high]) <= len(pivot):
                high -= 1
            if low < high:
                results[low] = results[high]
            while low < high and len(results[low]) >= len(pivot):
                low += 1
            if low < high:
                results[high] = results[low]
        results[low] = pivot
        self.QuickSort(results, start, low - 1)
        self.QuickSort(results, low + 1, end)
    def FindPath(self, root, expectNumber):
        # write code here
        if root == None:
            return []
        self.RecursionFindPath(root, expectNumber, [])
        if self.results == []:
            return []
        self.QuickSort(self.results, 0, len(self.results) - 1)
        return self.results

測試：

root = TreeNode(1)
root.left = TreeNode(2)
root.left.left = TreeNode(4)
root.right = TreeNode(3)
root.right.right = TreeNode(2)
root.right.right.left = TreeNode(1)
root.right.right.right = TreeNode(5)
expectNum = 7
print(Solution().FindPath(root, expectNum))

輸出：
在這裡插入圖片描述

演算法7，遍歷樹的第k個節點

例如下面這個二叉搜尋樹，找出第k個節點
在這裡插入圖片描述
演算法思想就是設定一個全域性的k，然後使用中序遍歷
需要注意的是程式碼的寫法，不能根據k判斷，而是要根據結果判斷，因為需要先遍歷，再k–。

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
class Solution:
    def __init__(self):
        self.k = 0
    def InOrder(self, Root):
        ans = None
        if Root:
            if ans == None and Root.left:
                ans = self.InOrder(Root.left)   #往左遍歷
            if ans == None and self.k == 1:
                ans = Root                      #遍歷到目標節點
            if ans == None and self.k != 1:     #沒有遍歷到目標節點，k--
                self.k -= 1
            if ans == None and Root.right:      #往右遍歷
                ans = self.InOrder(Root.right)
        return ans
    def KthNode(self, Root, k):
        if Root == None or k <= 0:
            return None
        self.k = k
        return self.InOrder(Root)

演算法8，遍歷倒數第k個節點

遍歷倒數第k個節點，可以使用中序遍歷，只不過先遍歷右子樹，再遍歷左子樹

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
class Solution:
    # 返回對應節點TreeNode
    def __init__(self):
        self.k = 0
    def ReverseInOrder(self, pRoot):
        ans = None
        if pRoot:
            if ans == None and pRoot.right:
                ans = self.ReverseInOrder(pRoot.right)
            if ans == None and self.k == 1:
                ans = pRoot
            if ans == None and self.k != 1:
                self.k -= 1
            if ans == None and pRoot.left:
                ans = self.ReverseInOrder(pRoot.left)
        return ans
    def KthNode(self, pRoot, k):
        # write code here
        if pRoot == None and k < 1:
            return None
        self.k = k
        return self.ReverseInOrder(pRoot)

演算法9，樹的子結構

部落格：https://blog.csdn.net/weixin_36372879/article/details/83831191
輸入兩棵二叉樹A，B，判斷B是不是A的子結構。（ps：我們約定空樹不是任意一個樹的子結構）

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def Tree1HasTree2(self, pRoot1, pRoot2):
        if pRoot2 == None:
            return True
        elif pRoot1 == None:
            return False
        if pRoot1.val == pRoot2.val:
            return self.Tree1HasTree2(pRoot1.left, pRoot2.left) and self.Tree1HasTree2(pRoot1.right, pRoot2.right)
        else:
            return False
    def HasSubtree(self, pRoot1, pRoot2):
        # write code here
        if pRoot1 == None or pRoot2 == None:
            return False
        ans = False
        if pRoot1.val == pRoot2.val:
            ans = self.Tree1HasTree2(pRoot1, pRoot2)
        if ans == False:
            ans = self.Tree1HasTree2(pRoot1.left, pRoot2)
        if ans == False:
            ans = self.Tree1HasTree2(pRoot1.right, pRoot2)
        return ans

演算法10 二叉樹的映象（將二叉樹的左子樹和右子樹交換）

在這裡插入圖片描述

class Solution:
    # 返回映象樹的根節點
    def Mirror(self, root):
        # write code here
        if root == None:
            return None
        if root.left == None and root.right == None:
            return root
        root.left, root.right = self.Mirror(root.right), self.Mirror(root.left)
        return root

演算法11 對稱二叉樹

判斷二叉樹是否對稱。

class Solution:
    def RecursionSymmetry(self, root1, root2):
        if root1 == None and root2 == None:
            return True
        elif root1 == None or root2 == None:
            return False
        if root1.val == root2.val:
            return self.RecursionSymmetry(root1.left, root2.right)
        else:
            return False
    def isSymmetrical(self, pRoot):
        # write code here
        return self.RecursionSymmetry(pRoot, pRoot)

相關推薦

二叉樹演算法整理

演算法1， 序列化二叉樹（二叉樹的先序遍歷） class TreeNode: def __init__(self, x): self.val = x self.left = None self.right = None clas

python編寫二叉樹演算法

       二叉樹的遍歷是樹的一種重要的運算。所謂遍歷是指對樹中所有結點的資訊的訪問，即依次對樹中每個結點訪問一次且僅訪問一次，我們把這種對所有節點的訪問稱為遍歷（traversal）。那麼樹的兩種重要的遍歷模式是深度優先遍歷

Leetcode二叉樹演算法題解題思路

題目型別 1. 構造二叉樹----遞迴 2. 二叉樹前序，中序，後序遍歷-遞迴，非遞迴（根節點入stack，不為空迴圈，出stack，獲取左右節點） 3. 二叉樹廣度優先遍歷-----利用佇列 4. 二叉樹最大，最小深度----遞迴或者BFS，整層節點入佇列，利用size--迴圈計數

java實現的一些二叉樹演算法

二叉堆 == 完全二叉樹 二叉堆滿足二個特性： 1．父結點的鍵值總是大於或等於（小於或等於）任何一個子節點的鍵值。 2．每個結點的左子樹和右子樹都是一個二叉堆（都是最大堆或最小堆）。 當父結點的鍵值總是大於或等於任何一個子節點的鍵值時為最大堆。當父結點的鍵值總是小於或等於任何一個

【第十週專案1】二叉樹演算法驗證（一）

/* Copyright (c)2017,煙臺大學計算機與控制工程學院 All rights reserved. 檔名稱：33.cpp 作 者：尚文哲 完成日期：2017年11月9日 問題描述: 執行並重複測試教學內容中涉及的演算法。改

前序遍歷序列和中序遍歷序列構造二叉樹演算法

轉自：https://blog.csdn.net/github_35124642/article/details/51735307前序，中序遍歷，在此就不向大家向下說明了，如有不懂請先理解，再來看此篇文章。當我們拿到前序和中序時，如何重新構建一顆新的數呢？首先，大家都知道的，

【資料結構】二叉樹演算法題思路

首先需要做到掌握三種常規遍歷（前、中、後）以及按層遍歷，幾乎所有的演算法題都逃不開這三種方法。 其次，做二叉樹題目，很多情況都可以使用遞迴的方法來做，要經常想這個。 舉例： 1. 二叉樹映象問題 2. 二叉樹找子樹問題

非遞迴中序遍歷二叉樹演算法詳解

注意學習這個演算法需要隨時可以在腦海中輸出二叉樹的中序遍歷的序列 舉例： 如上圖，我們就看到一棵二叉樹：那麼我們是不是馬上可以想到這棵二叉樹的中序遍歷序列是什麼呢？ 我直接給出答案：D B EF A G H C I 我們如果不適用遞迴中序遍歷二叉樹

php 二叉樹演算法小解

前段時間出去面試，被問到如果從一個數組中快速找到某一個元素在該陣列的位置。我當時大概想到他是想問我演算法，當時不是很清楚怎麼寫，就用說切割字串，用字串函式去找，當時想的是字串函式查詢起來挺方便的。面試官直接說。我給的陣列很小，如果很大怎麼辦。肯定不能用你這種方法

面試常考--二叉樹演算法

 樹是一種比較重要的資料結構，尤其是二叉樹。二叉樹是一種特殊的樹，在二叉樹中每個節點最多有兩個子節點，一般稱為左子節點和右子節點（或左孩子和右孩子），並且二叉樹的子樹有左右之分，其次序不能任意顛倒。二叉樹是遞迴定義的，因此，與二叉樹有關的題目基本都可以用遞迴思想

根據前序遍歷序列和中序遍歷序列構造二叉樹演算法

http://blog.csdn.net/yunzhongguwu005/article/details/9270085  1 確定根，確定左子樹，確定右子樹  2 在左子樹中遞迴  3 在右子樹中遞迴  4 列印當前根 I 前序遍歷的第一個就是根。 II 中序遍歷根據根，

二叉樹演算法驗證】之層次遍歷演算法的驗證

Copyright(c) 2017,煙臺大學計算機與控制工程學院 All rights reserved. 檔名稱：text.cpp 作者：黃瀟慧 完成日期：2017年11月2日 版本：ｖｃ６．０ 問題描述：實現二叉樹的層次遍歷演算法，並

按層次遍歷二叉樹演算法

問題：按層次遍歷二叉樹 在網上看了一些按層次遍歷二叉樹的演算法,這裡修改了一下通過佇列來按層次遍歷二叉樹的演算法 -------------------------------------------

二叉樹演算法引發的指標引數傳遞和引用的思考

最近想熟悉一下基本的資料結構和演算法，於是寫了一個二叉樹程式，功能很簡單，只有二叉樹的建立和遍歷。在這個過程中，卻發現了一些平時沒有注意到的細節問題，寫出來作為總結和大家分享。 待討論和遇到的細節問題如下： （1）常見的定式思維：指標作為引數傳遞，是否就不需要再賦值

二叉樹演算法（java）

二叉樹的展示功能（中序遍歷） private void show(Node node) { if (node != null) { this.show(node.leftChildNode); System.out.println(node.key + ":" + node.value);

java 反轉二叉樹演算法

題目：Invert a binary tree. 4 / \ 2 7 / \ / \ 1 3 6 9 to 4 / \

二叉樹演算法應用案例

筆者在1月4號將在CSDN學院開設一門公開課《演算法與遊戲實戰》，在這裡先把課程內容透露一部分給讀者。首先講述二叉樹演算法，二叉樹在IT領域應用是非常廣泛的，它不僅在遊戲開發中，在當前比較火的人工智慧上也得到了廣泛的應用。作為使用者，首先要清楚二叉樹的特性：它是n(n≥0)

二叉樹演算法驗證（4）

/*   *Copyright  (c)2017,煙臺大學計算機與控制工程學院       *All rights reservrd.       *檔名稱 ：test.cpp       *作者：杜昕曄   *完成時間：2017年12月07日       *

第11周專案1——二叉樹演算法驗證

問題及程式碼：/* *Copyright(c++)2015,煙臺大學計算機與控制工程學院 *All rights reserved. *檔名稱：CPP1.cpp *作者：宋 晨 *完成

二叉樹演算法驗證（2）

/*   *Copyright  (c)2017,煙臺大學計算機與控制工程學院       *All rights reservrd.       *檔名稱 ：test.cpp       *作者：杜昕曄   *完成時間：2017年12月08日       *