六、二叉树（1）

最新推荐文章于 2024-08-23 16:53:34 发布
最新推荐文章于 2024-08-23 16:53:34 发布
阅读量660 收藏 29
点赞数 11
分类专栏： 算法基础 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49206002/article/details/140794113
版权

六、二叉树（1）

理论基础

种类

满二叉树：节点都是满的，节点个数2^k - 1
完全二叉树：除最后一层外都是满的，底部可以空，但是有值的地方必须从左到右连续，
平衡二叉搜索树：（搜索树有序）平衡☞左子树和右子树的深度差不能> 1

存储方式

链式
.left 指向左儿子 .right指向右儿子（指针啦~）
线式
数组1 2 3 4 5 6顺序着标，对于某个节点i，i * 2+1是他的左孩子 i * 2+2是右孩子

一般是用链式也就是链表去构造，自己封装好，把头节点传入待处理的函数

遍历方式

深度优先搜索
前中后、迭代、递归（能递归的一定能迭代）
广度优先搜索 层序

前序遍历： 中左右
中序：左中右
后序：左右中（发现是先左后右，前中后是相对于中而言）

栈其实就是递归的一种实现结构，也就说前中后序遍历的逻辑其实都是可以借助栈使用递归的方式来实现的。

而广度优先遍历的实现一般使用队列来实现，这也是队列先进先出的特点所决定的，因为需要先进先出的结构，才能一层一层的来遍历二叉树。

定义

面试传入二叉树需要自己定义数据结构 初始值赋值None

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

递归遍历三部曲：

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

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]:
        res = []  # 全局变量
        # 递归参数
        def dfs(node):
            # 终止条件
            if node == None:
                return
            res.append(node.val)
            dfs(node.left)
            dfs(node.right)

        # 入口
        dfs(root)
        return res

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

# 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 postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ans = []
        def dfs(node):

            if node == None:
                return
            dfs(node.left)
            dfs(node.right)
            ans.append(node.val)

        dfs(root)
        return ans

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

左中右

# 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 inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ans = []
        def dfs(node):

            if node == None:
                return
            dfs(node.left)
            ans.append(node.val)
            dfs(node.right)
            

        dfs(root)
        return ans

递归和迭代的主要区别：

定义

  • 递归：一个函数直接或间接地调用自身来解决问题的方式。递归通常将问题分解为一个或多个较小的子问题，直到这些子问题足够简单以直接解决。

    示例：

    def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)

  • 迭代：使用循环结构（如 for 循环或 while 循环）反复执行一段代码直到满足某个条件来解决问题。

    示例：

    def factorial(n):
    result = 1
    for i in range(1, n + 1):
        result += i
    return result

特点和区别

  1. 实现方式：

    • 递归：通过函数调用自身实现。
    • 迭代：通过循环结构（如 for 或 while 循环）实现。

  2. 终止条件：

    • 递归：必须有一个明确的终止条件（基准情况）来避免无限递归。
    • 迭代：通过循环条件控制循环的终止。

  3. 空间复杂度：

    • 递归：每次递归调用都会在调用栈上分配新的栈帧，可能导致较高的空间开销。
    • 迭代：通常只需要固定的额外空间（循环变量），因此空间开销较小。

  4. 可读性和简洁性：

    • 递归：有时递归的解决方案更直观和简洁，特别是对于树形或分治问题。
    • 迭代：对于某些问题，迭代可能更直接和高效。

  5. 性能：

    • 递归：由于函数调用的开销和可能的栈溢出，递归在某些情况下可能不如迭代高效。
    • 迭代：通常比递归更高效，特别是在需要大量递归调用的情况下。

适用场景

  • 递归：适用于自然分解为更小子问题的问题，如树遍历、图遍历、分治算法（如归并排序、快速排序）、计算斐波那契数列等。

    示例：计算斐波那契数列

    def fibonacci(n):
    if n <= 1:
        return n
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)

  • 迭代：适用于需要重复执行某段代码直到满足特定条件的问题，如遍历数组、链表等线性数据结构、简单的数学计算等。

    示例：计算斐波那契数列

    def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
    return a

迭代遍历

用栈模拟+while 循环
前序是中左右，所以每一个节点弹出保存之前，先入栈右节点，再入栈左节点，右节点先保存，在左节点的子树 没有全部弹出之前，会一直在，所以很好的实现了前序

前序迭代

def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ans = []
        if root == None:
            return ans
        stack = [root]
        while stack:
            temp = stack.pop()
            ans.append(temp.val)  # 进去之前要考虑为None
            if temp.right:
                stack.append(temp.right)
            if temp.left:
                stack.append(temp.left)

        return ans

