代码随想录算法训练营第十一天 | 二叉树基础

代码随想录算法训练营第十一天 | 二叉树基础

文章目录

  • 代码随想录算法训练营第十一天 | 二叉树基础
    • 1 二叉树的理论基础
      • 1.1 二叉树的类型
      • 1.2 二叉树的存储方式
      • 1.3 二叉树的遍历方式
      • 1.4 二叉树的定义
    • 2 二叉树的递归遍历
      • 2.1 前序遍历
      • 2.2 中序遍历
      • 2.3 后序遍历
    • 3 二叉树的迭代遍历
      • 3.1 前序遍历
      • 3.2 中序遍历
      • 3.3 后序遍历
    • 4 二叉树的统一迭代法
      • 4.1 中序遍历
      • 4.2 前序遍历
      • 4.3 后序遍历

1 二叉树的理论基础

二叉树作为408的高频考点，不管是考试还是面试我们都要好好学习一下有关二叉树的相关知识。

1.1 二叉树的类型

（1）普通二叉树

普通二叉树是最基本的二叉树结构，每个节点最多有两个子节点，分别是左子节点和右子节点，它不强制要求每个节点都有子节点，因此可能呈现出不平衡的状态。

（2）满二叉树

满二叉树是一种特殊的二叉树，每一层的节点数都达到了可能的最大值，换句话说，除了叶子节点外，每个节点都有两个子节点。一棵高度为h的满二叉树，含有 2 h − 1 2^h-1 2h−1个节点，可以对满二叉树按层序编号：约定编号从根结点(根结点编号为1)起，自上而下，自左向右。这样每个结点对应一个编号，对于编号为i的结点，若有双亲，则其双亲为i/2」,若有左孩子，则左孩子为2i；若有右孩子，则右孩子为2i+1。

在这里插入图片描述

（3）完全二叉树

完全二叉树类似于满二叉树，但最后一层的节点可以不完全填满，并且所有节点都靠左排列，它是堆结构的基础。

完全二叉树其特点如下：

①若i≤Ln/2]，则结点i为分支结点，否则为叶结点。

②叶结点只可能在层次最大的两层上出现。对于最大层次中的叶结点，都依次排列在该层最左边的位置上。

③若有度为1的结点，则只可能有一个，且该结点只有左孩子而无右孩子（重要特征)。

④按层序编号后，一旦出现某结点（编号为i）为叶结点或只有左孩子，则编号大于i的结点均为叶结点。

⑤若n为奇数，则每个分支结点都有左孩子和右孩子;若n为偶数，则编号最大的分支结点（编号为n/2）只有左孩子，没有右孩子，其余分支结点左、右孩子都有。

在这里插入图片描述

（4）二叉搜索树（BST）

二叉搜索树是一种特殊的二叉树，它对节点的排列有严格要求：任一节点的左子树只包含比该节点小的值，右子树只包含比该节点大的值，这一特性使得二叉搜索树在查找数据时非常高效。

（5）平衡二叉树（AVL树）

AVL树是一种自平衡的二叉搜索树，它要求任何节点的左右子树的高度差不能超过1，这种严格的平衡要求保证了树的查找效率。

（6）红黑树

红黑树（408考试目前还没有考察过，但估计很快就会考察简单的概念题目）是一种自平衡的二叉搜索树，它通过确保任何一条从根到叶子的路径不会包含两个连续的红色节点来保持平衡，红黑树在计算机科学中广泛应用，特别是在数据结构如map和set中。

1.2 二叉树的存储方式

（1）顺序存储

顺序存储意味着将二叉树的节点数据存放在数组中，对于完全二叉树，这种方法非常高效，数组的索引和树的节点之间有直接的关系：对于索引i的节点，其左子节点的索引是2*i + 1，右子节点的索引是2*i + 2。

在这里插入图片描述

（2）链式存储

在链式存储中，每个节点包含三部分：值、指向左子节点的指针和指向右子节点的指针，这是二叉树最常见的存储方式，因为它能有效地表示树的结构，即使是对于不完全的二叉树。

在这里插入图片描述

1.3 二叉树的遍历方式

（1）前序遍历

