LeetCode 144,94,145,102,103 Binary Tree Traversal 二叉树遍历 Python Solution

最新推荐文章于 2022-08-03 18:25:17 发布

Tear_code

最新推荐文章于 2022-08-03 18:25:17 发布

阅读量1.2k

点赞数 1

分类专栏： python LeetCode 文章标签： python leetcode 二叉树遍历递归遍历循环遍历

本文链接：https://blog.csdn.net/u011452172/article/details/78315573

版权

python LeetCode 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

这篇文章汇总介绍 LeetCode 上的二叉树的遍历题目，由于内容可能比较多，所以持续更新中ing

首先是 144. Binary Tree Preorder Traversal

二叉树的前序遍历，这里分别给出递归和循环的做法。

思路：

递归，用一个类属性(类似于全局变量)来保存需要返回遍历列表

循环，使用mystack(先入后出的堆)作为辅助结构来储存一些中间信息。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def __init__(self):
        self.l = []
        
    def preorderTraversal(self, root):
        '''利用递归实现树的前序遍历''' 
        if root == None:
            return []
        self.l.append(root.val)
        self.preorderTraversal(root.left)
        self.preorderTraversal(root.right)
        return self.l
    
    def preorderTraversal(self, root):
        '''利用循环实现树的前序遍历''' 
        if root == None:
            return []
        mystack = []
        out = []
        cur = root
        while cur or myqueue:
            while cur:#从根节点開始，一直找它的左子树
                mystack.append(cur)
                out.append(cur.val)
                cur = cur.left
            cur = mystack.pop().right #while结束表示当前节点node为空，即前一个节点没有左子树了,開始查看它的右子树
        return out
        """
        :type root: TreeNode
        :rtype: List[int]
        """

接着是94. Binary Tree Inorder Traversal

二叉树的中序遍历，这里分别给出递归和循环的做法。

思路：

递归，用一个类属性(类似于全局变量)来保存需要返回遍历列表

循环，使用mystack(先入后出的堆)作为辅助结构来储存一些中间信息。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def __init__(self):
        self.l = []
        
    def inorderTraversal(self, root):
        '''利用递归实现树的中序遍历'''
        if root == None:
            return []
        self.inorderTraversal(root.left)
        self.l.append(root.val)
        self.inorderTraversal(root.right)
        return self.l
        """
        :type root: TreeNode
        :rtype: List[int]
        """
    def inorderTraversal(self, root):
         '''利用堆栈实现树的中序遍历'''
        if root == None:
            return []
        cur = root
        mystack = [] 
        outstack = []
        while mystack or cur:
            while cur:
                mystack.append(cur)
                cur = cur.left
            tmp = mystack.pop()
            outstack.append(tmp.val)
            cur = tmp.right
        return outstack
        
        """
        :type root: TreeNode
        :rtype: List[int]
        """

再接着是145. Binary Tree Postorder Traversal

二叉树的后序遍历，这里分别给出递归和循环的做法。

思路：

递归，用一个类属性(类似于全局变量)来保存需要返回遍历列表

循环，这里使用到一个trick,就是后续遍历(左右根)是(根右左的)反转，而根右左的遍历做法和

前序遍历（根左右类似），这样问题就很轻松了。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def __init__(self):
        self.l = []
        
    def postorderTraversal(self, root):
        if root == None:
            return []
        self.postorderTraversal(root.left)
        self.postorderTraversal(root.right)
        self.l.append(root.val)
        return self.l
    
    def postorderTraversal(self, root):
        if root == None:
            return []
        cur = root
        mystack = []
        out = []
        while mystack or cur:# 根右左的遍历，类似前序的写法
            while cur:
                out.append(cur.val)
                mystack.append(cur)
                cur = cur.right
            cur = mystack.pop().left
        return out[::-1]#反转后就是左右根
        """
        :type root: TreeNode
        :rtype: List[int]
        """

4.然后是102. Binary Tree Level Order Traversal