中序迭代

左中右，有一个node，先放入右节点，它，左节点，啥时候弹出？得先找到最左边那个节点。所以我们得按拿的顺序去放，先放入节点5，再放他的左节点4，如果还有左节点，一直放左节点，直到最左边1，弹出左1，弹出中4，如果有右2，放入右，再弹出右2，在弹出上一层的中5
在这里插入图片描述
注意：while cur or stack: # 循环条件# 怎么更新cur
# 假设这个最左节点是一个中节点，它还有一个右节点
cur = cur.right
# 去考虑右节点为根的小树

class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ans = []
        if  not root:
            return ans
        # 不能提前将root放入，
        stack = []
        cur = root
        while cur or stack:  # 循环条件
            
            # if node.left: # 这样会反复添加
            #     stack.append(node.left) 所以用一个指针来找
            if cur:
                stack.append(cur)
                cur = cur.left
            # 当左线找到最左点or 右节点为none
            else:
                cur = stack.pop()  #为空，
                ans.append(cur.val)
                # 怎么更新cur
                # 假设这个最左节点是一个中节点，它还有一个右节点
                cur = cur.right
                # 去考虑右节点为根的小树
        return ans

而且当到中的时候，stack是为空的巧的是cur指向右子树，指针表示了查询的顺序

后序迭代

左右中，可以通过先序遍历中左右改成 中右左，在ans[::-1]结果反转一下

# 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 postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ans = []
        if not root:
            return ans

        cur = root
        stack = []
        last_visited = None
        while cur or stack:
            if cur:  # 左
                stack.append(cur)
                cur = cur.left
            # 当cur为空
            else:
                cur = stack[-1]
                # 会重复访问
                if cur.right and last_visited != cur.right:  # 右节点重复访问
                    
                    cur = cur.right
                else:
                    ans.append(cur.val) # 中
                    last_visited = stack.pop()
                    cur = None # 右还没遍历 当 cur 为 None 时，查看栈顶节点的右子树
                    
        return ans

发现是用cur记录是否遍历过，cur有值就入栈，中序的顺序是左 中 右
后序遍历和中序遍历在实现上有一些相似之处，但它们在访问节点的顺序和处理方式上有显著的区别。以下是对这两种遍历方法的详细总结，以及它们的不同之处：

中序遍历（Inorder Traversal）

中序遍历的顺序是：左子树 -> 根节点 -> 右子树。其实现方式如下：
重点是我要用一个cur去找通过中 左 右（新头） 左的顺序

为什么？因为我的访问顺序和处理顺序是不一样的，前序中左右，一层一层都是先中，但中序是先左，所以得找到最左边。访问过的放到stack里面，没访问的用cur去更新，访问顺序也是中左右的顺序，符合我们寻找的逻辑
此时重复的是找最左点，cur空时（左点到头 or右点空）时弹出，右点又为新的数的头一直找左

# 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 inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # 左中右 找左 压入右，中， 中作为新的左
        ans = []
        stack = []
        if not root:
            return []
        cur = root
        
            
        while cur or stack:
            # 去找头和左，要一直找到最左点，才能看他对应的右，这个右又是新的头
            while cur: 
                stack.append(cur)
                cur = cur.left
            # if not cur: 执行到下面应该就是cur为空
            node = stack.pop()
            ans.append(node.val)
            # if node.right: 如果存在，cur没毛病，如果不存在，反正cur之前也是空
            cur = node.right
                
        return ans

后序遍历（Postorder Traversal）

后序遍历的顺序是：左子树 -> 右子树 -> 根节点。其实现方式如下：

# 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 postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ans = []
        if not root:
            return ans

        cur = root
        stack = []
        last_visited = None
        
        while cur or stack:
            if cur:  # 遍历左子树
                stack.append(cur)
                cur = cur.left
            else:
                cur = stack[-1]  # 查看栈顶节点

                # 如果右子树存在且未被访问过，遍历右子树
                if cur.right and last_visited != cur.right:
                    cur = cur.right
                else:
                    # 访问根节点
                    ans.append(cur.val)
                    last_visited = stack.pop()  # 弹出栈顶节点并更新 last_visited
                    cur = None  # 重置 cur 为 None

        return ans

把后续左右中看做中右左的逆，一层一层的，类似前序迭代

# 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 postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ans = []
        if not root:
            return []
        stack = [root]
        # 左右中  中右左
        # 为什么能直接就出来，要出现中右左 可以是栈中，左右中，也可以是先中 弹出，再左右
        # 先中，弹出有什么好，类似一层一层的考虑，下一层就是他的左子和右子
        while stack:
            node = stack.pop()
            ans.append(node.val)
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
        return ans[::-1]