前序遍历首先访问根节点，然后递归地进行左子树的前序遍历，接着是右子树的前序遍历。

在这里插入图片描述

（2）中序遍历

中序遍历首先递归地进行左子树的中序遍历，然后访问根节点，最后是右子树的中序遍历，对于二叉搜索树，中序遍历可以按升序访问所有节点。

在这里插入图片描述

（3）后序遍历

后序遍历首先递归地进行左子树的后序遍历，然后是右子树的后序遍历，最后访问根节点。

在这里插入图片描述

（4）层序遍历

层次遍历按照树的层次进行，从根节点开始，然后是第二层，以此类推，通常使用队列来辅助实现这种遍历方式。

在这里插入图片描述

1.4 二叉树的定义

（1）顺序存储定义

  • Python代码定义（在Python中，顺序存储通常使用列表（数组）实现）

    class BinaryTree:
    def __init__(self, size):
        self.array = [None] * size

    def insert(self, value, index):
        if index < len(self.array):
            self.array[index] = value
        else:
            print("Index out of range.")

bt = BinaryTree(10) # 创建一个大小为10的二叉树
bt.insert(1, 0)     # 在根位置插入1
bt.insert(2, 1)     # 在左子节点位置插入2
bt.insert(3, 2)     # 在右子节点位置插入3

  • C++代码定义（在C++中，顺序存储可以使用数组或标准模板库（STL）中的vector实现）

    #include <vector>
#include <iostream>

class BinaryTree {
public:
    std::vector<int> array;

    BinaryTree(int size) {
        array.resize(size, -1); // 初始化为-1，代表空节点
    }

    void insert(int value, int index) {
        if (index < array.size()) {
            array[index] = value;
        } else {
            std::cout << "Index out of range." << std::endl;
        }
    }
};

int main() {
    BinaryTree bt(10);
    bt.insert(1, 0);  // 在根位置插入1
    bt.insert(2, 1);  // 在左子节点位置插入2
    bt.insert(3, 2);  // 在右子节点位置插入3
    return 0;
}

（2）链式存储定义

  • Python代码定义

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

class BinaryTree:
    def __init__(self, root=None):
        self.root = root

root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
bt = BinaryTree(root)

  • C++代码定义

    #include <iostream>

struct TreeNode {
    int value;
    TreeNode *left, *right;

    TreeNode(int val) : value(val), left(nullptr), right(nullptr) {}
};

class BinaryTree {
public:
    TreeNode *root;
    BinaryTree() : root(nullptr) {}
};

int main() {
    BinaryTree bt;
    bt.root = new TreeNode(1);
    bt.root->left = new TreeNode(2);
    bt.root->right = new TreeNode(3);
    return 0;
}

2 二叉树的递归遍历

2.1 前序遍历

（1）Python版本代码

# 前序遍历-递归-LC144_二叉树的前序遍历
# 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: TreeNode) -> List[int]:
        if not root:
            return []

        left = self.preorderTraversal(root.left)
        right = self.preorderTraversal(root.right)

        return  [root.val] + left +  right

（2）C++版本代码

class Solution {
public:
    void traversal(TreeNode* cur, vector<int>& vec) {
        if (cur == NULL) return;
        vec.push_back(cur->val);    // 中
        traversal(cur->left, vec);  // 左
        traversal(cur->right, vec); // 右
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};

下面是王道数据结构上面的二叉树前序遍历代码：

在这里插入图片描述

2.2 中序遍历

（1）Python版本代码

class Solution {
public:
    void traversal(TreeNode* cur, vector<int>& vec) {
        if (cur == NULL) return;
        vec.push_back(cur->val);    // 中
        traversal(cur->left, vec);  // 左
        traversal(cur->right, vec); // 右
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};

（2）C++版本代码

void traversal(TreeNode* cur, vector<int>& vec) {
    if (cur == NULL) return;
    traversal(cur->left, vec);  // 左
    vec.push_back(cur->val);    // 中
    traversal(cur->right, vec); // 右
}

下面是王道数据结构上面的二叉树中序遍历代码：

在这里插入图片描述

2.3 后序遍历

（1）Python版本代码

# 后序遍历-递归-LC145_二叉树的后序遍历
class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []

