力扣刷题-二叉树-二叉树的层序遍历（相关题目总结）

思路

层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。这种遍历的方式和我们之前讲过的都不太一样。
需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。
而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。
使用队列实现二叉树广度优先遍历，动画如下：

这样就实现了层序从左到右遍历二叉树。
参考：https://www.programmercarl.com/0102.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E5%B1%82%E5%BA%8F%E9%81%8D%E5%8E%86.html

102 层序遍历

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

利用长度法

# 注意结果的返回形式是每层作为一个列表
# 法一 长度法

from collections import deque
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        # 注意判断是否为空
        if not root:
            return []
        result = [] # 最终结果列表 里面会存储每一层的遍历结果
        queue = deque([root]) # 采用队列来模拟
        while queue: # 当queue为空 终止
            level_result = [] # 每一层结果
            for _ in range(len(queue)): # queue中记录的是每一层进入队列的元素 所以遍历其长度 来获取元素值
                cur = queue.popleft()
                level_result.append(cur.val)
                if cur.left: # 左孩子 就是第二层了
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            result.append(level_result)
        return result

递归法

每次写递归，都按照这三要素来写，可以保证大家写出正确的递归算法！
确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。
确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。
确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

# 法二 递归法
from collections import deque
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Solution(object):
    def levelOrder(self, root):
        if not root:
            return []
        levels = []
        self.helper(root, 0, levels)
        return levels
    
    def helper(self, node, level, levels):
        if not node:
            return
        if len(levels) == level:
            levels.append([]) # 每层开始 用[]初始化
        levels[level].append(node.val)
        self.helper(node.left, level+1, levels)
        self.helper(node.right, level+1, levels)

确定递归函数的参数和返回值：当前节点；第几层，结果存储列表
确定终止条件：当当前节点不存在的时候 直接return（终止本次）
确定单层递归的逻辑：
if len(levels) == level:
levels.append([]) # 每层开始 用[]初始化
levels[level].append(node.val)

107. 二叉树的层序遍历 II

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）
示例 1：
image.png
输入：root = [3,9,20,null,null,15,7]
输出：[[15,7],[9,20],[3]]
其实相当于就是上一题结果做一下翻转。