迭代到底在重复什么？

看前序迭代，从根节点开始，每次弹出一个，是中，再弹出左，左作为中节点，还有他的左和右，就这样一层一层的找左右，通过栈，把右压在底下，左先弹出来。我们从逻辑上看前序也是中，左（作为中还有左），左，左，一直到头，看到头的左对应的右，也就是刚刚被压在底下的右。右可能也是作为中去找左和右，所以有有了一场迭代，去找左和右
曾经的左作为新的中，曾经的右作为新的中，先进右后进左以便先出左

思路上的主要区别

  1. 访问顺序：

    • 中序遍历：按照左子树 -> 根节点 -> 右子树的顺序。需要确保在访问根节点之前已经遍历了左子树，在访问右子树之前已经访问了根节点。
    • 后序遍历：按照左子树 -> 右子树 -> 根节点的顺序。需要确保在访问根节点之前已经遍历了左右子树。

  2. 辅助变量：

    • 中序遍历：不需要辅助变量，只需通过当前节点 cur 和栈来遍历树。
    • 后序遍历：需要一个辅助变量 last_visited 来跟踪上一次访问的节点，以避免重复访问右子树。

  3. 栈的处理：

    • 中序遍历：在找到最左节点后，弹出栈顶节点并访问它，然后遍历右子树。
    • 后序遍历：在找到最左节点后，查看栈顶节点。如果右子树存在且未被访问过，则遍历右子树；否则，访问根节点并更新 last_visited 变量。

  4. 终止条件：

    • 中序遍历：循环的终止条件是当前节点 cur 为 None 且栈为空。
    • 后序遍历：循环的终止条件相同，但需要额外检查右子树的访问状态。

前面用迭代来实现前中后序，后面通过栈用递归来实现。
针对三种遍历方式，使用迭代法是可以写出统一风格的代码！

统一迭代 （标记法）

访问放入栈，要处理的也放入，但是做一个标记。
标记什么？标记已经展开过left right的点，所以不会重复添加
在这里插入图片描述

对于前序来说，中左右。遇到中，我们放进去，但是他先弹出，所以我们放在最外面，拿出来5，放入他的右6和左4，再放入中5，由于我们要弹出的数后面做个记号放一个none，如果弹出一个数是none，那他前一个数就是要处理的，弹出放入ans。
那怎么处理这个逻辑呢，普通的要处理的数没有左右，后面依旧添加一个None表示他要弹出

# 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]:
        ans = []
        st = []
        if not root:
            return []
        st = [root]
        while st:
            node = st.pop()
            if node:
                if node.right:
                    st.append(node.right)
                if node.left:
                    st.append(node.left)
                # 拿出来看了一下，再放回
                st.append(node)
                st.append(None)  # 标记要处理，
                # 不管是中节点（有儿子的），还是最后要弹出的节点（没儿子的），轮到他后面都有一个标记
            else:
                # 待处理
                ans.append(st.pop().val)
        return ans

对于中序，左中右。右边先进，中后进，左最后，左作为新的中，none加在哪里?其实我们发现，对于一个中节点去访问他的左右节点这个操作，是不断重复的，也就是每个节点，都会有机会被当做中去看有没有左右。什么中这个节点访问过，所以在他后面标记一个None，每个节点都有机会被当做中，所以都会被标记，也就都会输出。至于输出的顺序，受进栈的顺序影响，只要我一直是右中左的顺序，就不会出错

# 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 inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        ans = []
        st = [root] # 存放访问和标记 标记法
        while st:
            node = st.pop()
            if node:
                # 访问，展开左右
                # 左中右， 右中左
                if node.right:
                    st.append(node.right)
                st.append(node)
                st.append(None)
                if node.left:
                    st.append(node.left)
                # 如果是要弹出的叶子节点，等到访问他们的时候自然会加上NONE

            else:
                ans.append(st.pop().val)
        return ans

后序，左右中。同样标记访问展开过的点

# 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 postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        ans = []
        st = [root] # 存放访问和标记 标记法
        while st:
            node = st.pop()
            if node:
                st.append(node)
                st.append(None)
                if node.right:
                    st.append(node.right)
                if node.left:
                    st.append(node.left)        
            else:
                ans.append(st.pop().val)
        return ans

标记法太好用了！标记展开的点，迭代重复展开，遇到叶子节点或者展开过的点就回有none，直接输出即可。不管是递归还是迭代还是标记法都是深度优先下面考虑广度优先的层序遍历。

层序遍历

