算法面试常考题总结--树各种遍历方法总结python版本【后序、前序、中序、层次 递归迭代版本】

二叉树的遍历

前序遍历

根左右

前序遍历递归写法

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        res = []
        def dfs(node):
            if not node:
                return 
            res.append(node.val)
            if node.left:
                dfs(node.left)
            if node.right:
                dfs(node.right)
        dfs(root)
        return res 

前序遍历的循环写法

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        res = []
        stack = [root]
        while stack:
            node = stack.pop() # 从后面pop
            if node:
                res.append(node.val)
                # 如果有处理，这里处理节点
                # 因为从后面pop，所以先添加右节点
                if node.right:
                    stack.append(node.right)
                if node.left:
                    stack.append(node.left)
        return res 

n叉树的前序遍历

递归版本

class Solution:
    def preorder(self, root: 'Node') -> List[int]:
        res  = []
        def dfs(node):
            if not node:
                return 
            res.append(node.val)
            if not node.children:
                return 
            for child in node.children:
                dfs(child)
        dfs(root)
        return res 

循环版本

class Solution:
    def preorder(self, root: 'Node') -> List[int]:
        res  = []
        if not root:return 
        stack = [root]
        while stack:
            node = stack.pop()
            res.append(node.val)
            if node.children:
                stack.extend(node.children[::-1])
        return res 

备注：如果使用循环写法，使用pop，记得倒序增加节点

层次遍历

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        res = []
        if not root:return []
        stack = [root]
        while stack:
            next_stack = []
            res_tmp = []
            while stack:
                node = stack.pop(0)
                res_tmp.append(node.val)
                # 从右往左增加节点
                if node.left:
                    next_stack.append(node.left)
                if node.right:
                    next_stack.append(node.right)
            stack = next_stack[:]
            res.append(res_tmp)
        return res 

中序遍历-左右根

递归写法，调整遍历顺序

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        res = []
        def dfs(node):
            if not node:
                return 
            if node.left:
                dfs(node.left)
            res.append(node.val)
            if node.right:
                dfs(node.right)
        dfs(root)
        return res

循环写法，调整入栈和出栈顺序

def inorderTraversal(self, root: TreeNode) -> List[int]:
        res = []
        stack = []
        pos = root 
        if not pos:return []
        while pos or stack:
            while pos:
            	stack.append(pos)
            	pos = pos.left
            pos = stack.pop()
            # 处理该节点
            pos = pos.right
        return res

二叉树节点数

递归写法

class Solution:
    def countNodes(self, root: TreeNode) -> int:
        def count_node(node):
            if not node:
                return 0
            return count_node(node.left) + count_node(node.right) + 1
        return count_node(root)

非递归写法

class Solution:
    def countNodes(self, root: TreeNode) -> int:
        stack = []
        pre = None 
        cur = root
        while cur or stack:
        	while cur:
        		stack.append(cur)
        		cur = cur.left 
        	cur = stack.pop()
        	while cur and (cur.right is None or cur.right==pre)：
        		pre = cur 
        		# 对cur的处理步骤，
        		if not stack:
        			return
        		cur = stack.pop()
        	stack.append(cur)
        	cur = cur.right

二叉树深度

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        max_depth = 0
        def dfs(node,depth):
            nonlocal max_depth
            if depth > max_depth:
                max_depth = depth
            if node.left:
                dfs(node.left,depth+1)
            if node.right:
                dfs(node.right,depth+1)
        if root:
            dfs(root,1)
        return max_depth

或者使用层次遍历。