代码随想录算法训练营第12天 | Python | 二叉树的前序遍历、中序遍历、后序遍历、层序遍历

最新推荐文章于 2024-10-16 19:08:56 发布
最新推荐文章于 2024-10-16 19:08:56 发布
阅读量704 收藏 11
点赞数 20
文章标签： 算法 python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45724176/article/details/141067882
版权

二叉树理论基础

链接：https://programmercarl.com/%E4%BA%8C%E5%8F%89%E6%A0%91%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html

种类

  1. 满二叉树：满二叉树：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。请添加图片描述
  2. 完全二叉树：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。
    请添加图片描述
  3. 二叉搜索树：有序数，左孩子<根节点<右孩子
    请添加图片描述
  4. 平衡二叉搜索树/AVL（Adelson-Velsky and Landis）树：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。请添加图片描述

遍历方式

  1. 深度优先遍历

前序遍历：中左右

在每个节点前面画点，先碰到点的数字先输出

请添加图片描述
中序遍历：左中右

在每个节点底下画点，先碰到点的数字先输出
请添加图片描述
后序遍历：左右中

在每个节点后面画点，先碰到点的数字先输出
请添加图片描述
2. 广度优先遍历

层序遍历：一层一层输出

5, 4, 6, 1, 2, 7, 8

定义

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

二叉树的递归遍历

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

LeetCode 94. 二叉树的中序遍历

# 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 inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        res = []
        def dfs(root):
            if root:
                dfs(root.left)
                res.append(root.val)
                dfs(root.right)
        dfs(root)
        return res

LeetCode 145. 二叉树的后序遍历

# 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 postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        res = []
        def dfs(root):
            if root:
                dfs(root.left)
                dfs(root.right)
                res.append(root.val)
        dfs(root)
        return res

二叉树的迭代遍历

使用栈结构：深度遍历需要先按一个方向遍历到底，其他方向的信息暂时压入栈，之后再取出。

不可以用队列：不满足其他方向信息暂存，因为先压入的信息一定会先出。

LeetCode 144. 二叉树的前序遍历

前序遍历：中左右

把右孩子压入栈 -> 左孩子压入栈（这样可以先出左孩子，再出右孩子） -> 出栈记录val

# 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]
        """
        if not root:
            return 
        stack = [root]
        res = []
        while stack:
            node = stack.pop()
            res.append(node.val)
            if node.right:
                stack.append(node.right)
            if node.left:
                stack.append(node.left)
        return res

LeetCode 94. 二叉树的中序遍历

中序遍历：左中右

【比较难】

把自己和左孩子压入栈 -> 直到没有左孩子，开始pop，并压入右孩子

# 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 inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return
        stack = []
        res = []
        node = root
        while stack or node:
            while node:
                stack.append(node)
                node = node.left
            node = stack.pop()
            res.append(node.val)
            node = node.right
        return res

LeetCode 145. 二叉树的后序遍历

在这里插入图片描述
[1,2,4,6,5] -> [1,2,4,6,5] -> [5,6,4,2,1]

前序遍历先压入左孩子，后压入右孩子 -> res[::-1]

# 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 postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return
        stack = [root]
        res = []
        while stack:
            node = stack.pop()
            res.append(node.val)
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
        return res[::-1]

二叉树的统一迭代遍历

在压入自己时加入标记符null，遇到null则直接输出自己

LeetCode 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]
        """
        if not root:
            return
        stack = [root]
        res = []
        while stack:
            node = stack.pop()
            if not node:
                node = stack.pop()
                res.append(node.val)
            elif node.left or node.right:
                if node.right:
                    stack.append(node.right)
                if node.left:
                    stack.append(node.left)
                stack.append(node)
                stack.append(None)
            else:
                res.append(node.val)
        return res

LeetCode 94. 二叉树的中序遍历

中序遍历：左中右
压入顺序：右中左

# 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 inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return
        stack = [root]
        res = []
        while stack:
            node = stack.pop()
            if not node:
                node = stack.pop()
                res.append(node.val)
            elif node.left or node.right:
                if node.right:
                    stack.append(node.right)
                stack.append(node)
                stack.append(None)
                if node.left:
                    stack.append(node.left)
            else:
                res.append(node.val)
        return res

