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

二叉树

满二叉树

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

完全二叉树

完全二叉树是只有最后一层结点可以不为满,但是最后一层结点都集中在左边,没有空隙。即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
  • 3
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

stark的小笨手2

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值