代码随想录算法训练营第十四天

代码随想录算法训练营第十四天|二叉树的递归遍历,二叉树的迭代遍历

  • 二叉树基础
    • 二叉树的种类
    • 二叉树的存储
    • 二叉树的遍历
  • 二叉树的递归遍历
    • 144.二叉树的前序遍历(递归)
    • 145.二叉树的后序遍历(递归)
    • 94.二叉树的中序遍历(递归)
  • 二叉树的迭代遍历
    • 144.二叉树的前序遍历(迭代)
    • 145.二叉树的后序遍历(迭代)
      • 反转
    • 94.二叉树的中序遍历(迭代)

二叉树基础

基础视频

二叉树的种类

  1. 满二叉树,满节点,个数是2k-1(k为深度);
  2. 完全二叉树,除了底层之外都是满的,底层不一定满但是从左到右是连续的,堆就是一个完全二叉树;
  3. 二叉搜索树,节点有顺序便于搜索,搜索一个节点的时间复杂度O(logn),左子树的所有节点都小于中间节点,右子树的所有节点都大于中间节点,但对树的结构没什么要求,就算没有左(右)子树的也叫二叉搜索树;
  4. 平衡二叉搜索树,左子树和右子树的高度绝对值不能超过1,往里插入节点,查询某个元素都是O(logn),(map和set的底层逻辑就是平衡二叉树,所以是有序的)

二叉树的存储

  1. 链式存储,用指针连接左右孩子
class TreeNode:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None
  1. 线性存储,用一个数组来存储,下标i的节点,对应的左右孩子的位置,
    左孩子:2i+1,右孩子:2i+2
    图片:代码随想录算法训练营第十四天_第1张图片

二叉树的遍历

  1. 深度优先搜索(dfs):递归的方式,会用栈来实现,一条路跑到底,然后再换方向。
    前序(中左右),中序(左中右),后序(左右中 )遍历,也会用迭代法(非递归)

  2. 广度优先搜索(bfs):一层一层的遍历,层序遍历,用队列来实现

二叉树的递归遍历

参考视频

  1. 确定递归函数的参数和返回值
  2. 确定终止条件
  3. 确定单层递归的逻辑

真的是一些写一次忘一次的代码

144.二叉树的前序遍历(递归)

# 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]
        """
        def pre(root):
            if root == None:
                return
        
            l.append(root.val)
            pre(root.left)
            pre(root.right)
        l = []
        pre(root)
        return l

145.二叉树的后序遍历(递归)

class Solution(object):
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        def pre(root):
            if root == None:
                return
            pre(root.left)
            pre(root.right)
            res.append(root.val)
        
        res = []
        pre(root)
        return res

94.二叉树的中序遍历(递归)

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

二叉树的迭代遍历

用栈的方式来解决遍历问题

144.二叉树的前序遍历(迭代)

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if root == None:
            return []
        res = []
        queue = []
        queue.append(root)
        while queue:
            cur = queue.pop()
            res.append(cur.val)
            if cur.right:
                queue.append(cur.right)
            if cur.left:
                queue.append(cur.left)
        return res
            

145.二叉树的后序遍历(迭代)

反转

一种办法是把前序里的,左右入栈顺序颠倒可以得到中右左,然后反转整个结果,就可以得到左右中

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

94.二叉树的中序遍历(迭代)

进栈和出栈:
代码随想录算法训练营第十四天_第2张图片

  1. 先一路向左,栈:1,4,3;输出:
  2. 从栈里拿出3,把3放进输出,再看3有没有右孩子,栈:1,4;输出:3
  3. 从栈里拿出4,把4放进输出,4有右孩子,入栈,栈:1,5;输出:3,4
  4. 从5开始一路向左,1入栈,栈:1,5,1;输出:3,4
  5. 从栈里拿出1,把1放进输出,1没有右孩子,栈:1,5;输出:3,4,1
  6. 从栈里拿出5,把5放进输出,1没有右孩子,栈:1;输出:3,4,1,5
  7. 从栈里拿出1,把1放进输出,1有右孩子,入栈,栈:2;输出:3,4,1,5,1
  8. 从栈里拿出2,把2放进输出,2有右孩子,入栈,栈:2;输出:3,4,1,5,1,2
  9. 从栈里拿出2,把2放进输出,2没有右孩子,输出:3,4,1,5,1,2,2
class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if root == None:
            return []
        
        res = []
        queue = []
        queue.append(root)
        cur = root

        while queue:
            while cur.left:
                cur = cur.left
                queue.append(cur)
            
            cur1 = queue.pop()
            res.append(cur1.val)
            if cur1.right:
                cur = cur1.right
                queue.append(cur)
            
        return res

            

                

你可能感兴趣的:(刷题日常,算法,leetcode,数据结构,python)