LeetCode 145. 二叉树的后序遍历

后序遍历：左右中
压入顺序：中右左

# 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 postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return
        stack = [root]
        res = []
        while stack:
            node = stack.pop()
            if not node:
                node = stack.pop()
                res.append(node.val)
            elif node.left or node.right:
                stack.append(node)
                stack.append(None)
                if node.right:
                    stack.append(node.right)
                if node.left:
                    stack.append(node.left)
            else:
                res.append(node.val)
        return res

二叉树的层序遍历

LeetCode 102. 二叉树的层序遍历

用队列结构保存信息。

利用队列长度区分不同层：

# 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 levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return 
        queue = collections.deque()
        queue.append(root)
        res = []
        while queue:
            level = []
            for _ in range(len(queue)):
                node = queue.popleft()
                level.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            res.append(level)
        return res

迭代法，核心就是按顺序扩充每层：

def traverse(node, level):
	res[level].append(node.val)
	traverse(node.left, level + 1)
	traverse(node.right, level + 1)

再加上一些辅助条件，保证程序顺利运行：

# 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 levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return
        res = []

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

        traverse(root, 0)
        return res

LeetCode 107. 二叉树的层序遍历 II

把res反转即可

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

LeetCode 199. 二叉树的右视图

只保留每层的最后一个数

# 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 rightSideView(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return
        queue = collections.deque()
        queue.append(root)
        right_view = []
        while queue:
            queue_len = len(queue)
            for i in range(queue_len):
                node = queue.popleft()
                if i == queue_len-1:
                    right_view.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return right_view

LeetCode 637. 二叉树的层平均值

每层求平均，注意level要写成0.0，默认float

# 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 averageOfLevels(self, root):
        """
        :type root: TreeNode
        :rtype: List[float]
        """
        if not root:
            return 
        queue = collections.deque()
        queue.append(root)
        res = []
        while queue:
            level = 0.0
            queue_len = len(queue)
            for _ in range(queue_len):
                node = queue.popleft()
                level += node.val
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            res.append(level/queue_len)
        return res

LeetCode 429. N 叉树的层序遍历

把孩子依次存入队列

"""
# Definition for a Node.
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 
        queue = collections.deque()
        queue.append(root)
        res = []
        while queue:
            level = []
            for _ in range(len(queue)):
                node = queue.popleft()
                level.append(node.val)
                for children in node.children:
                    queue.append(children)
            res.append(level)
        return res

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

# 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 largestValues(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return 
        queue = collections.deque()
        queue.append(root)
        res = []
        while queue:
            max_num = float('-inf')
            for _ in range(len(queue)):
                node = queue.popleft()
                max_num = max(max_num, node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            res.append(max_num)
        return res

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

"""
# Definition for a Node.
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 
        queue = collections.deque()
        queue.append(root)
        while queue:
            cur = None
            queue_len = len(queue)
            for i in range(queue_len):
                node = queue.popleft()
                if cur:
                    cur.next = node
                cur = node
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return root

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

