代码随想录第十四天：递归遍历、迭代遍历

二叉树理论基础：代码随想录

题目：二叉树的前序遍历、中序遍历、后序遍历

递归遍历 代码随想录

1.前序遍历

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:   # 递归结束的条件，当前节点为空
            return []
        else:
            left = self.preorderTraversal(root.left)
            right = self.preorderTraversal(root.right)
        return [root.val]+left+right

2.中序遍历

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return []
        else:
            left = self.inorderTraversal(root.left)
            right = self.inorderTraversal(root.right)
        return left + [root.val] + right

3.后序遍历

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return []
        else:
            left = self.postorderTraversal(root.left)
            right = self.postorderTraversal(root.right)
        return left + right + [root.val]

中序遍历和后序遍历就是把相应的节点顺序换一下就好了。

感觉递归还是要多写写找感觉

迭代遍历 代码随想录

1.前序遍历

用一个栈来模拟递归过程

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root: 
            return []
        stack = [root]
        res = []
        while stack:
            n = stack.pop()
            res.append(n.val)
            if n.right:  # 先加入右孩子，这样出栈时才是左孩子先出栈
                stack.append(n.right)
            if n.left: 
                stack.append(n.left)
        return res

2.后序遍历

后序遍历可以直接根据前序遍历交换位置，前序遍历的顺序是中左右，将左右孩子的添加顺序交换得到中右左，最后反转结果数组得到左右中：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return []
        stack = [root]
        res = []
        while stack:
            node = stack.pop()
            res.append(node.val)
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
        return res[::-1]

3.中序遍历

中序遍历和其他两个不同，中序遍历对元素的操作和访问不同步，所以要用一个指针cur，来访问节点，而栈用来操作节点。

写的时候举一个例子按顺序走一遍会好很多，但是不要想着“万一下面还有一个孩子该怎么办”，容易把自己绕进去。。。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return []
        stack = []
        res = []
        cur = root
        while stack or cur:  # 当栈和指针都为空时循环结束
            if cur != None:  # cur不为空就添加进栈，并访问左孩子，一路向左
                stack.append(cur)
                cur = cur.left
            else:
                cur = stack.pop()  # cur为空，此时左侧已经处理完，则处理中间节点，再访问右孩子
                res.append(cur.val)
                cur = cur.right
        return res

统一迭代暂时不看了。