二叉树练习

最新推荐文章于 2022-10-04 16:50:54 发布

原创最新推荐文章于 2022-10-04 16:50:54 发布 · 344 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode 专栏收录该内容

10 篇文章

订阅专栏

本文主要介绍了二叉树的几种遍历方法，包括中序遍历、前序遍历和后序遍历，并详细讲解了从上往下打印二叉树、按之字形打印二叉树、判断二叉树是否对称以及找到二叉树的下一个节点等经典问题的解决方案。通过这些实例，读者可以深入理解二叉树的遍历和操作技巧。

中序遍历

class TreeNode(object):
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None


def in_order_traversal(root):  # 中序
    res = []
    stack = []#借用栈
    if root is None:
        return res
    cur = root
    while len(stack) != 0 or cur is not None:
        while cur is not None:
            stack.append(cur)
            cur = cur.left
        node = stack.pop()
        res.append(node.val)
        cur = node.right
    return res
    
# 中序打印二叉树（递归）
def inOrderTraverse(node):
    if node is None:
        return None
    inOrderTraverse(node.left)
    print(node.val)
    inOrderTraverse(node.right)

前序遍历

class TreeNode(object):
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None


def pre_order_traversal(root):  # 前序
    result = []
    stack = []
    stack.append(root)
    while len(stack) != 0:
        node = stack.pop()
        if node is None:
            continue
        result.append(node.val)
        stack.append(node.right)
        stack.append(node.left)
    return result
    
# 先序打印二叉树（递归）
def preOrderTraverse(node):
    if node is None:
        return None
    print(node.val)
    preOrderTraverse(node.left)
    preOrderTraverse(node.right)

后序遍历

class TreeNode(object):
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None


def post_order_traversal(root):  # 后序
    """
    前序遍历为 root -> left -> right，后序遍历为 left -> right -> root，
    可以修改前序遍历成为 root -> right -> left，那么这个顺序就和后序遍历正好相反
    """
    result = []
    stack = []
    stack.append(root)
    while len(stack) != 0:
        node = stack.pop()
        if node is None:
            continue
        result.append(node.val)
        stack.append(node.left)
        stack.append(node.right)
    return result[::-1]
    
# 后序打印二叉树（递归）
def postOrderTraverse(node):
    if node is None:
        return None
    postOrderTraverse(node.left)
    postOrderTraverse(node.right)
    print(node.val)

从上往下打印二叉树（简单）

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

思路：

根节点不存在返回空
开辟queue空间初始化为[root] 队列意味着一层一层的遍历
开辟放结果的数组 res
当队列不为空时while：
计算这一层有几个节点n
遍历这一层for
如果这一层不存在节点退出for循环
否则取出一个节点添加到放结果的数组res
将下一层的节点都添加到队列即如果该节点左右节点存在添加到队列
返回res

运行时间：26ms

占用内存：5860k

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
def construct_tree():
    root = TreeNode(8)
    root.left = TreeNode(6)
    root.right = TreeNode(10)
    root.left.left = TreeNode(5)
    root.left.right = TreeNode(7)
    root.right.left = TreeNode(9)
    root.right.right = TreeNode(11)
    root.left.right.left = TreeNode(12)
    root.left.right.right = TreeNode(13)
    return root
class Solution:
    # 返回从上到下每个节点值列表，例：[1,2,3]
    def PrintFromTopToBottom(self, root):
        # write code here
        if not root:return []
        queue=[root]
        res=[]
        while queue:
            n=len(queue)
            for _ in range(n):
                if not queue:break
                temp=queue.pop(0)
                res.append(temp.val)
                if temp.left:
                    queue.append(temp.left)
                if temp.right:
                    queue.append(temp.right)
        return res
s=Solution()
tree= construct_tree()
res=s.PrintFromTopToBottom(tree)
print(res)  
#return [8, 6, 10, 5, 7, 9, 11, 12, 13]

按之字形打印二叉树

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

思路：
同上一道题，不同之处在于添加了标记偶数行的标记 j，j 初始化为-1 ，每开始新一行的循环 j 就加一，最后每一行遍历完后判断这是奇数行还是偶数行，偶数行的话，反转这一行的数值。第二个不同之处在于，开辟了放每一行数值的暂存数组temp，因为偶数行的话，必须反转后才能添加到结果数组res里面。

运行时间：27ms

占用内存：5728k

class Solution:
    def Print(self, pRoot):
        # write code here
        if not pRoot: return []
        res = []#放结果的数组
        queue = [pRoot]
        j = -1#标记偶数行
        while queue:
            j += 1
            n = len(queue)
            temp = []#放这一行的节点数值
            for _ in range(n):
                node = queue.pop(0)
                temp.append(node.val)
                if node.left: queue.append(node.left)
                if node.right: queue.append(node.right)
            if j % 2:#当j表示这一行为偶数行 反转这一行
                temp.reverse()
            res.append(temp)#把这一行确定的节点数值放进结果数组里
        return res
        
s=Solution()
tree= construct_tree()
res=s.Print(tree)
print(res)

把二叉树打印成多行

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

运行时间：25ms

占用内存：5632k

class Solution:
    # 返回二维列表[[1,2],[4,5]]
    def Print(self, pRoot):
        # write code here
        if not pRoot: return []
        queue = [pRoot]
        res = []
        while queue:
            n = len(queue)
            temp = []
            for _ in range(n):
                node = queue.pop(0)
                temp.append(node.val)
                if node.left: queue.append(node.left)
                if node.right: queue.append(node.right)
            res.append(temp)
         #   print(res)
        return res