        left = self.postorderTraversal(root.left)
        right = self.postorderTraversal(root.right)

        return left + right + [root.val]

（2）C++版本代码

void traversal(TreeNode* cur, vector<int>& vec) {
    if (cur == NULL) return;
    traversal(cur->left, vec);  // 左
    traversal(cur->right, vec); // 右
    vec.push_back(cur->val);    // 中
}

下面是王道数据结构上面的二叉树后序遍历代码：

在这里插入图片描述

下面是王道数据结构上面树这一章中关于二叉树的递归算法实现的介绍：

下面用带箭头的虚线表示了这三种遍历算法的递归执行过程。其中，向下的箭头表示更深一层的递归调用，向上的箭头表示从递归调用退出返回; ,虚线旁的三角形、圆形和方形内的字符分别表示在先序、中序和后序遍历的过程中访问根结点时输出的信息。例如，由于中序遍历中访问结点是在遍历左子树之后、遍历右子树之前进行的，则带圆形的字符标在向左递归返回和向右递归调用之间。由此，只要沿虚线从1出发到2结束，将沿途所见的三角形(或圆形或方形)内的字符记下，便得到遍历二叉树的先序(或中序或后序）序列。例如在下图中，沿虚线游走可以分别得到先序序列为ABDEC、中序序列为DBEAC、后序序列为DEBCA。

在这里插入图片描述

3 二叉树的迭代遍历

3.1 前序遍历

在前序遍历中，我们首先访问根节点，然后左节点，最后右节点。使用栈来实现时，我们首先将根节点放入栈中，然后循环直到栈为空，在每次循环中，我们取出栈顶元素，访问它，然后先将其右子节点压入栈（如果有），再将左子节点压入栈（如果有）。

（1）Python版本代码

def preorder_traversal(root):
    if not root:
        return []

    stack, output = [root, ], []
    while stack:
        node = stack.pop()  # 弹出栈顶元素
        if node:
            output.append(node.value)  # 访问节点
            if node.right:  # 如果存在右子节点，先压入栈
                stack.append(node.right)
            if node.left:  # 如果存在左子节点，后压入栈
                stack.append(node.left)
    return output

（2）C++版本代码

vector<int> preorderTraversal(TreeNode* root) {
    vector<int> result;
    if (!root) return result;

    stack<TreeNode*> stack;
    stack.push(root);

    while (!stack.empty()) {
        TreeNode* node = stack.top(); stack.pop(); // 弹出栈顶元素
        if (node) {
            result.push_back(node->value); // 访问节点
            if (node->right) stack.push(node->right); // 先将右子节点压入栈
            if (node->left) stack.push(node->left); // 再将左子节点压入栈
        }
    }
    return result;
}

3.2 中序遍历

在中序遍历中，我们首先访问最左侧节点，然后根节点，最后右节点。使用栈实现时，我们从根节点开始，首先将所有左侧节点压入栈中，然后弹出栈顶元素访问，再处理这个节点的右子树。

（1）Python版本代码

def inorder_traversal(root):
    stack, output = [], []
    current = root

    while current or stack:
        while current:
            stack.append(current)  # 将左子节点压入栈
            current = current.left
        current = stack.pop()  # 弹出栈顶元素
        output.append(current.value)  # 访问节点
        current = current.right  # 转到右子树

    return output

（2）C++版本代码

vector<int> inorderTraversal(TreeNode* root) {
    vector<int> result;
    stack<TreeNode*> stack;
    TreeNode* current = root;

    while (current || !stack.empty()) {
        while (current) {
            stack.push(current); // 将左子节点压入栈
            current = current->left;
        }
        current = stack.top(); stack.pop(); // 弹出栈顶元素
        result.push_back(current->value); // 访问节点
        current = current->right; // 转到右子树
    }
    return result;
}

3.3 后序遍历

后序遍历的顺序是先左节点，然后右节点，最后根节点。其非递归的实现是三种遍历方法中最难的，因为在后序遍历中，要保证左孩子和右孩子都已被访问并且左孩子在右孩子前访问才能访问根节点，我们使用栈实现时，我们可以利用前序遍历的顺序，首先访问根节点，然后右节点，最后左节点，并将结果逆序输出。

（1）Python版本代码

def postorder_traversal(root):
    if not root:
        return []

    stack, output = [root, ], []
    while stack:
        node = stack.pop()  # 弹出栈顶元素
        if node:
            output.append(node.value)  # 访问节点
            if node.left:  # 如果存在左子节点，先压入栈
                stack.append(node.left)
            if node.right:  # 如果存在右子节点，后压入栈
                stack.append(node.right)
    return output[::-1]  # 反转输出结果

（2）C++版本代码

vector<int> postorderTraversal(TreeNode* root) {
    vector<int> result;
    if (!root) return result;

    stack<TreeNode*> stack;
    stack.push(root);

    while (!stack.empty()) {
        TreeNode* node = stack.top(); stack.pop(); // 弹出栈顶元素
        if (node) {
            result.push_back(node->value); // 访问节点
            if (node->left) stack.push(node->left); // 先将左子节点压入栈
            if (node->right) stack.push(node->right); // 再将右子节点压入栈
        }
    }
    reverse(result.begin(), result.end()); // 反转输出结果
    return result;
}

在这些实现中，我们使用栈来模拟递归过程，栈的特性（后进先出）允许我们以非递归的方式来实现树的深度优先遍历，对于前序和后序遍历，我们都是先处理右子树，以确保左子树先被处理。对于中序遍历，我们首先迭代地将所有左子树压入栈中，然后处理节点，并转向右子树。

4 二叉树的统一迭代法

因为统一风格的迭代法并不好理解，而且在面试中也不好直接写，不如递归法简单，所以在这里我就不做过多的研究，感兴趣的可以去卡哥的代码随想录：二叉树的统一迭代法去看看，这里我就只贴出卡哥的代码。

4.1 中序遍历

中序遍历代码如下：（详细注释）

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
                if (node->right) st.push(node->right);  // 添加右节点（空节点不入栈）

                st.push(node);                          // 添加中节点
                st.push(NULL); // 中节点访问过，但是还没有处理，加入空节点做为标记。

                if (node->left) st.push(node->left);    // 添加左节点（空节点不入栈）
            } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
                st.pop();           // 将空节点弹出
                node = st.top();    // 重新取出栈中元素
                st.pop();
                result.push_back(node->val); // 加入到结果集
            }
        }
        return result;
    }
};

