代码随想录算法训练营第15天｜二叉树 part02｜ 层序遍历 、226.翻转二叉树、101. 对称二叉树

最新推荐文章于 2024-10-08 14:50:18 发布
最新推荐文章于 2024-10-08 14:50:18 发布
阅读量107 收藏
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gengjiahao/article/details/128596555
版权

15代码随想录算法训练营第15天｜二叉树 part02｜ 层序遍历 、226.翻转二叉树、101. 对称二叉树

层序遍历

102. 二叉树的层序遍历

题目链接： 102.二叉树的层序遍历

需要用到队列，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑

这种层序遍历方式就是图论中的广度优先遍历

层次遍历动画如下：

请添加图片描述

代码：

自己做

因为题目中是按层返回结点信息的，如果采用队列的方式，不知道如何按层返回结点信息，所以我就采用了递归的方式，每次返回都是一层的结点信息。

python

# 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 levelOrderTraverse(self, lst, result):
        if len(lst) == 0:
            return None
        else:
            sub_list = []
            nextLevel_list = []
            for node in lst:
                sub_list.append(node.val)
                if node.left: nextLevel_list.append(node.left)
                if node.right: nextLevel_list.append(node.right)
            result.append(sub_list)
            return self.levelOrderTraverse(nextLevel_list, result)

        
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        # 思想：
        '''
        1. 创建一个队列
        2. 只要队列不等于空，那么出队，然后将其左孩子和右孩子送入队列中，知道队列为空
        注意：如何记录哪些结点属于哪一层呢？
        好像递归更好记录层次信息，每次return 层次加1
        '''
        result = []
        lst = []

        if root: 
            lst.append(root)
        else:
            return []
        
        self.levelOrderTraverse(lst, result)

        return result

代码随想录

采用队列的方式：

for _ in range(len(queue)): # 点睛之笔！！！只遍历每层结点的长度

python

from collections import deque
# 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([root]) # 这里root要加[]，因为deque类接受数据类型必须为可迭代数据类型

        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

递归的方式：

这个递归方式没有自己写的好理解

# 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]]
        """
        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)

接下来为10道用到层次遍历的题

107.二叉树的层次遍历 II

107.二叉树的层次遍历 II

反转result列表即可

result[::-1]

199.二叉树的右视图

199.二叉树的右视图

在这里插入图片描述

方法一：

	return [result[-1] for result in result]

方法二：

	 result.append(level[-1]) # level为每层的结点列表
 return result

637.二叉树的层平均值

637.二叉树的层平均值

改进方法一：（时间复杂度会很高！）

result.append(float(sum(level))/len(level))
    return result

改进方法二：

level_sum = 0.0
level_len = 0
for _ in range(len(queue)): # 点睛之笔！！！只遍历每层结点的长度
    cur = queue.popleft()
    level_sum += cur.val
    level_len += 1
    if cur.left:
        queue.append(cur.left)
    if cur.right:
        queue.append(cur.right)
result.append(level_sum/level_len)

429. N 叉树的层序遍历

429. N 叉树的层序遍历

思想：

框架与二叉树的层次遍历一致

注意

collections.deque是一个类，如果直接传参进行初始化，需要传入可迭代的对象

方式一：

queue = collections.deque([root])

方式二：

queue = collections.deque()
queue.append(root)

n叉树的children为可迭代对象，需要使用for循环进行遍历

代码：

python

from collections import deque
"""
# 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 = deque()
        queue.append(root)

        result = []

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

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

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

代码改写部分：

python

cur_level_max = -2e31
for _ in range(len(queue)): # 点睛之笔！！！只遍历每层结点的长度
    cur = queue.popleft()
    if cur.val > cur_level_max: cur_level_max = cur.val
    if cur.left:
        queue.append(cur.left)
    if cur.right:
        queue.append(cur.right)
result.append(cur_level_max)

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

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

思想：

这道题可能是脑子不好用了，没有做出来…

本题依然是层序遍历，只不过在单层遍历的时候记录一下 本层的头部节点 ，然后在遍历的时候让前一个节点指向本节点就可以了

代码：

python