"""
# Definition for a Node.
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 
        queue = collections.deque()
        queue.append(root)
        while queue:
            cur = None
            queue_len = len(queue)
            for i in range(queue_len):
                node = queue.popleft()
                if cur:
                    cur.next = node
                cur = node
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return root

LeetCode 104. 二叉树的最大深度

# 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 maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return 0
        queue = collections.deque()
        queue.append(root)
        depth = 0
        while queue:
            for _ in range(len(queue)):
                node = queue.popleft()
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            depth += 1
        return depth

LeetCode 111. 二叉树的最小深度

当左右孩子都为空时，说明遍历到最低点了

# 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 minDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return 0
        queue = collections.deque()
        queue.append(root)
        depth = 0
        while queue:
            depth += 1
            for _ in range(len(queue)):
                node = queue.popleft()
                if not node.left and not node.right:
                    return depth
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            
        return depth
genestar
关注
代码随想录算法训练营第十三天|144. 二叉树的前序遍历、145.二叉树的后序遍历、94.二叉树的中序遍历、102.二叉树的层序遍历
qq_43487696的博客
08-26 288
【代码】代码随想录算法训练营第十三天|144. 二叉树的前序遍历、145.二叉树的后序遍历、94.二叉树的中序遍历。
代码随想录算法训练营第十四天｜144.二叉树的前序遍历、145.二叉树的后序遍历、94.二叉树的中序遍历
biuhuiui的博客
03-05 406
二叉树是一种层次结构的。
【代码随想录算法训练营第十三天|144. 二叉树的前序遍历、94. 二叉树的中序遍历、145. 二叉树的后序遍历】
weixin_46281930的博客
05-21 306
因为中序遍历的时候，访问的结点不是第一个需要处理的结点，所以需要一个栈用来保存中间结点，一个指针来指向当前访问的结点。当当前访问的结点不为None的时候，将结点入栈，然后指向当前结点的左结点，如果为None，则把栈顶结点出栈，将其元素添加到输出列表中，然后再让指向当前结点的右节点。二叉搜索数是有序的，在二叉搜索树里，左子树的值都必须小于根节点，右子树的值都必须小于根节点，并且子树里也满足这个要求。后序遍历是左右中，在前序遍历中左右的基础上，把左右结点入栈的顺序调换就是中右左，再把输出反转就是左右中了。
代码随想录算法训练营Day13 | 二叉树理论基础 二叉树的递归遍历 前序、中序、后序遍历 102.二叉树的层序遍历
weixin_65053787的博客
07-18 1847
① 满二叉树：顾名思义就是结点都满的二叉树。定义：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。 深度为k，结点数为2^k-1的二叉树② 完全二叉树：最后一层可以不满，但最后一层从左到右结点连续。 定义：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层（h从1开始），则该层包含 1~ 2^(h-1) 个节点。 ③ 二叉搜索树：有数值的有序树
代码随想录算法训练营第十三天| 144. 二叉树的前序遍历、94. 二叉树的中序遍历、145. 二叉树的后序遍历
alimamaalala的博客
10-05 111
对于二叉树，其前中后遍历均可采用递归遍历与迭代遍历，递归很好理解，函数规定以列表的形式返回节点的值，所以我们规定边界条件，即无节点时返回[]，随后讨论左孩子情况与右孩子情况。对于树来说，只要是用迭代法就要想着使用stack来存每一层的节点了。同前序遍历，只不过是前中的进入位置要进行修改。LeetCode 144. 二叉树的前序遍历。LeetCode 145. 二叉树的后序遍历。LeetCode 94. 二叉树的中序遍历。注意判断一下操作符，讨论一下各种情况，
代码随想录算法训练营第十四天| LeetCode144. 二叉树的前序遍历、LeetCode145. 二叉树的后序遍历、LeetCode94. 二叉树的中序遍历
weixin_48323589的博客
10-26 294
代码随想录算法训练营第十四天| LeetCode144. 二叉树的前序遍历、LeetCode145. 二叉树的后序遍历、LeetCode94. 二叉树的中序遍历
代码随想录算法训练营第14天 | 144.二叉树的前序遍历 + 94.二叉树的中序遍历 + 145.二叉树的后序遍历
weixin_42286468的博客
05-23 221
代码随想录算法训练营 打卡博文 day14
代码随想录算法训练营第十三天|144二叉树的前序遍历、145二叉树的后序遍历、94二叉树的中序遍历
weixin_42518710的博客
01-29 148
坚持。
代码随想录算法训练营第十二天 | 二叉树的递归遍历、迭代遍历、统一遍历和层序遍历
decode12的博客
10-15 316
二叉树的遍历分为深度优先遍历（向下遍历到叶子再返回）和广度优先遍历（先遍历当前层再遍历下一层）
Python二叉树的遍历操作示例【前序遍历,中序遍历,后序遍历,层序遍历】
09-19
本文将深入探讨Python中的二叉树及其遍历方法，包括前序遍历、中序遍历、后序遍历以及层序遍历。通过具体的代码示例，我们将更好地理解这些遍历方法的工作原理和应用场景。 #### 二、二叉树基础知识回顾 二叉树是由...
Python实现输入二叉树的先序和中序遍历，再输出后序遍历操作示例
01-20
本文实例讲述了Python实现输入二叉树的先序和中序遍历，再输出后序遍历操作。分享给大家供大家参考，具体如下： 实现一个功能：  输入:一颗二叉树的先序和中序遍历  输出:后续遍历 思想： 先序遍历中，第一个元素...
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
热门推荐
正弦定理的博客
12-09 36万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
python实现二叉树遍历（前序遍历、中序遍历、后序遍历）
data+scenario+science+insight
06-12 2369
python实现二叉树遍历（前序遍历、中序遍历、后序遍历） 在计算机科学中，二叉树是一种树数据结构，其中每个节点最多有两个子节点，称为左子节点和右子节点。使用集合理论概念的递归定义是(非空)二叉树是元组(L, S, R)，其中L和R是二叉树或空集，而S是包含根的单例集。一些作者也允许二叉树是空集。 三种常用的遍历方式： 1. 前序遍历。先访问根结点，再前序遍历左子树，最后前序遍历右子树。可见，这个操作的定义就是递归的。 2. 中序遍历。先中序遍历左子树，再访问根结点，最后中序遍历右子树。..
图算法之Floyd-Warshall 算法（全点对最短路径）详细解读
m0_61840987的博客
10-11 806
Floyd-Warshall 算法是求解全点对最短路径的经典算法，适用于需要处理负权边的场景。它的时间复杂度较高，因此适合处理顶点较少的密集图，而不是稀疏图。如果图中存在负权环，该算法可以用来检测。
在顺序结构和链式结构的线性表上实现顺序检索算法
m0_56332819的博客
10-13 206
在顺序结构和链式结构的线性表上实现顺序检索算法，C语言
数据结构常考基础代码题-数组倒置
最新发布
qq_52291558的博客
10-16 295
根据题目中的“将数组中的元素顺序反转”，我们需要实现一个函数Reverse，用于反转数组中从start到end的元素。// 函数用于反转数组A中从start到end的元素int temp;// 使用while循环进行元素交换，直到start和end相遇或交叉// 保存A[start]的值// 将A[end]的值赋给A[start]// 将temp（原A[start]的值）赋给A[end]start++;// 移动start指针end--;// 移动end指针。
【从零开始的LeetCode-算法】3099. 哈沙德数
qq_40878316的博客
10-15 152
如果一个整数能够被其各个数位上的数字之和整除，则称之为。各个数位上的数字之和，否则，返回。各个数位上的数字之和为。各个数位上的数字之和为。不是哈沙德数，答案是。
【刷题册】2024.10.13 - 2024.10.15
yj20040627的博客
10-16 614
BC153 [NOIP2010]数字统计 NC313 两个数组的交集 AB5 点击消除 BC64牛牛的快递 DP4 最小花费爬楼梯 数组中最小两个字符串的最小距离 BC149 简写单词 dd爱框框 除2！
【鸟类识别系统】Python+卷积神经网络算法+人工智能+深度学习+ResNet50算法+计算机课设项目
子午的博客
10-12 886
鸟类识别系统。本系统采用Python作为主要开发语言，通过使用加利福利亚大学开源的200种鸟类图像作为数据集。使用TensorFlow搭建ResNet50卷积神经网络算法模型，然后进行模型的迭代训练，得到一个识别精度较高的模型，然后在保存为本地的H5格式文件。在使用Django开发Web网页端操作界面，实现用户上传一张鸟类图像，识别其名称。本项目通过人工智能技术实现对鸟类图像的自动识别，满足用户在日常生活中快速、准确地识别鸟类的需求。
通过 哪些 序列可以确定唯一的二叉树 前序遍历和后序遍历 前序遍历和中序遍历 后序遍历和中序遍历 后序遍历
08-30
- *1* *2* *3* [二叉树前序遍历、中序遍历、后序遍历、层序遍历的直观理解](https://blog.csdn.net/u013834525/article/details/80421684)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值