题目要求给出树的层次遍历，值得注意的是要求了返回格式rtype: List[List[int]]，这个格式有别去上面3题要求的

返回格式，所以一定程度上改变了解法和加强的难度。

return its level order traversal as:

[
  [3],
  [9,20],
  [15,7]
]

这里给出两种解法：

（1）做广度优先遍历BFS，做法就是用一个辅助list来存放每层的遍历节点，并循环更新节点。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def levelOrder(self, root):
        res = []
        if root == None:
            return res
        q = [root] #辅助list
        while len(q)!=0:
            res.append([node.val for node in q])
            new_q = []
            for node in q:#对于上一层的每一个节点都进行以下操作
                if node.left:
                    new_q.append(node.left)
                if node.right:
                    new_q.append(node.right)
            q = new_q
        return res        
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """

(2) 做深度优先搜索DFS,做法就是构建一个辅助list res，并根据list的层数和深度就地操作res

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def dfs(self,root,depth,res):
        if root == None:
            return res
        if len(res) < depth+1:#判断当前节点的深度，进行对应操作
            res.append([])
        res[depth].append(root.val)
        self.dfs(root.left,depth+1,res)
        self.dfs(root.right,depth+1,res)
    def levelOrder(self, root):
        res = []
        self.dfs(root,0,res)
        return res
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """

BTW，这里如果该一下返回list的格式问题就简单多了，比如改rtype: List[int]

下面也想前，中，后序遍历一样给出了两种解法，值得注意的是这里用来存储

节点的是先入先出的队列。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def __init__(self):
        self.l = []
        
    def levelOrder(self, root):
        if root == None:
            return []
        self.l.append(root.val)
        self.levelOrder(root.left)
        self.levelOrder(root.right)
        return self.l
    
    def levelOrder(self, root):
        if root == None:
            return []
        myqueue = [root]#以队列来存放层次遍历的节点
        res = []
        while len(myqueue)!=0:
            node = myqueue.pop(0)
            res.append(node.val)
            if node.left:
                myqueue.append(node.left)
            if node.right:
                myqueue.append(node.right)
        return res
        """
        :type root: TreeNode
        :rtype: List[int]
        """

5.再着是 103. Binary Tree Zigzag Level Order Traversal

题目要求：

Given a binary tree, return the zigzag level order traversal of its nodes' values. (ie, from left to right, then right to left for the next level and alternate between).

For example:
Given binary tree [3,9,20,null,null,15,7],

return its zigzag level order traversal as:

[
  [3],
  [20,9],
  [15,7]
]

解法同层次遍历类似，只需要最后对res的部分元素进行重新组织即可：

这里和层次遍历一样提供两种解法：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def dfs(self,root,depth,res):
        if root == None:
            return res
        if len(res) < depth+1:
            res.append([])
        res[depth].append(root.val)
        self.dfs(root.left,depth+1,res)
        self.dfs(root.right,depth+1,res)
    def zigzagLevelOrder(self, root):
        res = []
        self.dfs(root,0,res)
        for i in range(len(res)):
            if i%2 == 1:
                res[i] = res[i][::-1]
        return res
    def zigzagLevelOrder(self, root):
        res = []
        if root == None:
            return res
        q = [root]
        cnt = 0
        while len(q)!=0:
            res.append([node.val for node in q])
            new_q = []
            for node in q:
                if node.left:
                    new_q.append(node.left)
                if node.right:
                    new_q.append(node.right)
            q = new_q
        for i in range(len(res)):
            if i%2==1:
                res[i] = res[i][::-1]          
        return res
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """

Tear_code

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
LeetCode 144,94,145,102,103 Binary Tree Traversal 二叉树遍历 Python Solution

这篇文章汇总介绍 LeetCode 上的二叉树的遍历题目，由于内容可能比较多，所以持续更新中ing首先是94. Binary Tree Inorder Traversal题目要求：
复制链接

扫一扫