4.2 前序遍历

迭代法前序遍历代码如下： (注意此时我们和中序遍历相比仅仅改变了两行代码的顺序)

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop();
                if (node->right) st.push(node->right);  // 右
                if (node->left) st.push(node->left);    // 左
                st.push(node);                          // 中
                st.push(NULL);
            } else {
                st.pop();
                node = st.top();
                st.pop();
                result.push_back(node->val);
            }
        }
        return result;
    }
};

4.3 后序遍历

后序遍历代码如下： (注意此时我们和中序遍历相比仅仅改变了两行代码的顺序)

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop();
                st.push(node);                          // 中
                st.push(NULL);

                if (node->right) st.push(node->right);  // 右
                if (node->left) st.push(node->left);    // 左

            } else {
                st.pop();
                node = st.top();
                st.pop();
                result.push_back(node->val);
            }
        }
        return result;
    }
};

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

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

相关文章

C++特殊类的设计

C++特殊类的设计

目录 一、不能被拷贝的类 二、只能在堆上创建对象的类 三、只能在栈上创建对象的类 四、不能被继承的类 五、只能创建一个对象的类(单例模式) 下面说几种特殊要求的类的设置&#xff0c;主要学习其中所运用的一些思想&#xff0c;融会贯通 一、不能被拷贝的类 C98可以将拷…
阅读更多...
高质量谷歌seo外链平台有哪些？

高质量谷歌seo外链平台有哪些？

明确的说&#xff0c;没有任何必要&#xff0c;这里说的没必要指的是没必要寻找什么高质量的外链平台 所谓高质量的外链平台是什么&#xff1f;你期待在这种平台发外链能获得什么效果&#xff1f;高质量的外链平台&#xff0c;无非就是网站排名高&#xff0c;能发相关的外链的平…
阅读更多...
iOS推送通知

iOS推送通知