#return [[8], [6, 10], [5, 7, 9, 11]]

对称的二叉树

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

思路：

如果根节点不存在返回真
把每一层放进队列 queue = [pRoot]

当队列里有节点时进行以下操作
看这一层有多少个节点 n

如果非根节点且这一层节点数是奇数
则返回false
否则
重点，判断这一行最左和最右是否一样

【判断两个节点一样么
两节点都不存在则两节点一样
两节点都存在且数值一样则两节点一样
否则返回不一样】

遍历这一行
弹出队列中的一个节点
如果该节点不存在过
否则将下一层的节点都添加到队列即如果该节点左右节点存在添加到队列

运行时间：25ms

占用内存：5732k

class Solution:
    def isEqual(self,p1, p2):
        if not p1 and not p2:
            return True
        elif p1 and p2 and p1.val == p2.val:
            return True
        else:
            return False
    def isSymmetrical(self, pRoot):
        # write code here
        if not pRoot: return True
        queue = [pRoot]
        while queue:
#            print(queue)
            n = len(queue)
            if queue[0] != pRoot and n % 2 != 0: 
                return False
            for i in range(n//2):
                if not self.isEqual(queue[i], queue[-1-i]):
                    return False
            for _ in range(n):
                node = queue.pop(0)
                if not node: continue
                queue.append(node.left)
                queue.append(node.right)
        return True

二叉树的下一个结点

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

思路：
分情况讨论

第一：节点p的右节点存在：p的下一个节点则为p的右子树的最左节点 [1.1】
第二：节点p的右节点不存在的话分两种情况：
第一：节点p的右节点不存在的话且 p为其父节点的左子节点：p的下一个节点则为p的父节点【2.1】
第二：节点p的右节点不存在的话且 p为其父节点的右子节点： p的下一个节点为沿着父节点往上遍历找到一个点满足该点是其父节点的左子节点。（若该点不存在，则p的下一个节点不存在）【2.2】

如果该节点为空返回None
p的右节点存在的话
找到右子树的最左节点返回

节点p的右节点不存在的话且 p为其父节点的右子节点时：
关键，往上遍历当pNode是自己父节点的左子节点时，跳出while
返回pNode的父节点

运行时间：26ms

占用内存：5864k

def construct_tree():
    root = TreeNode(1)
    root.left = TreeNode(2)
    root.right = TreeNode(3)
    root.left.left = TreeNode(4)
    root.left.right = TreeNode(5)
    root.right.left = TreeNode(6)
    root.right.right = TreeNode(7)
    root.left.right.left = TreeNode(8)
    root.left.right.right = TreeNode(9)
     '''
    root = TreeNode('a')
    root.left = TreeNode('b')
    root.right = TreeNode('c')
    root.left.left = TreeNode('d')
    root.left.right = TreeNode('e')
    root.right.left = TreeNode('f')
    root.right.right = TreeNode('g)
    root.left.right.left = TreeNode('h')
    root.left.right.right = TreeNode('i')
    '''
    root.parent = None
    root.left.parent= root
    root.right.parent= root
    root.left.left.parent= root.left
    root.left.right.parent =root.left
    root.right.left.parent= root.right
    root.right.right.parent= root.right
    root.left.right.left.parent = root.left.right
    root.left.right.right.parent =root.left.right
    return root

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
        self.parent = None

class Solution:
    def GetNext(self, pNode):
        # write code here
        if not pNode: return None
        if pNode.right:  # 
            p = pNode.right
            while p.left:
                p = p.left
            return p
         # 
        while pNode.parent and pNode.parent.right == pNode:
            pNode = pNode.parent
        return pNode.parent
        
        
root=construct_tree()
s=Solution()
#res=s.GetNext(root.left.left)
res=s.GetNext(root.right.left)
print(res.val)

二叉树的深度

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

思路：
队列queue 用来放每一层节点

运行时间：28ms

占用内存：5728k

class Solution:
    def TreeDepth(self, pRoot):
        # write code here
        if not pRoot: return 0#根节点不存在 返回0
        queue = [pRoot]# 把每一层放进队列
        deep = 0#深度初始化为0
        while queue:#当这一层有节点时
            n = len(queue)#看着一层有几个节点n
            for _ in range(n):#遍历这一层的n个节点
                node = queue.pop(0)#弹出一个，并把弹出的节点的下一层的节点（即左右子节点）添加到队列
                if node.left: queue.append(node.left)
                if node.right: queue.append(node.right)
            deep += 1#每一层遍历完 深度加一
        return deep

二叉搜索树的第k个结点

题目描述
给定一棵二叉搜索树，请找出其中的第k小的结点。例如，（5，3，7，2，4，6，8）中，按结点数值大小顺序第三小结点的值为4。

运行时间：26ms

占用内存：5864k

树的子结构

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

重建二叉树（中等）

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

思路

用前序遍历找到根结点，用根结点在中序遍历中切开左右子树，递归重建二叉树

前序数组为空时，返回空
用前序遍历找到根结点
初始化一个为根值的树节点
遍历后序数组，找到根数值的索引位置i
切分左右子树,递归调用本函数
返回根节点

运行时间：42ms

占用内存：5724k

# 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 not pre:
            return
        root_val=pre[0]
        root=TreeNode(root_val)
        for i in range(len(tin)):
            if tin[i]==root_val:break
        root.left=self.reConstructBinaryTree(pre[1:1+i],tin[:i])
        root.right=self.reConstructBinaryTree(pre[1+i:],tin[i+1:])
        return root