深度优先是用栈来实现，（一路一路）。广度优先是用队列，（一层一层）
需要哪些变量。ans存结果是一个二维的列表 queue放拿出来的值 node是拿出来之后要left right展开的点 level是一层的一维的列表
102.二叉树的层序遍历

注意deque初始化应该是一个iterable的queue = collections.deque([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 levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
       if not root:
           return []
       ans = []
       queue = collections.deque([root])
       while queue:
           # 后面queue会随着node展开增加，怎么才能知道我的node是在这一层的呢？
           # 用queue的长度 每次queue进入循环都只存了一层的信息
           level = [] # 应该在每层初始化
           for _ in range(len(queue)):              
               node = queue.popleft()
               if node.left:
                   queue.append(node.left)
               if node.right:
                   queue.append(node.right)
               level.append(node.val)
           ans.append(level)
       return ans

递归

# 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 levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
       # 递归，参数：节点，层数
       if not root:
           return []
       ans = []

       def dfs(node, level):
           if  not node:
               return
           # ans虽然是[[]]但是如果level 1 就超出范围了
           # 所以应该每层开始都要初始化一下
           if len(ans) == level:
               ans.append([])
           ans[level].append(node.val)
           dfs(node.left, level+1)
           dfs(node.right, level+1)

       dfs(root, 0)
       return ans

107.二叉树的层次遍历II

199.二叉树的右视图
637.二叉树的层平均值
429.N叉树的层序遍历
515.在每个树行中找最大值
116.填充每个节点的下一个右侧节点指针
117.填充每个节点的下一个右侧节点指针II
104.二叉树的最大深度
111.二叉树的最小深度

小霖同学onism
关注
  • 11
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
实验六 二叉树及其应用
Sukihasimoto的博客
11-27 1688
1.目的要求： （1） 通过实验，掌握二叉树的两种基本的存储结构及二叉树的建立、遍历（先序、中序、后序、层次遍历），并加以应用（计算二叉树的高度、统计结点数目等）。 （2） Huffman编码和译码。 2.实验内容： （1） 按先序次序输入二叉树中结点的值，建立一棵以二叉链表作存储结构的二叉树，然后按先序、中序、后序、层序遍历这棵二叉树，并完成二叉树的相应信息的统计（如各种结点数目、二叉树的深度等...
第六章 二叉树基础知识
policevos的博客
04-20 255
二叉树基础知识结点的度和树的度结点的层次和树的高度（深度）父亲，儿子和兄弟祖先，子孙和堂兄弟有序树，m叉树，森林二叉树概念满二叉树完全二叉树二叉树的性质二叉树的存储结构 结点的度和树的度 结点拥有子树的数目称为该结点的度(一个节点分叉的数量） 度为0的结点称为叶子或者终端结点 度不为0的结点称为非终端结点或分支结点，除了根之外的分支结点也称为内部结点 树内各结点度的最大值称为树的度（最多的分结点...
二叉树
qq_45704528的博客
02-17 1834
二叉树 目录二叉树一.二叉树的概念二.二叉树的基本形态三.两种特殊的二叉树1.满二叉树2.完全二叉树四.二叉树的性质五.二叉树的存储1.顺序存储2. 链式存储六.二叉树的基本操作1.二叉树的遍历<1>前序遍历<2>中序遍历<3>后序遍历<4>层序遍历2.二叉树求结点个数<1>解题思路<2>代码实列3.求二叉树第K层结点个数<1>解题思路<2>代码实列4.求二叉树叶子结点的个数<1>解题思路<2&
六 二叉树
Major_S的博客
05-02 486
六 二叉树
c语言六种方法遍历二叉树,C语言——二叉树的基本遍历方法
weixin_33925126的博客
05-25 1104
/*二叉树的基本遍历方法*/#include #include #define type char#define MAXSIZE 10typedef struct BiTree {type data;struct BiTree * lchild;struct BiTree * rchild;}BiNode, *BiTree;// 访问节点函数void visit(BiTree node) {pri...
第六章 二叉树part01
qq_16674623的博客
04-16 108
二叉树的递归遍历 二叉树的递归遍历 二叉树的统一迭代法
六、二叉树
weixin_44824326的博客
01-08 886
二叉树·的查找
数据结构第六章 树和二叉树
郑哥哥の博客
08-23 499
文章目录基本术语树的性质二叉树二叉树的定义及其主要特性1.二叉树的定义2.几个特殊的二叉树3.二叉树的性质二叉树的存储结构1.顺序存储结构2.链式存储结构二叉树的遍历与线索二叉树1.先序遍历2.中序遍历3.后序遍历4.层序遍历线索二叉树1.线索二叉树的概念2.中序线索二叉树的构造树、森林树的存储结构1.双亲表示法2.孩子表示法3.孩子兄弟表示法树、森林、二叉树的转换树和二叉树的应用二叉排序树1.二叉排序树的定义2.二叉排序树的查找3.二叉树排序树的查找效率分析平衡二叉树1.平衡二叉树的插入2.平衡二叉树的4
【数据结构】——二叉树详解
热门推荐
atwdy的博客
07-28 5万+
二叉树(Binary Tree)是由n个结点构成的有限集(n≥0)，n=0时为空树，n>0时为非空树。对于非空树TTT有且仅有一个根结点；除根结点外的其余结点又可分为两个不相交的子集TLT_LTL​和TRT_RTR​，分别称为TTT的左子树和右子树，且TLT_LTL​和TRT_RTR​本身又都是二叉树。很明显该定义属于递归定义，所以有关二叉树的操作使用递归往往更容易理解和实现。从定义也可以看出二叉树与一般树的区别主要是两点，一是每个结点的度最多为2；
二叉树刷题 第六天
jianjiange1的博客
10-29 2189
二叉树的递归和非递归
第六章 树和二叉树习题1
03-20
最后，空树既是一棵树也是一棵二叉树，二叉树可以使用顺序和链式存储，完全二叉树的深度与节点数的关系是2^(k-1) ^k，把树转换成二叉树形态不是唯一的，但是二叉排序树的特性是有一定的规律。 通过这些解释，我们...
实验六 二叉树操作.docx
11-12
本实验"实验六 二叉树操作.docx"显然着重于探讨如何操作和遍历二叉树，特别是通过层序遍历的方式。在这个过程中，我们将深入理解二叉树的性质、层序遍历的概念，以及如何实现这一遍历方法。 首先，二叉树是由节点...
实验六 二叉树操作.pdf
11-12
二叉树是一种数据结构，它由结点（或称为节点）构成，每个结点最多有两个子结点，分别称为左子结点和右子结点。在这个实验中，我们将深入理解二叉树的性质，并学习如何使用数组来存储和操作二叉树。 实验目标是掌握...
有值二叉树
04-15
1. **至少三个元素**：根据描述中的“至少有三个元素”，我们可以理解为一个有效的有值二叉树至少需要包含三个节点。这是因为一个具有两个节点的二叉树无法形成分支结构，不具备足够的复杂度来体现二叉树的特性。 ...
第六章树和二叉树学生版1
08-08
第六章主要讲解了树和二叉树的基本概念和特性，涉及了多项选择题和填空题，涵盖了多个知识点。以下是对这些知识点的详细说明： 1. 满二叉树的性质：在一棵具有5层的满二叉树中，结点总数可以通过公式2^(h-1)-1计算...
如何在Python中使用IP代理
最新发布
IPIPGO的博客
08-23 357
通过以上步骤，你应该已经学会了如何在Python中使用IP代理。无论是单个代理IP、带认证的代理IP，还是批量使用代理IP，这些方法都能帮助你在实际项目中灵活应用。希望这篇文章对你有所帮助，如果你有任何问题或建议，欢迎在评论区留言，我们会尽力为你解答。t=N7T8。
常见面试问题(Python)
jiao_mrswang的博客
08-23 150
5、GIL全局解释锁。
Android笔试面试题AI答之Kotlin（20）
学无止境，止于至善
08-21 684
Elvis操作符（?:）是Kotlin（以及一些其他编程语言）中用于处理可空表达式的一种简洁方式。它允许在表达式的值为null时提供一个默认值，从而简化了空值的处理。在Kotlin中，构造函数（Constructor）是类的一个特殊方法，它用于初始化新创建的对象。与Java不同，Kotlin中的构造函数不是通过名称来定义的，而是与类名相同，并且没有返回类型（即使是void）。Kotlin支持主构造函数和次构造函数（也称为辅助构造函数或二级构造函数）。
零基础学习人工智能—Python—Pytorch学习（六）
kiba518的博客
08-21 860
前言 本文主要讲神经网络的上半部分。 这篇文章开始有很多公式了，这些公式都很简单，但是如果是不经常在脑海里思考公式的人，那可能需要多花点时间做一下自我训练，个人感觉，也就几天时间，就能把自己感觉给调整出来。 习惯了公式看下面内容就会轻松很多，另外如果要深入学习人工智能，熟练的认知公式也是个必须的事情。 另外，我发现我前面文章写的有歧义的地方还是挺多，虽然，已经改了一部分，但，可能还有没发现的，大...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值