数据结构-----剑指offer----二叉树系列

最新推荐文章于 2022-04-18 15:24:45 发布

程序员小老九

最新推荐文章于 2022-04-18 15:24:45 发布

阅读量97

点赞数

分类专栏：剑指offer 文章标签：树

本文链接：https://blog.csdn.net/mao123_4zxc/article/details/96183157

版权

剑指offer 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

重建二叉树

题目：输入某二叉树的前序遍历和中序遍历，请重建出该二叉树。

假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

算法：

找根节点
递归

注意要求：返回的是根节点

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回构造的TreeNode根节点
    def reConstructBinaryTree(self, pre, tin):
        # write code here
        if len(pre) == 0:
            return None
        elif len(pre)==1:
            return TreeNode(pre[0])
        else:
            root = TreeNode(pre[0])
            pos = tin.index(pre[0])
            root.left = self.reConstructBinaryTree(pre[1:pos+1], tin[:pos])
            root.right = self.reConstructBinaryTree(pre[pos+1:], tin[pos+1:])
        return root

树的子结构

题目：输入两颗二叉树A，B，判断B是不是A的子结构。（我们约定空树不是任意一个树的子结构）

注意：

子树只要包含了一个结点，就得包含这个结点下的所有节点。因此，A树与其子树一定最后同时访问到空指针。
子结构只要包含任意相连的任意数量的结点即可。

算法：

分别将二叉树A，B以相同的方式读取到列表中，list1,list2
然后判断list2是否包含于list1中

举例：list1 = [1,2,3,4,5,6,7] list2 = [4,5,6] ，那么list2是list1的子结构

但是这个代码在牛客网上没有通过，我不太清楚为什么。

现在已经知道了，下面的代码不能排除重复元素的情况。比如，list1 = [1,2,3,4,5,3,6,7] list2= [3,6,7]

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
          
    def __init__(self):
        self.pR1 = []
          
    def ABC(self, pR):
        if pR is None:
            return
        self.pR1.append(pR.val)
        self.ABC(pR.left)
        self.ABC(pR.right)

    def HasSubtree(self, pRoot1, pRoot2):
        # write code here
        if pRoot1 == None or pRoot2 == None:
            return False
        else:
            self.ABC(pRoot1)
            list1 = self.pR1
            self.pR1 = []
            self.ABC(pRoot2)
            list2 = self.pR1

            return list1[list1.index(list2[0]):list1.index(list2[-1])+1] == list2

正确代码：

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
          
    def __init__(self):
        self.pR1 = []
          
    def ABC(self, pR):
        if pR is None:
            return
        self.pR1.append(pR.val)
        self.ABC(pR.left)
        self.ABC(pR.right)

    def HasSubtree(self, pRoot1, pRoot2):
        # write code here
        if pRoot1 == None or pRoot2 == None:
            return False
        else:
            self.ABC(pRoot1)
            listA = self.pR1
            self.pR1 = []
            self.ABC(pRoot2)
            listB = self.pR1
            while listA:
                if listA[:len(listB)] == listB:
                    return True
                else:
                    listA = listA[1:]

二叉树的镜像

题目：操作给定的二叉树，将其变换为源二叉树的镜像

8 8

6 10 10 6

5 7 9 11 11 9 7 5

算法：

根节点不变，左子树变换为右子树
迭代

错误示范：

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回镜像树的根节点
    def Mirror(self, root):
        # write code here
        if (root == None or (root.left == None and root.right == None)):
            return None
        left = self.Mirror(root.left)
        self.Mirror(root.left) = self.Mirror(root.right)
        self.Mirror(root.right) = left

分析：这么写是不对的，为什么呢？首先， $l e f t = s e l f . M i r r o r (r o o t . l e f t)$ 没有问题，但是 $s e l f . M i r r o r (r o o t . l e f t) = s e l f . M i r r o r (r o o t . r i g h t)$ 是不对的，因为这句代码相当于3=2之类的，但是这样操作是不对的。