文章目录 一、推送通知的介绍1. 简介2. 通知的分类 二、本地通知1. 本地通知的介绍2. 实现本地通知3. 监听本地通知的点击 三、远程通知1. 什么是远程通知2. 为什么需要远程通知3. 远程通知的原理4. 如何做远程通知5. 远程通知证书配置6. 获取远程推送要用的 DeviceToken7. 测试…
阅读更多...
外贸SOHO产品怎么选？海洋建站选品方法？

外贸SOHO产品怎么选？海洋建站选品方法？

外贸SOHO应该如何选产品&#xff1f;跨境电商独立站选品策略&#xff1f; 越来越多的人选择通过外贸SOHO创业&#xff0c;将业务拓展到国际市场。然而&#xff0c;面对琳琅满目的外贸SOHO产品&#xff0c;许多初创企业主可能会感到困惑。海洋建站将为您提供一些建议&#xff0…
阅读更多...
直播核心岗位基础内容

直播核心岗位基础内容

一.直播间核心岗位 1.直播间前端岗位 前端岗位分工 &#xff08;1&#xff09;主播岗位职责 &#xff08;2&#xff09;场控岗位职责 &#xff08;3&#xff09;助理岗位职责 中端岗位分工 &#xff08;1&#xff09;运营岗位职责 &#xff08;2&#xff09;中控岗位职责 …
阅读更多...
2024年Java SpringBoot 计算机软件毕业设计题目推荐

2024年Java SpringBoot 计算机软件毕业设计题目推荐

博主介绍&#xff1a;✌全网粉丝30W,csdn特邀作者、博客专家、CSDN新星计划导师、Java领域优质创作者,博客之星、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域和学生毕业项目实战,高校老师/讲师/同行交流合作✌ 主要内容&#xff1a;SpringBoot、Vue、SSM、HLM…
阅读更多...
Hbuilder从gitlab上面拉取项目

Hbuilder从gitlab上面拉取项目

要先下载TortoiseGit-2.15.0.0-64bit这个软件 在HBuilder中从GitLab上拉取项目&#xff0c;请按照以下步骤操作&#xff1a; 1. 打开HBuilder&#xff0c;点击左上角的“文件”菜单&#xff0c;然后选择“新建”->“项目”。 2. 在弹出的对话框中&#xff0c;选择“从Git导…
阅读更多...
解决 [Vue warn]:Avoid mutating a prop directly 警告

解决 [Vue warn]:Avoid mutating a prop directly 警告

错误信息 [Vue warn]: Avoid mutating a prop directly since the value will be overwritten whenever the parent component re-renders. Instead, use a data or computed property based on the prop’s value. Prop being mutated: “xxx” 错误原因 所有的 prop 都使得…
阅读更多...
vue中使用canvas给图片绘制水印，即使下载图片也是带水印的

vue中使用canvas给图片绘制水印，即使下载图片也是带水印的