from collections import deque
"""
# 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 root
        queue = deque()
        queue.append(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

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

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

同上一题

这道题目说是二叉树，但116题目说是完整二叉树，其实没有任何差别，一样的代码一样的逻辑一样的味道

104.二叉树的最大深度

104.二叉树的最大深度

思想：

有几层的问题

使用迭代法的话，使用层序遍历是最为合适的，因为最大的深度就是二叉树的层数，和层序遍历的方式极其吻合。

111.二叉树的最小深度

111.二叉树的最小深度

思想：

需要注意的是，只有当左右孩子都为空的时候，才说明遍历的最低点了。如果其中一个孩子为空则不是最低点

我当时想的是如果当前层的结点数量小于2**(level-1) 的话就说明到了最小深度，这种想法是不对的。反例：一条斜线的二叉树

代码：

python

# 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
        depth = 0
        queue = collections.deque([root])
        
        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

致敬叶师傅！（连着打了10个小怪，真累坏了）

噗，终于结束了…

226.翻转二叉树

226.翻转二叉树

自己做

思想：

从上到下遍历和从下到上遍历应该是一样的

使用递归：

  1. 传入参数：root
  2. 单层操作：交换左右结点
  3. 返回条件：无左右孩子结点

代码：

python

# 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 invertTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        # 从上到下遍历和从下到上遍历应该是一样的
        if root :
            cur = root
            self.helper(cur)

        return root
    
    def helper(self, cur):
        if cur.left != None or cur.right != None:
            temp = cur.left
            cur.left = cur.right
            cur.right = temp
        if cur.left != None:
            self.helper(cur.left)
        if cur.right != None:
            self.helper(cur.right)
        if cur.left == None and cur.right == None:
            return

代码随想录

思想：

只要把每一个节点的左右孩子翻转一下，就可以达到整体翻转的效果

这道题目使用前序遍历和后序遍历都可以，唯独中序遍历不方便，因为中序遍历会把某些节点的左右孩子翻转了两次！建议拿纸画一画，就理解了

那么**层序遍历可以不可以呢？依然可以的！**只要把每一个节点的左右孩子翻转一下的遍历方式都是可以的！

注意

二叉树解题的大忌就是自己稀里糊涂的过了（因为这道题相对简单），但是也不知道自己是怎么遍历的。

针对翻转二叉树，我给出了一种递归，三种迭代（两种模拟深度优先遍历，一种层序遍历）的写法，都是之前我们讲过的写法，融汇贯通一下而已。

大家一定也有自己的解法，但一定要成方法论，这样才能通用，才能举一反三！

代码：

递归法

# 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 invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return None
        root.left, root.right = root.right, root.left
        self.invertTree(root.left)
        self.invertTree(root.right)
        return root

迭代法：前序遍历：

# 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 invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return None      
        stack = [root]        
        while stack:
            node = stack.pop()   
            node.left, node.right = node.right, node.left                   
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)  
        return root

递归法：中序遍历：

# 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 invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return None
        self.invertTree(root.left)
        root.left, root.right = root.right, root.left
        self.invertTree(root.left)
        return root

迭代法：中序遍历：

# 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 invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return None      
        stack = [root]        
        while stack:
            node = stack.pop()                   
            if node.left:
                stack.append(node.left)
            node.left, node.right = node.right, node.left               
            if node.left:
                stack.append(node.left)       
        return root

递归法：后序遍历：

# 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 invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return None
        self.invertTree(root.left)
        self.invertTree(root.right)
        root.left, root.right = root.right, root.left
        return root

迭代法：后序遍历：

# 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 invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return None      
        stack = [root]        
        while stack:
            node = stack.pop()                   
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)  
            node.left, node.right = node.right, node.left               
     
        return root

迭代法：广度优先遍历（层序遍历）：

# 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 invertTree(self, root: TreeNode) -> TreeNode:
        if not root: 
            return None

        queue = collections.deque([root])    
        while queue:
            for i in range(len(queue)):
                node = queue.popleft()
                node.left, node.right = node.right, node.left
                if node.left: queue.append(node.left)
                if node.right: queue.append(node.right)
        return root

101. 对称二叉树

101. 对称二叉树

自己做

思想：

代码：

代码随想录

思想：

本题遍历只能是“后序遍历”，因为我们要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等。

正是因为要遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中。

代码：

python

递归法

递归三部曲：

  1. 确定递归函数的参数和返回值

  2. 确定终止条件

  3. 确定单层递归的逻辑

# 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 isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if not root:
            return False
        
        return self.compare(root.left, root.right)

    def compare(self, left, right): # 1. 确定递归函数的参数和返回值
    	# 2. 确定终止条件
        if not left and not right: # 
            return True
        elif not left and right:
            return False
        elif left and not right:
            return False
        elif left.val != right.val:
            return False
        
        # 3. 确定单层递归的逻辑
        outside = self.compare(left.left, right.right)
        inside = self.compare(left.right, right.left)
        return outside and inside

迭代法

  1. 使用队列

请添加图片描述

import collections
class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        if not root:
            return True
        queue = collections.deque()
        queue.append(root.left) #将左子树头结点加入队列
        queue.append(root.right) #将右子树头结点加入队列
        while queue: #接下来就要判断这这两个树是否相互翻转
            leftNode = queue.popleft()
            rightNode = queue.popleft()
            if not leftNode and not rightNode: #左节点为空、右节点为空，此时说明是对称的
                continue
            
            #左右一个节点不为空，或者都不为空但数值不相同，返回false
            if not leftNode or not rightNode or leftNode.val != rightNode.val:
                return False
            queue.append(leftNode.left) #加入左节点左孩子
            queue.append(rightNode.right) #加入右节点右孩子
            queue.append(leftNode.right) #加入左节点右孩子
            queue.append(rightNode.left) #加入右节点左孩子
        return True
  1. 使用栈

把左右两个子树要比较的元素顺序放进一个容器，然后成对成对的取出来进行比较，

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        if not root:
            return True
        st = [] #这里改成了栈
        st.append(root.left)
        st.append(root.right)
        while st:
            rightNode = st.pop()
            leftNode = st.pop()
            if not leftNode and not rightNode:
                continue
            if not leftNode or not rightNode or leftNode.val != rightNode.val:
                return False
            st.append(leftNode.left)
            st.append(rightNode.right)
            st.append(leftNode.right)
            st.append(rightNode.left)
        return True
  1. 层次遍历
class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        if not root:
            return True
        
        queue = collections.deque([root.left, root.right])
        
        while queue:
            level_size = len(queue)
            
            if level_size % 2 != 0:
                return False
            
            level_vals = []
            for i in range(level_size):
                node = queue.popleft()
                if node:
                    level_vals.append(node.val)
                    queue.append(node.left)
                    queue.append(node.right)
                else:
                    level_vals.append(None)
                    
            if level_vals != level_vals[::-1]:
                return False
            
        return True
gengjiahao
关注
代码随想录算法训练营第十五天|二叉树part02| 二叉树的层序遍历 226.翻转二叉树 101. 对称二叉树
2301_78266314的博客
06-21 151
可以前序遍历，也可以后序遍历，中序遍历要注意swap之后遍历的是同一边。二叉树的层序遍历：之后补。101. 对称二叉树。
代码随想录算法训练营第15天 | 二叉树_part2 二叉树层序遍历 BFS，226. 翻转二叉树，101. 对称二叉树
wdhealer的博客
06-10 173
中（页面左边有对应题目的目录）有详细讲解，这是博主学习的心得和日志，感兴趣的建议去阅读一下原文。以下题目皆在Carl老师的。复习和巩固区域变量的基础。
代码随想录算法训练营第15天 | 二叉树part02：●层序遍历和10道题● 226.翻转二叉树 ● 101.对称二叉树 2
weixin_51674457的博客
06-22 1096
2. 107 层序遍历从最下层开始 易：vec反一下就行；迭代ok 递归ok 都是最基本的。易错：传入的变量到底是var还是ref。注意：用固定大小size来遍历。
代码随想录算法训练营20期|第十五天|二叉树 part02|● 层序遍历 102 ● 226.翻转二叉树 ● 101.对称二叉树
2301_78266314的博客
08-23 137
最经典的层序遍历，用Queue来存储TreeNode，用size存储个数对每一层的node。返回结果是倒三角，代码和102一样，只是往res里加的时候，之间加到list的最前面。把sub和tree比较,返回的时候要用||，因为有一边找到就行。只要有node不为空，有下一次，就继续遍历，返回层数。把每一层的node值相加，再除以node的个数。其实就是return每一层的最后一个node。前序或者后序都可以，中序会有的孩子被反转两次。层序遍历：在node poll出来的时候交换。
代码随想录算法训练营DAY15|C++二叉树Part.2|102.二叉树的层序遍历、226.翻转二叉树、101. 对称二叉树
糖炒栗子
04-03 1436
状态：对于二叉树的题，往往会涉及到遍历顺序，此题要求反转二叉树，也就每个结点的左右孩子进行反转，最直观的应该当属前序遍历或者后序遍历。返回值本来是不需要的，但是题目中要求给出返回root结点的指针，我们就直接使用题目定义好的函数。由于其并不是把当前层遍历完再去遍历下一层的规则，所以层序遍历的递归法总体还是比较难懂的。这样遍历主要是因为，左子树的左侧对应右子树的右侧，左子树的右侧对应右子树的左侧。左右都不空，但是结点数值不相等；二叉树类的题目，确定遍历深度是非常重要的，决定了我们对题目理解的深度。
代码随想录算法训练营第十五天【二叉树part02】 | 层序遍历、226.翻转二叉树、101. 对称二叉树
Mako5455的博客
10-25 66
层序遍历、226.翻转二叉树、101. 对称二叉树
代码随想录算法训练营第十五天 | 层序遍历、226.翻转二叉树、101.对称二叉树
owlmo的博客
12-27 1148
然后将当前节点的left指向当前的右子树，right指向当前的左子树，做翻转操作。否则进行递归处理，判断当前对应的两棵子树是否对称，判断的根据还是根据两棵子树是否为空、两棵子树的对称位置子树是否一致等。思路：进行层次遍历，如果在遍历时，发现当前有一个节点既没有左子树又没有右子树，则当前节点的深度为二叉树的最小深度。思路：进行层次遍历，然后对每层的结果做平均，注意每个节点的数值是否越过int的边界。思路：进行层序遍历，然后在遍历的过程中不断地将每层的前一个节点指向后一个节点。给你一个二叉树的根节点。
代码随想录算法训练营第15天 |（二叉树2 层序遍历的10道题 226.翻转二叉树 101. 对称二叉树
weixin_46743838的博客
01-10 1076
需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑 整体思路：先记录当前层的节点个数（即当前队列中的元素值），再将这一层的元素依次弹出，在弹出过程中下一层的元素要依次入队。集合框架及其方法的使用 List<List> list = new ArrayList<>(); //返回结果 LinkedList<List> list = new LinkedList<>(); list.addFirst(levelList); //
代码随想录算法训练营第15天|10 层序遍历 226.翻转二叉树 101. 对称二叉树2
taohuaak47的博客
07-11 70
今日学习的文章链接，或者视频链接。今日收获，记录一下自己的学习时长。自己实现过程中遇到哪些困难。看完代码随想录之后的想法。自己看到题目的第一想法。
二叉树的创建与遍历C语言实现代码.zip
05-27
二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言...
代码随想录算法训练营Day14|二叉树重点理论基础、递归遍历
m0_60979177的博客
12-20 1320
Day14打卡！今日感想：今天开启二叉树篇章！主要学习了递归法的遍历，之前学的有一点“浮于表面”，要注重学习基本逻辑，尽量把问题的根本理解透彻。
20230622 | 102. 二叉树的层序遍历、226. 翻转二叉树、101.对称二叉树
qq_45885369的博客
06-22 149
给你二叉树的根节点 root ，返回其节点值的 层序遍历。（即逐层地，从左到右访问所有节点）。示例 1：输入：root = [3,9,20,null,null,15,7]输出：[[3],[9,20],[15,7]]示例 2：输入：root = [1]输出：[[1]]示例 3：输入：root = []输出：[]
代码随想录训练营第十四天 | 二叉树基础 递归遍历 144前序遍历 145后序遍历 94中序遍历
Sherry_Sky的博客
11-30 288
代码随想录训练营打卡Day14 | 二叉树基础 递归遍历 144前序遍历 145后序遍历 94中序遍历
打卡第四天 P1081 [NOIP2012 提高组] 开车旅行
hjxxlsx的博客
10-06 456
【代码】打卡第四天 P1081 [NOIP2012 提高组] 开车旅行。
数组综合应用（下标计数）C++
hjxxlsx的博客
10-08 965
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
代码随想录算法训练营Day28 | 39. 组合总和、40.组合总和Ⅱ、131.分割回文串
jiabao0520的博客
10-08 1326
训练营第28天：39. 组合总和、40.组合总和Ⅱ、131.分割回文串
ICPC-day2(圆方树)
最新发布
m0_74315028的博客
10-08 311
每次询问两点x, y，求是否存在一个n的排列，使得第一个元素为x，最后一个元素为y，且排列的任意一个前缀、任意一个后缀都连通。可以用圆方树缩点将其变成一颗树，再判断这颗树是否是一条链，x,y是否在这条链的两侧。其实就是求这两个点是否存在两个不相同的路径，同时两者路径的交集是n。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值