正确代码：

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回镜像树的根节点
    def Mirror(self, root):
        # write code here
        if (root == None or (root.left == None and root.right == None)):
            return None
        root.left,root.right = root.right,root.left
        self.Mirror(root.left)
        self.Mirror(root.right)

从上往下打印二叉树

题目：从上往下打印二叉树的每个节点，同层节点从左至右打印

算法：

层次遍历
将遍历的节点的值存入列表
打印列表

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回从上到下每个节点值列表，例：[1,2,3]
    def __init__(self):
        self.queue = []
        self.list_result = []
    def PrintFromTopToBottom(self, root):
        # write code here
        if not root :
            return []  
        self.queue.append(root)
        while len(self.queue)>0:
            for i in range(len(self.queue)):
                root = self.queue.pop(0)
                self.list_result.append(root.val)
                if root.left:
                    self.queue.append(root.left)
                if root.right:
                    self.queue.append(root.right)
        return self.list_result

二叉树中和为某一值的路径

题目：输入一颗二叉树和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。

算法—递归算法：

临界点----左子树为空和右子树为空且路径之和为输入整数
”有去“-----对根节点的左子树、右子树分别递归

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
 
class Solution:
    # 返回二维列表，内部每个列表表示找到的路径
    def FindPath(self, root, expectNumber):
        # write code here
        if not root:
            return []
        if not root.left and not root.right and expectNumber == root.val:
            return [[root.val]]
        res = []
        left = self.FindPath(root.left, expectNumber-root.val)
        right = self.FindPath(root.right, expectNumber-root.val)
        for i in left+right:
            res.append([root.val]+i)
        return res
if __name__=='__main__':
    A1 = TreeNode(1)
    A2 = TreeNode(2)
    A3 = TreeNode(3)
    A4 = TreeNode(4)
    A5 = TreeNode(5)
    A6 = TreeNode(6)
 
    A1.left=A2
    A1.right=A3
    A2.left=A4
    A2.right=A5
    A4.left=A6
 
    solution=Solution()
    ans=solution.FindPath(A1,8)
    print('ans=',ans)

图示分析：

在这里插入图片描述

二叉树的深度

题目：输入一个二叉树，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。

算法：

记录次数
迭代

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def __init__(self):
        self.i = 1
        self.j =1
    def TreeDepth(self, pRoot):
        # write code here
        if pRoot == None:
            return 0
        else:
            if self.TreeDepth(pRoot.left):
                self.i +=1
            if self.TreeDepth(pRoot.right):
                self.j +=1
        num = max(self.i,self.j)
        return num

平衡二叉树

输入一颗二叉树，判断该二叉树是否为平衡二叉树

Note: 什么叫平衡二叉树呢？平衡的意思是树中任意一个节点下左右两个子树的高度差不超过1.

百度百科：平衡二叉树

算法：

先定义一个求解树的深度的函数
求解左子树的深度、右子树的深度
深度之差不大于1

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def __init__(self):
        self.i = 1
        self.j = 1
    def deep_tree(self,pRoot):
        if not pRoot:
            return 0
        else:
            if pRoot.left:
                self.i += 1
                self.deep_tree(pRoot.left)
            if pRoot.right:
                self.j += 1
                self.deep_tree(pRoot.right)
        return max(self.i,self.j)
    def IsBalanced_Solution(self, pRoot):
        # write code here
        if not pRoot:
            return True
        else:
            left_num = self.deep_tree(pRoot.left)
            self.i = 1
            self.j = 1
            right_num = self.deep_tree(pRoot.right)
        if abs(left_num-right_num)==1 or abs(left_num-right_num)==0 :
            return True

二叉树的下一个结点

题目：给定一个二叉树和其中的一个节点，请找出中序遍历顺序的下一个节点并且返回。注意，树中的节点不仅包含左右子节点，同时包含指向父节点的指针。

算法：

先中序遍历
然后找到根节点
匹配，找下一个节点