from collections import deque

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 levelOrderBottom(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []
        result = []
        queue = deque([root])
        while queue:
            level_result = []
            for _ in range(len(queue)):
                cur = queue.popleft()
                level_result.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            result.append(level_result)
        return result[::-1]

199. 二叉树的右视图

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
示例 1:
image.png
输入: [1,2,3,null,5,null,4]
输出: [1,3,4]
思路：其实就是层序遍历每一层遍历结果的最后一个元素

from collections import deque
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 rightSideView(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return []
        levels = []
        self.helper(root, 0, levels)
        result = []
        for item in levels:
            result.append(item[len(item)-1])
        return result

    def helper(self, node, level, levels):
        if not node:
            return 
        if len(levels) == level:
            levels.append([])
        levels[level].append(node.val)
        self.helper(node.left, level+1, levels)
        self.helper(node.right, level+1, levels)

637. 二叉树的层平均值

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。
示例 1：
image.png
输入：root = [3,9,20,null,null,15,7]
输出：[3.00000,14.50000,11.00000]
解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。
因此返回 [3, 14.5, 11]
思路：就是对每一层结果 取平均 注意需要用float！！！


from collections import deque

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 averageOfLevels(self, root):
        """
        :type root: TreeNode
        :rtype: List[float]
        """
        if not root:
            return []
        result = []
        queue = deque([root])
        while queue:
            level_result = []
            for _ in range(len(queue)):
                cur = queue.popleft()
                level_result.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            result.append(level_result)
        final = [(sum(item)/float(len(item))) for item in result] # 注意要加上float 因为python中 / 是整除
        return final

429. N 叉树的层序遍历

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。
树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。
示例 1：
image.png
输入：root = [1,null,3,2,4,null,5,6]
输出：[[1],[3,2,4],[5,6]]
思路：N叉树 每个节点存在多个孩子 所以要采用遍历方式

from collections import deque 

class Node(object):
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children


class Solution(object):
    def levelOrder(self, root):
        """
        :type root: Node
        :rtype: List[List[int]]
        """
        if not root:
            return []
        result = []
        queue = deque([root])
        while queue:
            level_result = []
            for _ in range(len(queue)):
                node = queue.popleft()
                level_result.append(node.val)
                for child in node.children: # 因为有多个孩子 所以采用遍历方式
                    queue.append(child)
            result.append(level_result)
        return result

时间复杂度：O(n)，其中 n 是树中包含的节点个数。在广度优先搜索的过程中，我们需要遍历每一个节点恰好一次。
空间复杂度：O(n)，即为队列需要使用的空间。在最坏的情况下，树只有两层，且最后一层有 n−1 个节点，此时就需要 O(n) 的空间。

515. 在每个树行中找最大值

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。
示例1：
image.png
输入: root = [1,3,2,5,3,null,9]
输出: [1,3,9]

思路：就是求每一层遍历结果的最大值

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 largestValues(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return []
        result = []
        queue = deque([root])
        while queue:
            level_result = []
            for _ in range(len(queue)):
                cur = queue.popleft()
                level_result.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            result.append(level_result)
        final = [max(item) for item in result] # 求最大
        return final

（※）116. 填充每个节点的下一个右侧节点指针

给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：
struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
初始状态下，所有 next 指针都被设置为 NULL。
示例 1：
image.png
输入：root = [1,2,3,4,5,6,7]
输出：[1,#,2,3,#,4,5,6,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，‘#’ 标志着每一层的结束。

# # 注意节点定义
class Node(object):
    def __init__(self, val=0, left=None, right=None, next=None):
        self.val = val
        self.left = left
        self.right = right 
        self.next = next # 多了一个next

from collections import deque

class Solution:
    def connect(self, root):
        if not root:
            return root # 因为最终返回的是整棵树
        # 初始化队列同时将第一层节点加入队列中，即根节点
        Q = collections.deque([root])
        # 外层的 while 循环迭代的是层数
        while Q:
            # 记录当前队列大小
            size = len(Q)
            # 遍历这一层的所有节点
            for i in range(size):
                # 从队首取出元素
                node = Q.popleft()
                # 连接 比较巧妙
                if i < size - 1: # 题目说了 初始状态下 所有的Next指针都设置为 null
                    node.next = Q[0] # 比如2出来 指向队列里面第一个元素 就是3
                # 拓展下一层节点
                if node.left:
                    Q.append(node.left)
                if node.right:
                    Q.append(node.right)
        # 返回根节点
        return root

117 填充每个节点的下一个右侧节点指针 II

给定一个二叉树：
struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL 。
初始状态下，所有 next 指针都被设置为 NULL 。
示例 1：
image.png
输入：root = [1,2,3,4,5,null,7]
输出：[1,#,2,3,#,4,5,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化输出按层序遍历顺序（由 next 指针连接），‘#’ 表示每层的末尾。
思路：其实和上一题是一样，上一题是完美/全二叉树，本题不是，但是是一样的做法。

from collections import deque

class Node(object):
    def __init__(self, val=0, left=None, right=None, next=None):
        self.val = val
        self.left = left
        self.right = right
        self.next = next

class Solution(object):
    def connect(self, root):
        """
        :type root: Node
        :rtype: Node
        """
        if not root:
            return root
        queue = deque([root])
        while queue:
            size = len(queue)
            for i in range(size):
                cur = queue.popleft()
                if i < size - 1:
                    cur.next = queue[0]
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
        return root

104. 二叉树的最大深度

给定一个二叉树 root ，返回其最大深度。
二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。
示例 1：
image.png
输入：root = [3,9,20,null,null,15,7]
输出：3
思路：按照层序遍历 有多少层（最大深度）即 有多少个嵌套列表

层次遍历
from collections import deque

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 maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return 0
        result = []
        queue = deque([root])
        while queue:
            level_result = []
            for _ in range(len(queue)):
                cur = queue.popleft()
                level_result.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            result.append(level_result)
        return len(result) # 里面多少嵌套列表 即为最大深度
递归

递归第一点：参数就是传入树的根节点，返回就返回这棵树的深度，所以返回值为int类型。
递归第二点：如果为空节点的话，就返回0，表示高度为0。
递归第三点：
**先求它的左子树的深度，再求右子树的深度，最后取左右深度最大的数值 再+1 **（加1是因为算上当前中间节点）就是目前节点为根节点的树的深度。（也就是高度）

class solution:
    def maxdepth(self, root: treenode) -> int:
        return self.getdepth(root)
    def getdepth(self, node):
        if not node:
            return 0
        leftdepth = self.getdepth(node.left)
        rightdepth = self.getdepth(node.right)
        depth = max(leftdepth, rightdepth) + 1
        return depth

精简版：

class solution:
    def maxdepth(self, root: treenode) -> int:
        if not root:
            return 0
        return 1 + max(self.maxdepth(root.left), self.maxdepth(root.right))

559. N 叉树的最大深度

层次遍历

给定一个 N 叉树，找到其最大深度。
最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。
N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔（请参见示例）。
示例 1：
image.png
输入：root = [1,null,3,2,4,null,5,6]
输出：3

# Definition for a Node.
class Node(object):
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children


from collections import deque
class Solution(object):
    def maxDepth(self, root):
        """
        :type root: Node
        :rtype: int
        """
        if not root:
            return 0
        result = []
        queue = deque([root])
        while queue:
            level_result = []
            for _ in range(len(queue)):
                cur = queue.popleft()
                level_result.append(cur.val)
                for child in cur.children: # 特别之处
                    queue.append(child)
            result.append(level_result)
        return len(result)
递归
class Solution:
    def maxDepth(self, root: 'Node') -> int:
        if not root:
            return 0
        max_depth = 1
        for child in root.children:
            max_depth = max(max_depth, self.maxDepth(child) + 1)
        
        return max_depth

（※）111. 二叉树的最小深度

给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。
示例 1：
image.png
输入：root = [3,9,20,null,null,15,7]
输出：2

层序遍历法
# 层序遍历法
class Solution(object):
    def minDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return 0
        queue = deque([(root, 1)]) # 每个元素是元组 一个是树元素值 一个是最小深度 比较巧妙

        while queue:
            cur, min_depth = queue.popleft()
            if not cur.left and not cur.right:
                return min_depth
            if cur.left:
                queue.append((cur.left, min_depth+1))
            if cur.right:
                queue.append((cur.right, min_depth+1))
        return 0

时间复杂度：O（N） 因为每个结点会访问一次
空间复杂度：O（N）在层序遍历法中空间复杂度主要取决于队列的开销，队列中的元素个数不会超过树的节点数。

递归法

注意这块和最大深度不一样，如下是错误代码：
image.png
这个代码就犯了此图中的误区：
image.png
如果这么求的话，没有左孩子的分支会算为最短深度。
所以，如果左子树为空，右子树不为空，说明最小深度是 1 + 右子树的深度。
反之，右子树为空，左子树不为空，最小深度是 1 + 左子树的深度。 最后如果左右子树都不为空，返回左右子树深度最小值 + 1 。

# 递归法
class Solution(object):
    def minDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        return self.getDepth(root)
    
    def getDepth(self, node):
        if node is None:
            return 0
        leftDepth = self.getDepth(node.left)  # 左
        rightDepth = self.getDepth(node.right)  # 右
        
        # 当一个左子树为空，右不为空，这时并不是最低点
        if node.left is None and node.right is not None:
            return 1 + rightDepth
        
        # 当一个右子树为空，左不为空，这时并不是最低点
        if node.left is not None and node.right is None:
            return 1 + leftDepth
        
        result = 1 + min(leftDepth, rightDepth)
        return result

时间复杂度：O(N)，其中 N 是树的节点数。对每个节点访问一次。
空间复杂度：O(N)/O(H) 其中 H 是树的高度。空间复杂度主要取决于递归时栈空间的开销，最坏情况下，树呈现链状，空间复杂度为 O(N)。平均情况下树的高度与节点数的对数正相关，空间复杂度为 O(log⁡N)

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/140628.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

超级干货：光纤知识总结最全的文章

超级干货：光纤知识总结最全的文章

你们好&#xff0c;我的网工朋友。 光纤已经是远距离有线信号传输的主要手段&#xff0c;而安装、维护光纤也是很多人网络布线的基本功。 在网络布线中&#xff0c;通常室外楼宇间幢与幢之间使用的是光缆&#xff0c;室内楼宇内部大都使用的是以太网双绞线&#xff0c;也有使用…
阅读更多...
【Git】第二篇：基本操作（创建本地仓库）

【Git】第二篇：基本操作（创建本地仓库）

我们知道&#xff0c;git是一个版本控制器&#xff0c;可以帮我们控制管理电脑上所有格式的文档。 而我们需要使用git管理文件的时候&#xff0c;我们必须将这些文件放到git仓库中&#xff0c;只有在git仓库中的文件才可以被我们的git追踪管理 创建本地仓库 创建本地仓库是需…
阅读更多...
Apache Airflow (五) ：DAG调度触发时间

Apache Airflow (五) ：DAG调度触发时间

&#x1f3e1; 个人主页&#xff1a;IT贫道_大数据OLAP体系技术栈,Apache Doris,Clickhouse 技术-CSDN博客 &#x1f6a9; 私聊博主&#xff1a;加入大数据技术讨论群聊&#xff0c;获取更多大数据资料。 &#x1f514; 博主个人B栈地址&#xff1a;豹哥教你大数据的个人空间-豹…
阅读更多...
教育局档案室智慧档案库房建设方案

教育局档案室智慧档案库房建设方案

教育局档案室智慧档案库房建设是指教育局为了更好地保存和管理学校、教师、学生等相关档案资料&#xff0c;以及保证这些档案资料的安全性、可靠性和完整性&#xff0c;而建设的一个专门的存储、管理和保护档案资料的场所。 专久智能提供的教育局档案库房建设方案从以下几个方面…
阅读更多...
基于蝴蝶算法优化概率神经网络PNN的分类预测 - 附代码

基于蝴蝶算法优化概率神经网络PNN的分类预测 - 附代码

基于蝴蝶算法优化概率神经网络PNN的分类预测 - 附代码 文章目录 基于蝴蝶算法优化概率神经网络PNN的分类预测 - 附代码1.PNN网络概述2.变压器故障诊街系统相关背景2.1 模型建立 3.基于蝴蝶优化的PNN网络5.测试结果6.参考文献7.Matlab代码 摘要&#xff1a;针对PNN神经网络的光滑…
阅读更多...
PCL安装与使用

PCL安装与使用

1 apt安装 ubuntu20.04及以上版本下可以直接通过apt方式安装pcl编译好的二进制文件,二进制安装的版本为1.10。 sudo apt update sudo apt install libpcl-dev 2 源码安装 在pcl的github上下载对应的版本进行安装&#xff1a; https://github.com/PointCloudLibrary/pcl/rel…
阅读更多...
北京刘家窑中医院举行‘心梗救治日’宣传活动，郭自强主任呼吁提高群众防治意识

北京刘家窑中医院举行‘心梗救治日’宣传活动，郭自强主任呼吁提高群众防治意识

阅读更多...
分组取每组数据的最大值和最小值的方法思路，为类似场景的数据分析提取提供思路，例如提取宗地内建筑的最高层数等可参考此方法思路

分组取每组数据的最大值和最小值的方法思路，为类似场景的数据分析提取提供思路，例如提取宗地内建筑的最高层数等可参考此方法思路

目录 一、实现效果 二、实现过程 1.读取并剔除无效数据 2.数据分组 3.提取最大值 4.提取最小值 三、总结 使用FME实现批量分组取每组数据的最大值和最小值&#xff0c;为类似场景的数据分析提取提供思路&#xff0c;例如提取宗地内建筑的最高层数等可参考此方法思路。关…
阅读更多...
酉矩阵（Unitary Matrix）

酉矩阵（Unitary Matrix）

对于n阶复数矩阵A&#xff0c;如果&#xff0c;其中表示矩阵A的共轭转置&#xff0c;为单位矩阵&#xff0c;那么就称A为酉矩阵。 对于酉矩阵&#xff0c; 如果酉矩阵的元素都是实数&#xff0c;那么该矩阵就是正交矩阵。
阅读更多...
74hc165 编程注意事项

74hc165 编程注意事项

74hc165 是一个并行输入转串行输出的io 扩展芯片&#xff0c;支持级联。 74HC165 的工作原理基于移位寄存器的设计。它通过四个输入引脚( SER, SRCLK, RCLK, OE)来实现数据的串行输入、并行输出。在时钟信号的驱动下&#xff0c;数据逐位地从串行输入引脚SER进入寄存器。每次时…
阅读更多...
计算复杂性理论（一）图灵机

计算复杂性理论（一）图灵机

计算复杂性理论&#xff08;一&#xff09;图灵机 一台 k-带图灵机&#xff08;TM&#xff09;M 有 k-条带子。第一条带子称为输入带&#xff0c;用来存放输入数据&#xff0c;输入带是只读带。其余 k−1 条带子是工作带&#xff0c;既可以从工作带上读信息&#xff0c;也可以…
阅读更多...
Hafnium之工程目录结构介绍

Hafnium之工程目录结构介绍

安全之安全(security)博客目录导读 Hafnium存储库包含Hafnium源代码以及与集成测试和单元测试相关的测试代码。为了帮助集成测试，存储库还包含一个用于分区的小型客户端库，以及构建和运行测试所需的预构建工具二进制文件。构建系统由gn支持。 每个平台都有一个单独的…
阅读更多...
如何学习VBA：3.2.7 工作簿的操作引申

如何学习VBA：3.2.7 工作簿的操作引申

我给VBA的定义&#xff1a;VBA是个人小型自动化处理的有效工具。利用好了&#xff0c;可以大大提高自己的劳动效率&#xff0c;而且可以提高数据处理的准确度。我推出的VBA系列教程共九套和一部VBA汉英手册&#xff0c;现在已经全部完成&#xff0c;希望大家利用、学习。 如果…
阅读更多...
【PIE-Engine 数据资源】全球250米LAI产品

【PIE-Engine 数据资源】全球250米LAI产品

文章目录 一、 简介二、描述三、波段四、示例代码参考资料 一、 简介 数据名称全球250米LAI产品时间范围2015年空间范围全球数据来源北京师范大学肖志强教授团队代码片段var images pie.ImageCollection(“BNU/LAI/GLOBAL-250”) 二、描述 全球 250 米叶面指数产品由北京师范…
阅读更多...
mNetAssist网络调试助手编译

mNetAssist网络调试助手编译

1.现在的问题 很多都是用百度网盘下载&#xff0c;访问github才能下载源码。 2.码云下载地址 这个已经是7年前编辑的了&#xff0c;是从github上复制到码云的。 cheni/mNetAssist 3.下载后用QT编译 图示中的两行要注释掉&#xff0c;用//&#xff0c;作者也有备注QT4.8要用…
阅读更多...
Linux网络——自定义协议

Linux网络——自定义协议

目录 一.什么是协议 二.协议与报文 三.自定义协议 1.封装套接字 2.构建请求与响应 3.序列化和反序列化 4.报头添加和去除 5.报文读取 四.服务器端程序 五.客户端程序 一.什么是协议 协议在生活中泛指&#xff1a;双方或多方为了完成某项任务或达成某种目的而制定的共…
阅读更多...
FreeRTOS知识梳理

FreeRTOS知识梳理

一、RTOS:Real time operating system,中文意思为 实时操作系统&#xff0c;它是一类操作系统&#xff0c;比如uc/OS、FreeRTOS、RTX、RT-Thread 这些都是实时操作系统。 二、移植FreeRTOS到STM32F103C8T6上 interface选择CMSIS_V1,RCC选择Crystal Ceramic Resonator 。 …
阅读更多...
Redis应用之一自增编号

Redis应用之一自增编号

一、前言 前段时间同事用Redis实现收银台商品排行榜&#xff0c;我们都知道Redis最基础的功能是用来缓存数据&#xff0c;但其实它还有很多特性能解决很多实际问题&#xff0c;接下来几篇文章我们就聊聊Reids一些特性的应用&#xff0c;今天先聊一下借助Reids生成不会重复的订…
阅读更多...
智能优化算法（一）：伪随机数的产生

智能优化算法（一）：伪随机数的产生

文章目录 1.伪随机数介绍1.1.伪随机产生的意义1.2.伪随机产生的过程 2.产生U(0,1)的乘除同余法2.1.原始的乘同余法2.2.改进的乘同余法 3.产生正态分布的伪随机数4.基于逆变法产生伪随机数 1.伪随机数介绍 1.1.伪随机产生的意义 1.随机数的产生是进行随机优化的第一步也是最重要…
阅读更多...
C++ final

C++ final

参考:https://blog.csdn.net/qq_45358642/article/details/124232686#t2 不想让类继承 方式一&#xff1a;将类的构造函数设置为私有 子类不能调用父类构造函数初始化来实例化对象&#xff0c;所以不能继承 缺点&#xff1a;我们自己也不能够实例化出对象 class A { privat…
阅读更多...
最新文章

Copyright @ 2022~2023