二叉树的遍历(递归与非递归)

前序遍历

递归解法

# 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 preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        # 递归
        if not root:
            return []
        
        res = []
        res.append(root.val)
        
        left = self.preorderTraversal(root.left)
        right = self.preorderTraversal(root.right)
        
        return res + left + right

非递归解法

# 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 preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
		# 非递归解法
		if not root:
			retrun None
		
		stack = []
		res = []
		
		while root or stack:
			while root:
				# 从根节点开始，一直找它的左子树
				stack.append(root)
				res.append(root.val)
				root = root.left
			
			# while结束表示当前节点node为空，即前一个节点没有左子树了
			root = stack.pop()
			# 开始查看它的右子树
			root = root.right
		
		retrun 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 inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
		# 递归
		if not root:
			return []
		
		res = []
		res.append(root.val)
		
		left = self.inorderTraversal(root.left)
		right = self.inorderTraversal(root.right)
		
		return left + res + right

非递归解法

# 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 inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        
        # 非递归
        if not root:
        	retrun None
        	
        stack = []
        res = []
        
        while root or stack:
        	while root:
        		satck.append(root)
        		root = root.left
        	
        	res.append(stack.pop().val)
        	root = root.right
        
        retrun 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 postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        # 递归
        if not root:
            return []
        
        res = []
        res.append(root.val)
        
        left = self.postorderTraversal(root.left)
        right = self.postorderTraversal(root.right)
        
        return left + right + 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 postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        # 非递归
        if not root:
            return 
        stack_1 = []
        stack_2 = []
        
        res = []
        
        stack_1.append(root)
        while stack_1:
            root = stack_1.pop()
            
            if root.left:
                stack_1.append(root.left)
            if root.right:
                stack_1.append(root.right)
            
            stack_2.append(root.val)
            
        while stack_2:
            res.append(stack_2.pop())
            
        return res

层序遍历

给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。

例如:
给定二叉树: [3,9,20,null,null,15,7]

返回其层次遍历结果：

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

# 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):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []
        
        stack1 = []
        layer_list = []
        res = []
        
        stack1 = [root]
        
        layer_size = 1
        while stack1:
            root = stack1.pop(0)
            
            layer_list.append(root.val)  # 当前层的结点的list
            
            layer_size = layer_size - 1  # 当前层每出栈一个结点,layer_size-1

            if root.left:
                stack1.append(root.left)
            if root.right:
                stack1.append(root.right)
            
            # 当前层layer_size == 0 时，表示当前层已记录完
            if layer_size == 0:
                layer_size = len(stack1)  # 每一层的长度
                res.append(layer_list)
                
                layer_list = []
                
        return res