# -*- coding:utf-8 -*-
# class TreeLinkNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#         self.next = None
class Solution:
    def __init__(self):
        self.inorder = []
    def get_inorder(self, pRoot):  # 先得到中序遍历序列
        if pRoot.left:
            self.get_inorder(pRoot.left)
        self.inorder.append(pRoot)
        if pRoot.right:
            self.get_inorder(pRoot.right)
    def GetNext(self, pNode):
        # write code here
        temp = pNode
        # 找到根节点
        while temp.next:  
            temp = temp.next
        #得到中序遍历
        self.get_inorder(temp) 
        # 遍历中序序列，找到下一个节点
        for index, value in enumerate(self.inorder):  
            if value == pNode:
                # 需要查找的结点不是最后一个结点
                if index != len(self.inorder) - 1:  
                    return self.inorder[index + 1]
        return None

对称的二叉树

请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是相同的，定义为对称的。

算法：

根节点的左子树等于右子树
右子树等于左子树
递归

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def isSymmetrical(self, pRoot):
        # write code here
        if pRoot == None:
            return True
        return self.comroot(pRoot.left, pRoot.right)
      
    def comroot(self, left, right):
        if left == None:
            return right == None
        if right == None:
            return False
        if left.val != right.val:
            return False
        return self.comroot(left.left, right.right) and self.comroot(left.right, right.left)

按之字顺序打印二叉树

题目：请实现一个函数按照之字形打印二叉树，即第一行按照从左到有的顺序打印，第二行按照从右往左的顺序打印，第三行按照从左往右的顺序打印，其他行以此类推。

算法：

要有判断条件
递归

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def __init__(self):
        self.res = []
        self.stack = []
        self.n = 0
    def Print(self, pRoot):
        # write code here
        if pRoot is None:
            return []
         
        #stack = []
        self.stack.append(pRoot)
        
        while len(self.stack)!=0:
            size = len(self.stack)
            temp = []
            for i in range(size):
                p = self.stack.pop(0)
                temp.append(p.val)
                if p.left:
                    self.stack.append(p.left)
                if p.right:
                    self.stack.append(p.right)
                     
            if self.n % 2 == 0:
                self.res.append(temp)
            else:
                self.res.append(temp[::-1])
            self.n += 1
             
        return self.res

把二叉树打印成多行

从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。

和上一题差不多吧

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def __init__(self):
        self.res = []
        self.stack = []
        self.n = 0
    def Print(self, pRoot):
        # write code here
        if pRoot is None:
            return []
         
        #stack = []
        self.stack.append(pRoot)
        
        while len(self.stack)!=0:
            size = len(self.stack)
            temp = []
            for i in range(size):
                p = self.stack.pop(0)
                temp.append(p.val)
                if p.left:
                    self.stack.append(p.left)
                if p.right:
                    self.stack.append(p.right)
                     
            
            self.res.append(temp)

        return self.res

序列化二叉树

请实现两个函数，分别用来序列化和反序列化二叉树。

1. 对于序列化：使用前序遍历，递归的将二叉树的值转化为字符，并且在每次二叉树的结点
不为空时，在转化val所得的字符之后添加一个'，'作为分割。对于空节点则以 '#' 代替。
2. 对于反序列化：就是将类似于‘‘1’‘，’‘2’‘，’‘#’’这样的文本按照一定的顺序恢复为1,2节点

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def Serialize(self, root):
        # write code here
        if not root:
            return "#"
        return str(root.val)+","+self.Serialize(root.left)+","+self.Serialize(root.right)
    def Deserialize(self, s):
        # write code here
        if not s:
            return None
        s = s.split(',')
        return self.dfs(s)
     
    def dfs(self, s):
        val = s.pop(0)
        if val == '#':
            return None
        elif val != '#' and s:
            node = TreeNode(int(val))
            node.left = self.dfs(s)
            node.right = self.dfs(s)
            return node

程序员小老九

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
数据结构-----剑指offer----二叉树系列

重建二叉树题目：输入某二叉树的前序遍历和中序遍历，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。算法：找根节点递归注意要求：返回的是根节点# -*- coding:utf-8 -*-# class TreeNode:# ...
复制链接

扫一扫

专栏目录