【代码随想录算法训练营第十三天|144. 二叉树的前序遍历、94. 二叉树的中序遍历、145. 二叉树的后序遍历】

二叉树

满二叉树

满二叉树是当二叉树有k层的时候，每层结点都是满的，即刚好有$2^k-1$个结点，或者说除了最后一层的结点没有子结点，所有结点都有左右子结点。

完全二叉树

完全二叉树是只有最后一层结点可以不为满，但是最后一层结点都集中在左边，没有空隙。即k-1层的结点的子结点如果有右节点必须有左节点，并且前一个结点有左右结点。

二叉搜索树

二叉搜索数是有序的，在二叉搜索树里，左子树的值都必须小于根节点，右子树的值都必须大于根节点，并且子树里也满足这个要求。

平衡二叉搜索树

平衡二叉搜索树是在二叉搜索树的基础上，并且根节点左右子树的高度差绝对值不大于1。

二叉树递归遍历

二叉树前序、中序、后序遍历中这个前中后指的是中间结点所处的顺序，即中左右、左中右、左右中。

前序遍历

迭代的方法都差不多，顺序变一下就行了

class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ans = []
        def pTraversal(root):
            if root:
                ans.append(root.val)
                pTraversal(root.left)
                pTraversal(root.right)
        pTraversal(root)
        return ans

中序遍历

class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ans = []
        def iTraversal(root):
            if root:
                iTraversal(root.left)
                ans.append(root.val)
                iTraversal(root.right)
        iTraversal(root)
        return ans

后序遍历

class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ans = []
        def pTraversal(root):
            if root:
                pTraversal(root.left)
                pTraversal(root.right)
                ans.append(root.val)
        pTraversal(root)
        return ans

二叉树的迭代遍历

迭代前序遍历

和递归的方式基本相同，多一个栈来存放根节点，然后按右左子结点的顺序依次把非空结点入栈，再反向输出。

class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if root == None:
            return []
        ans = []
        stack = [root]
        while stack:
            top = stack.pop()
            ans.append(top.val)
            if top.right:
                stack.append(top.right)
            if top.left:
                stack.append(top.left)
        return ans

迭代中序遍历

因为中序遍历的时候，访问的结点不是第一个需要处理的结点，所以需要一个栈用来保存中间结点，一个指针来指向当前访问的结点。当当前访问的结点不为None的时候，将结点入栈，然后指向当前结点的左结点，如果为None，则把栈顶结点出栈，将其元素添加到输出列表中，然后再让指向当前结点的右节点。

class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if root == None:
            return []
        ans = []
        stack = []
        cur = root
        while cur != None or stack:
            if cur:
                stack.append(cur)
                cur = cur.left
            else:
                cur = stack.pop()
                ans.append(cur.val)
                cur = cur.right
        return ans

迭代后序遍历

后序遍历是左右中，在前序遍历中左右的基础上，把左右结点入栈的顺序调换就是中右左，再把输出反转就是左右中了。

class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if root == None:
            return []
        ans = []
        stack = [root] 
        while stack:
            cur = stack.pop()
            ans.append(cur.val)
            if cur.left:
                stack.append(cur.left)
            if cur.right:
                stack.append(cur.right)
        return ans[::-1]

统一迭代遍历法

这种统一的方法是对已经访问过，但是还没被处理的结点后面加上一个None标记。

统一迭代前序遍历

入栈顺序为右左中

class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if root == None:
            return []
        ans = []
        stack = [root]
        while stack:
            cur = stack.pop()
            if cur:
                if cur.right:
                    stack.append(cur.right)
                if cur.left:
                    stack.append(cur.left)
                stack.append(cur)
                stack.append(None)
            else:
                cur = stack.pop()
                ans.append(cur.val)
        return ans

统一迭代中序遍历

入栈顺序为右中左

class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if root == None:
            return []
        ans = []
        stack = [root]
        while stack:
            cur = stack.pop()
            if cur:
                if cur.right:
                    stack.append(cur.right)
                stack.append(cur)
                stack.append(None)
                if cur.left:
                    stack.append(cur.left)
            else:
                cur = stack.pop()
                ans.append(cur.val)
        return ans

统一后序迭代遍历

class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if root == None:
            return []
        ans = []
        stack = [root] 
        while stack:
            cur = stack.pop()
            if cur:
                stack.append(cur)
                stack.append(None)
                if cur.right:
                    stack.append(cur.right)
                if cur.left:
                    stack.append(cur.left)
            else:
                cur = stack.pop()
                ans.append(cur.val)
        return ans