代码随想录算法训练营day14| 递归遍历、迭代遍历、统一迭代

144、二叉树的前序遍历：

递归遍历：

class Solution(object):
    def traversal(self, tree_node, array):
        if not tree_node:
            return
        array.append(tree_node.val)
        self.traversal(tree_node.left, array)
        self.traversal(tree_node.right, array)

    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        list = []
        self.traversal(root, list)
        return list

迭代遍历：

class Solution(object):
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        stack = []
        res = []
        if not root:
            return res
        stack.append(root)
        while stack:
            tree_node = stack[-1]
            stack.pop()
            if tree_node:
                res.append(tree_node.val)
            else:
                continue
            stack.append(tree_node.right)
            stack.append(tree_node.left)
        return res

统一迭代：

class Solution(object):
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        stack = []
        res = []
        if not root:
            return res
        stack.append(root)
        while stack:
            tree_node = stack[-1]
            if tree_node:  # 如果栈顶元素不为空，继续遍历节点加入栈
                stack.pop()
                if tree_node.right:
                    stack.append(tree_node.right)
                if tree_node.left:
                    stack.append(tree_node.left)
                stack.append(tree_node)
                stack.append(None)
            else:  # 如果栈顶元素为空，处理下一个元素加入数组
                stack.pop()
                res.append(stack.pop().val)
        return res

145、二叉树的后序遍历：

递归遍历

class Solution(object):
    def traversal(self, tree_node, array):
        if not tree_node:
            return
        self.traversal(tree_node.left, array)
        self.traversal(tree_node.right, array)
        array.append(tree_node.val)

    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        res = []
        self.traversal(root, res)
        return res

迭代遍历：

class Solution(object):
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        stack = []
        res = []
        if not root:
            return res
        stack.append(root)
        while stack:
            tree_node = stack[-1]
            stack.pop()
            res.append(tree_node.val)
            if tree_node.left:
                stack.append(tree_node.left)
            if tree_node.right:
                stack.append(tree_node.right)
        return res[::-1]

统一迭代：

class Solution(object):
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        stack = []
        res = []
        if not root:
            return res
        stack.append(root)
        while stack:
            tree_node = stack[-1]
            if tree_node:
                stack.pop()
                stack.append(tree_node)
                stack.append(None)
                if tree_node.right:
                    stack.append(tree_node.right)
                if tree_node.left:
                    stack.append(tree_node.left)
            else:
                stack.pop()
                res.append(stack.pop().val)
        return res

94、二叉树的中序遍历

递归遍历：

class Solution(object):
    def traversal(self, tree_node, array):
        if not tree_node:
            return
        self.traversal(tree_node.left, array)
        array.append(tree_node.val)
        self.traversal(tree_node.right, array)
        
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        res = []
        self.traversal(root, res)
        return res

迭代遍历：

class Solution(object):
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        res = []
        nodes = []
        cur = root  # 初始化链表头结点
        while cur or nodes:
            if cur:  # 访问节点
                nodes.append(cur)
                cur = cur.left
            else:  # 处理节点
                cur = nodes.pop()
                res.append(cur.val)
                cur = cur.right
        return res

统一迭代：

class Solution(object):
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        res = []
        nodes = []
        if not root:
            return res
        nodes.append(root)
        while nodes:
            tree_node = nodes[-1]
            if tree_node:  # 如果栈顶节点不为空，继续遍历节点加入栈
                nodes.pop()
                if tree_node.right:
                    nodes.append(tree_node.right)
                nodes.append(tree_node)
                nodes.append(None)
                if tree_node.left:
                    nodes.append(tree_node.left)
            else:  # 如果栈顶节点为空，处理下一个元素加入数组
                nodes.pop()
                node = nodes.pop()
                res.append(node.val)
        return res

二叉树的种类：

分为满二叉树（所有节点的数量为层数k的2^k-1个）、完全二叉树（所有叶子节点均在最底层且从左到右为连续分布的）、二叉搜索树（有序的二叉树，其上所有节点的左子树上节点均小于该节点的值，右子树上节点均大于该节点的值，搜索节点时间复杂度为O(logK)）、平衡二叉搜索树（左子树和右子树的高度差绝对值不大于1，又称AVL树）

二叉树的存储方式：

分为链式存储(通过左右指针分别指向左右子树进行链接)和顺序存储(地址连续分布，较少用)

二叉树的定义：

初始化二叉树需定义根节点的值和左右指针

二叉树的遍历方式：

深度优先搜索（递归法和迭代法）和广度优先搜索（层序遍历）

重点学习了递归法和迭代法，因为深度优先搜索是一条道走到黑，非常适用于栈这种数据结构，因此用递归的思想很容易可以推导出来；迭代遍历法前、后序遍历的遍历节点和处理节点是同步的，而中序节点不是同步的，需要分开处理，因此无法用统一风格的代码；统一迭代法则为了统一遍历节点和处理节点，专门在需要处理的节点上做了标记，引入None节点，因此也称为“标记法”