先看效果 话不多说直接上组件 1、Watermark.vue <template><div><canvas ref"canvas" :width"width" :height"height"></canvas></div> </template><script>export default {props: {// 图片地址ur…
阅读更多...
Java服务端使用freemarker+wkhtmltoimage生成Echart图片

Java服务端使用freemarker+wkhtmltoimage生成Echart图片

目录 1.通过 freemarker 将ftl转成html 1.1 freemarker 手册: 1.2 添加freemarker maven依赖 1.3 添加 echart-test.ftl 模版文件 1.4 添加 FreemarkerTool 工具类 1.5 添加测试main方法 1.6 运行,生成echart-test-时间戳.html 文件 2. 通过wkhtmltoimage将html 转为p…
阅读更多...
【复现】JieLink+智能终端操作平台弱口令漏洞_28

【复现】JieLink+智能终端操作平台弱口令漏洞_28

目录 一.概述 二 .漏洞影响 三.漏洞复现 1. 漏洞一&#xff1a; 四.修复建议&#xff1a; 五. 搜索语法&#xff1a; 六.免责声明 一.概述 JeLink智能终端操作平台 (JSOTC2016 fJeLink)是捷顺历经多年行业经验积累&#xff0c;集智能硬件技术视频分析技术、互联网技术等…
阅读更多...
【HarmonyOS应用开发】ArkTS基础知识（三）

【HarmonyOS应用开发】ArkTS基础知识（三）

一、浅析ArkTS的起源和演进 1、引言 Mozilla创造了JS&#xff0c;Microsoft创建了TS&#xff0c;Huawei进一步推出了ArkTS。 从最初的基础的逻辑交互能力&#xff0c;到具备类型系统的高效工程开发能力&#xff0c;再到融合声明式UI、多维状态管理等丰富的应用开发能力&#xf…
阅读更多...
如何解决服务器端口被占用的问题，减少带来的影响

如何解决服务器端口被占用的问题，减少带来的影响

在现代网络环境中&#xff0c;服务器扮演着至关重要的角色&#xff0c;其稳定性和安全性对企业的正常运营具有重要意义。然而&#xff0c;服务器端口被占用的问题却时常困扰着企业网络管理员。本文将深入探讨服务器端口被占用的影响&#xff0c;并提出相应的解决方案。 一、服务…
阅读更多...
大数据学习之Redis、从零基础到入门（二）

大数据学习之Redis、从零基础到入门（二）

二、Redis安装配置 1. VMWare本地虚拟机 VMWare准备的为64位 查看自己的VMWare是32位还是64位 getconf LONG_BIT 2. Redis的安装 2.1 系统选择 选择Linux系统 2.2 Linux版安装 2.2.1 Linux环境安装Redis必须先具备gcc编译环境 ①什么是gcc gcc是linux下的一个编译程序&…
阅读更多...
Python模块与包：扩展功能、提高效率的利器

Python模块与包：扩展功能、提高效率的利器

文章目录 一、引言1.1 模块与包对于Python开发的重要性1.2 Python作为拥有丰富生态系统的编程语言 二、为什么学习模块与包2.1 复用代码&#xff1a;利用现有模块与包加速开发过程2.2 扩展功能&#xff1a;通过模块与包提供的功能增强应用的能力 三、模块的使用3.1 导入模块&am…
阅读更多...
网站域名一定要部署SSL证书吗？

网站域名一定要部署SSL证书吗？

随着互联网的发展&#xff0c;网络安全问题越来越受到重视。为网站域名部署SSL证书更是成为站长们维护网站安全的基础措施之一&#xff0c;但是这并非是强制性的&#xff0c;因此有不少人对部署SSL证书的必要性产生疑惑&#xff0c;网站域名一定要部署SSL证书吗&#xff1f;在本…
阅读更多...
part1. jdk8新特性详解

part1. jdk8新特性详解

1.Lambda //1.匿名内部类new Thread(new Runnable() {Overridepublic void run() {System.out.println("新线程中执行的代码&#xff1a;"Thread.currentThread().getName());}}).start();System.out.println("主线程中的代码:"Thread.currentThread().ge…
阅读更多...
CI/CD

CI/CD

介绍一下CI/CD CI/CD的出现改变了开发人员和测试人员发布软件的方式,从最初的瀑布模型,到最后的敏捷开发(Agile Development),再到今天的DevOps,这是现代开发人员构建出色产品的技术路线 随着DevOps的兴起,出现了持续集成,持续交付和持续部署的新方法,传统的软件开发和交付方…
阅读更多...
Maven（上）：Maven介绍、安装配置及工程构建

Maven（上）：Maven介绍、安装配置及工程构建

1. Maven介绍 Maven 是一款为 Java 项目管理构建、依赖管理的工具&#xff08;软件&#xff09;&#xff0c;使用 Maven 可以自动化构建、测试、打包和发布项目&#xff0c;大大提高了开发效率和质量。 Maven就是一个软件&#xff0c;掌握安装、配置、以及基本功能 &#xff…
阅读更多...
19 python快速上手

19 python快速上手

面向对象高级和应用 1. 继承【补充】1.1 mro和c3算法1.2 py2和py3区别&#xff08;了解&#xff09; 2. 内置函数补充3.异常处理3.1 异常细分3.2 自定义异常&抛出异常3.4 特殊的finally 4.反射4.1 一些皆对象4.2 import_module 反射 总结 各位小伙伴想要博客相关资料的话关…
阅读更多...
最新文章

Copyright @ 2022~2023