day13

sjtu_cjs

已于 2024-07-23 23:23:09 修改

阅读量238

点赞数 4

分类专栏： Leetcode刷题日记文章标签： python leetcode

于 2024-07-08 13:40:16 首次发布

本文链接：https://blog.csdn.net/xmu_cjs/article/details/140260771

版权

Leetcode刷题日记专栏收录该内容

41 篇文章 0 订阅

订阅专栏

二叉树

满二叉树

在这里插入图片描述
一颗二叉树只有度为0和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树

完全二叉树

在这里插入图片描述
完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层（h从1开始），则该层包含 1~ 2^(h-1) 个节点。

二叉搜索树

若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
它的左、右子树也分别为二叉排序树
在这里插入图片描述
也就是说，二叉搜索树是有序的

平衡二叉搜索树

在这里插入图片描述
平衡二叉搜索树：又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

二叉树的存储方式

二叉树可以顺序存储(数组)，也可以链式存储（指针）。
在这里插入图片描述

二叉树的遍历方式

广度优先遍历

层次遍历（迭代法）

深度优先遍历

在这里插入图片描述

二叉树结点定义(python)

class TreeNode:
	def __init__(self,val,left=None,right=None):
		self.val = val
		self.left = left
		self.right = right

递归函数的写法：

1、确定递归函数的参数和返回值：确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数，并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。
2、确定终止条件：写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。

3、确定单层递归的逻辑：确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

144 二叉树的前序遍历

给你二叉树的根节点 root ，返回它节点值的前序遍历。

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]
        """
        res = []
        def dfs(node):
            if node is None:
                return
            res.append(node.val)
            dfs(node.left)
            dfs(node.right)
        dfs(root)
        return res

总结：主要就是递归的写法，其次弄清楚前序遍历的思路

145 二叉树的后序遍历

记住后序遍历是：左右中

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]
        """
        res = []
        def dfs(node):
            if node is None:
                return
            dfs(node.left)
            dfs(node.right)
            res.append(node.val)
        dfs(root)
        return res

94 二叉树的中序遍历

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]
        """
        res = []
        def dfs(node):
            if node is None:
                return
            dfs(node.left)
            res.append(node.val)
            dfs(node.right)
        dfs(root)
        return res

层序遍历

102 二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的层序遍历。（即逐层地，从左到右访问所有节点）。

class TreeNode(object):
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
import collections
class Solution(object):
    def levelOrder(self, root):

        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if root == None:
            return []
        queue =  collections.deque([root])  #把root的结点放入queue中
        result = []
        while queue:#对于queue中存在的元素
            level = []  #创建一个空列表Level用于存储当前层的节点值

            for _ in range(len(queue)):#对于queue中已经存在的元素
                cur  = queue.popleft()#队列左边的元素弹出
                level.append(cur.val)#存储当前层的结点值
                if cur.left:#如果当前元素存在左孩子和右孩子，加入到队列中
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)

            result.append(level)
        return result

主要思路：
现用一个collections.deque()双向队列，逐层遍历，现将root放进queue中，然后如果root有左右孩子，将root弹出后，将左右孩子放入queue中，过程中将弹出的元素放进list中进行存储

107 二叉树的层序遍历2

给你二叉树的根节点 root ，返回其节点值自底向上的层序遍历。（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

class Solution(object):
    def levelOrderBottom(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if root == None:
            return []
        queue = collections.deque([root])
        result = []

        while queue:
            level = []
            for _ in range(len(queue)):
                cur = queue.popleft()
                level.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            result.append(level)
        return result[::-1]

与102的差距在于最后输出的时候result倒过来即可，因为result直接放入的是level这个list

199 二叉树的右视图

在这里插入图片描述
给定一个二叉树的根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

import collections
class Solution(object):
    def rightSideView(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        result = []
        if root == None:
            return []
        queue = collections.deque([root])
        while queue:
            level_size = len(queue)

            for i in range(len(queue)):
                node = queue.popleft()
                if i == level_size - 1:
                    result.append(node.val)

                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        
        return result

谈一谈对层序遍历的看法：
从代码中的
while queue:
这一行代码表示遍历二叉树中的某一层，queue中的每个元素都是叉树中的这一层的元素，用node = queue.popleft(),将元素弹出并且进行处理，
然后for i in range(len(queue)):表示遍历这一层中的全部元素。然后在这个循环中，再将这些元素的左右孩子加入到queue中，

637 二叉树的层平均值

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

import collections
class Solution(object):
    def averageOfLevels(self, root):
        """
        :type root: TreeNode
        :rtype: List[float]
        """
        
        if root == None:
            return []
        queue = collections.deque([root])
        result = []
        while queue:
            size = len(queue)
            level_sum = 0.0 
            for i in range(size):
                node = queue.popleft()
                level_sum += node.val
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            result.append(level_sum / size)
        return result

429 N叉树的层序遍历

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。

树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

import collections
class Solution(object):
    def levelOrder(self, root):
        """
        :type root: Node
        :rtype: List[List[int]]
        """
        if not root:
            return []
        result = []
        queue = collections.deque([root])

        while queue:
            level_size = len(queue)
            level = []
            
            for _ in range(level_size):
                node = queue.popleft()
                level.append(node.val)
                
                for child in node.children:
                    queue.append(child)
            result.append(level)
        return result```

总结：本题更难得地方可能在于不知道如何处理child部分

##515 再每个树行中找最大值
给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

```python
import collections
class Solution(object):
    def largestValues(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        result = []
        queue = collections.deque([root])
        if root == None:
            return []
        
        while queue:
            size = len(queue)
            max = float('-inf')
            for i in range(size):
                node = queue.popleft() 
                if max < node.val:
                    max,node.val = node.val,max
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            result.append(max)
        return result

116 填充每个结点的下一个右侧节点指针

给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

import collections
class Solution(object):
    def connect(self, root):
        """
        :type root: Node
        :rtype: Node
        """
        if not root:
            return root
        
        queue = collections.deque([root])
        while queue:
            level_size  = len(queue)
            prev = None

            for i in range(level_size):
                node = queue.popleft()

                if prev:
                    prev.next = node

                prev = node
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return root