Studying-代码随想录训练营day13| 二叉树理论基础、二叉树递归遍历、二叉树迭代遍历、二叉树层序遍历

第十三天，💪(ง •_•)ง💪，编程语言：C++

目录

二叉树理论基础

二叉树的种类：

二叉树的存储方式

二叉树的遍历方式 

二叉树的定义：

二叉树递归遍历

二叉树的迭代遍历 

二叉树的层次遍历

102.二叉树的层序遍历

层次遍历相关的力扣题 

107.二叉树的层次遍历 II

199.二叉树的右视图

637.二叉树的层平均值

429.N叉树的层序遍历 

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

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

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

104.二叉树的最大深度

111.二叉树的最小深度

总结 

二叉树理论基础

文档讲解：代码随想录二叉树理论基础

二叉树的种类：

1.满二叉树：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。

2.完全二叉树： 完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。

3.二叉搜索树： 前面介绍的树，都没有数值的，而二叉搜索树是有数值的了，二叉搜索树是一个有序树。它保证：若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉排序树。

4.平衡二叉树： 又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

注意：在c++中map、set、multimap，multiset的底层实现都是平衡二叉搜索树，所以map、set的增删操作时间时间复杂度是logn。

二叉树的存储方式

二叉树可以链式存储（指针），也可以顺序存储（数组）。

1.链式存储：通过指针把分布在各个地址的节点串联。

2.顺序存储： 父节点的数组下标是 i，那么它的左孩子是 i * 2 + 1，右孩子是 i * 2 + 2。

二叉树的遍历方式 

二叉树的遍历方式分为：1.深度优先遍历：先往深走，遇到叶子节点再往回走；2.广度优先遍历：一层一层的去遍历。

1.深度优先遍历：前序遍历、中序遍历、后序遍历。

前序遍历：中左右；中序遍历：左中右；后续遍历：左右中

注：深度优先遍历代码实现一般会使用递归法来实现 前中后序遍历，同时栈其实也是递归的一种实现结构，因此前中后序遍历的逻辑其实也可以借助栈使用递归的方式来实现。

2.广度优先遍历：层次遍历。

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

这也是栈与队列的一个应用场景。

二叉树的定义：

二叉树有两种存储方式顺序存储，和链式存储，顺序存储就是用数组来存，定义一个数组。

链式存储定义：

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

二叉树的定义和链表是差不多的，相对于链表 ，二叉树的节点里多了一个指针， 有两个指针，指向左右孩子。

二叉树递归遍历

文档讲解：代码随想录二叉树递归遍历

视频讲解：手撕二叉树递归遍历

力扣题目：前序遍历、后续遍历、中序遍历

学习：

1.递归三要素：确定递归函数的参数和返回值；确定终止条件；确定单层递归的逻辑：

  • 确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，明确每次递归的返回值是什么，进而确定递归函数的返回类型。

  • 确定终止条件： 明确终止条件，避免出现栈溢出的错误。操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。

  • 确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

以前序遍历为例：

确定递归函数的参数和返回值：因为要打印出前序遍历节点的数值，所以参数里需要传入vector来放节点的数值，除了这一点就不需要再处理什么数据了也不需要有返回值，所以递归函数返回类型就是void。

void traversal(TreeNode* cur, vector<int>& vec)

确定终止条件：在递归的过程中，如何算是递归结束了呢，当然是当前遍历的节点是空了，那么本层递归就要结束了，所以如果当前遍历的这个节点是空，就直接return。

if (cur == NULL) return;

确定单层递归的逻辑：前序遍历是中左右的顺序，所以在单层递归的逻辑，是要先取中节点的数值。

vec.push_back(cur->val);    // 中
traversal(cur->left, vec);  // 左
traversal(cur->right, vec); // 右

前序遍历（递归）：

//时间复杂度O(n)
//空间复杂度O(n) 递归过程中栈的开销
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void pretraversal(TreeNode* cur, vector<int>& res) {
        if (cur == nullptr) return;
        res.push_back(cur->val);
        pretraversal(cur->left, res); 
        pretraversal(cur->right, res);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        pretraversal(root, result);
        return result;
    }
};

后序遍历（递归）：

//时间复杂度O(n)
//空间复杂度O(n) 递归过程中栈的开销
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void posttraversal(TreeNode* cur, vector<int>& res) {
        //后序遍历，左右中（左右根）
        if(cur == nullptr) return;
        posttraversal(cur->left, res);
        posttraversal(cur->right, res);
        res.push_back(cur->val);
    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        posttraversal(root, result);
        return result;
    }
};

中序遍历（递归）：

//时间复杂度O(n)
//空间复杂度O(n) 递归过程中栈的开销
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void intraversal(TreeNode* cur, vector<int>& res) {
        //中序遍历，左中右（左根右）
        if (cur == nullptr) return;
        intraversal(cur->left, res);
        res.push_back(cur->val);
        intraversal(cur->right, res);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        intraversal(root, result);
        return result;
    }
};

二叉树的迭代遍历 

文档讲解：代码随想录迭代遍历

视频讲解：手撕迭代遍历（前序、后序）、手撕迭代遍历（中序）

迭代遍历：不使用递归的方式，而是使用栈结构更加直观的表现遍历过程。

实现原理：递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，这就是递归为什么可以返回上一层位置的原因。

前序遍历（迭代法）：前序遍历是中左右，每次先处理的是中间节点，那么先将根节点放入栈中，然后将右孩子加入栈，再加入左孩子。

注意：此处先加入右孩子，再假如左孩子的原因是因为，栈是先进后出的结构，左节点后进栈才会被先处理。

//时间复杂度O(n)
//空间复杂度O(n)，迭代过程中显式栈的开销，平均情况下为O(log⁡n)，最坏情况下树呈现链状，为O(n)。
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        //判断根节点是否为空，初始化栈
        if(root != nullptr) st.push(root);
        while(!st.empty()) {
            //取出处理节点
            TreeNode* tmp = st.top();
            result.push_back(tmp->val);
            st.pop();
            //每次先载入处理节点的右节点再载入左节点，由于栈先进后出的特性，会先处理后进入的左节点
            if(tmp->right) st.push(tmp->right); //空节点不入栈
            if(tmp->left) st.push(tmp->left);   //空节点不入栈
        }
        return result;
    }
};

后序遍历（迭代法）： 先序遍历是中左右，后序遍历是左右中，那么我们只需要调整一下先序遍历的代码顺序，就变成中右左的遍历顺序，然后在反转result数组，输出的结果顺序就是左右中了。

 

//时间复杂度、空间复杂度同上
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> result;
        if (root == NULL) return result;
        st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            st.pop();
            result.push_back(node->val);
            //相较于前序遍历更换顺序，结果变为中右左（前序遍历为中左右）
            if (node->left) st.push(node->left); // 空节点不入栈
            if (node->right) st.push(node->right); // 空节点不入栈
        }
        reverse(result.begin(), result.end()); // 将结果反转之后就是左右中的顺序了
        return result;
    }
};

中序遍历（迭代法）：中序遍历存在不同之处，中序遍历需要一直遍历到左下角才开始处理元素，元素的遍历过程和处理过程存在分离。 

方法：将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记。标记的方法为在处理的节点放入栈之后，紧接着放入一个空指针，以此作为标记。

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        //用以指示当前需要处理的节点
        TreeNode* cur;

        if(root != nullptr) st.push(root);
        while(!st.empty()) {
            cur = st.top();
            //当前节点不为空时，意味着还需要搜寻左节点是否存在
            if(cur != nullptr) {
                st.pop();
                if(cur->right) st.push(cur->right);//空节点不入栈

                //加入一个nullptr指针，在返回到左中右的“中”节点时进行处理
                st.push(cur);
                st.push(nullptr);

                if(cur->left) st.push(cur->left);//空节点不入栈
            }
            //当遇到nullptr节点时，意味着可以处理当前节点了
            else {
                st.pop();
                result.push_back(st.top()->val);
                st.pop();
            }
        }
        return result;
    }
};

此方法也可以用于前序遍历和后序遍历之中。

二叉树的层次遍历

文档讲解：代码随想录层次遍历

视频讲解：手撕层次遍历

102.二叉树的层序遍历

学习：层序遍历一个二叉树，就是从左到右一层一层的去遍历二叉树。此时需要借助一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

代码：

//时间复杂度O(n)
//空间复杂度O(n)
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>> result;
        //判断根节点是否为空，初始化队列
        if (root != nullptr) que.push(root);
        while(!que.empty()) {
            int size = que.size(); //确定每一层个数
            vector<int> vec; //初始化每一层数组
            while (size--) {
                TreeNode* node = que.front(); //将该层节点取出
                vec.push_back(node->val);
                que.pop();
                //将下一层节点导入，由于size是每一层的个数，所以不存在跨层导出的情况
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        return result;
    }
};

层次遍历相关的力扣题 

107.二叉树的层次遍历 II

题目：自底向上得到的结果就是自上向下的反转

代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        //自底向上得到的结果就是自上向下的反转
        queue<TreeNode*> que;
        vector<vector<int>> result;
        //判断根节点是否为空，初始化队列
        if (root != nullptr) que.push(root);
        while(!que.empty()) {
            int size = que.size(); //确定每一层个数
            vector<int> vec; //初始化每一层数组
            while (size--) {
                TreeNode* node = que.front(); //将该层节点取出
                vec.push_back(node->val);
                que.pop();
                //将下一层节点导入，由于size是每一层的个数，所以不存在跨层导出的情况
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            result.push_back(vec);
        }

        reverse(result.begin(), result.end());
        return result;
    }
};

199.二叉树的右视图

题目：右视图对每一层的操作，查询每一层最右边的节点（最后一个节点）

代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        //右视图对每一层的操作：看到每一层最右边的节点（最后一个节点）
        queue<TreeNode*> que;
        vector<int> result;
        if (root != nullptr) que.push(root);
        while(!que.empty()) {
            int size = que.size(); 
            for(int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                //遍历到最右边的节点时导入数据
                if(i == size-1) result.push_back(node->val);
                //将下一层节点导入
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return result;
    }
};

637.二叉树的层平均值

题目：求平均值对每一层的操作：求和算平均。

代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        //求平均值对每一层的操作：求和算平均
        queue<TreeNode*> que;
        vector<double> result;
        if (root != nullptr) que.push(root);
        while(!que.empty()) {
            int size = que.size(); 
            double sum = 0;
            for(int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                sum += node->val;
                //将下一层节点导入
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            result.push_back(sum/size);
        }
        return result;
    }
};

429.N叉树的层序遍历 

题目：N叉树层序遍历的不同在于，不再只是遍历左右根节点，而是要遍历该节点的所有子节点。

代码：

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/
class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        //N叉树层序遍历的不同在于，不再只是遍历左右根节点，而是要遍历该节点的所有子节点
        queue<Node*> que;
        vector<vector<int>> result;
        if (root != nullptr) que.push(root);
        while(!que.empty()) {
            int size = que.size(); 
            vector<int> vec;
            for(int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                vec.push_back(node->val);
                //将下一层节点导入
                for(auto it = node->children.begin(); it != node->children.end(); it++) {
                    if(*it) que.push(*it);
                }
            }
            result.push_back(vec);
        }
        return result;
    }
};

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

题目：遍历每一层节点，找到最大值

代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        //遍历每一层节点，找到最大值
        //层序遍历使用队列查找每一层节点
        queue<TreeNode*> que;
        vector<int> result;
        if(root != nullptr) que.push(root); 
        while(!que.empty()) {
            int size = que.size();
            int MAX =   INT_MIN; //int类型里面的最小值
            while (size--) {  //等于for(int i = 0; i < que.size(); i++)
                TreeNode* node = que.front();
                que.pop();
                MAX = max(MAX, node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);                
            }
            result.push_back(MAX);
        }
        return result;
    }
};

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

题目：遍历每一层节点，前面的节点都指向下一个节点，最后的节点指向nullptr

代码：

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;
    Node() : val(0), left(NULL), right(NULL), next(NULL) {}
    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}
    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/
class Solution {
public:
    Node* connect(Node* root) {
        //遍历每一层节点，前面的节点都指向下一个节点，最后的节点指向nullptr
        queue<Node*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            for(int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                //遍历到最后一个节点的时候单独处理
                if (i == size-1) {
                    node->next = nullptr;
                }
                else {
                    node->next = que.front();
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }        
        return root;
    }
};

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

题目：遍历每一层节点，前面的节点都指向下一个节点，最后的节点指向nullptr

代码： 

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;
    Node() : val(0), left(NULL), right(NULL), next(NULL) {}
    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}
    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/
class Solution {
public:
    Node* connect(Node* root) {
        //遍历每一层节点，前面的节点都指向下一个节点，最后的节点指向nullptr
        queue<Node*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            for(int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                //遍历到最后一个节点的时候单独处理
                if (i == size-1) {
                    node->next = nullptr;
                }
                else {
                    node->next = que.front();
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }        
        return root;
    }
};

104.二叉树的最大深度

题目：最大深度就是需要遍历的层数

代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode* root) {
        //最大深度就是需要遍历的层数
        queue<TreeNode*> que;
        int depth = 0; //记入深度
        if (root != nullptr) que.push(root);

        while (!que.empty()) {
            int size = que.size();
            //每进行循环深度加1
            depth++;
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return depth;
    }
};

111.二叉树的最小深度

题目：最小深度，就是在遍历每一层节点的时候，如果发现该节点没有子节点则停下循环。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int minDepth(TreeNode* root) {
        //最小深度，就是在遍历每一层节点的时候，如果发现该节点没有子节点则停下循环。
        queue<TreeNode*> que;
        int depth = 0; //记入深度
        if (root != nullptr) que.push(root);

        while (!que.empty()) {
            int size = que.size();
            //每进行循环深度加1
            depth++;
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
                if (node->right == nullptr && node->left == nullptr) {
                    return depth;
                }
            }
        }
        return depth;
    }
};

总结 

学习有关树的基本知识，树的两大遍历方式，深度遍历和层次遍历。深度遍历可以使用递归也可以使用栈实现，层次遍历一般使用队列实现。

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

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

相关文章

数据库新技术【分布式数据库】

数据库新技术【分布式数据库】

文章目录 第一章 概述1.1 基本概念1.1.1 分布式数据库1.1.2 数据管理的透明性1.1.3 可靠性1.1.4 分布式数据库与集中式数据库的区别 1.2 体系结构1.3 全局目录1.4 关系代数1.4.1 基操1.4.2 关系表达式1.4.3 查询树 第二章 分布式数据库的设计2.1 设计策略2.2 分布设计的目标2.3…
阅读更多...
深度学习入门5——为什么神经网络可以学习？

深度学习入门5——为什么神经网络可以学习？

在理解神经网络的可学习性之前&#xff0c;需要先从数学中的导数、数值微分、偏导数、梯度等概念入手&#xff0c;从而理解为什么神经网络具备学习能力。 1.数值微分的定义 先从导数出发理解什么是梯度。某一点的导数直观理解就是在该点的切线的斜率。在数学中导数表示某个瞬…
阅读更多...
Spring的事务步骤

Spring的事务步骤

一、事务处理方案&#xff1a; Spring框架中提供的事务处理方案&#xff1a;一共有两种&#xff1a; 1.适合中小项目使用的&#xff0c; 注解方案&#xff1a; 注解的方式做事务用起来简单&#xff0c;灵活&#xff0c;方便&#xff0c;中小型项目中用它比较方便&#xff0c…
阅读更多...
白酒：酒文化的教育价值与实践

白酒：酒文化的教育价值与实践

酒文化作为中国传统文化的重要组成部分&#xff0c;具有丰富的教育价值。云仓酒庄的豪迈白酒作为酒文化的品牌之一&#xff0c;在传承与发展中不断挖掘和发挥酒文化的教育价值。 首先&#xff0c;豪迈白酒有责任传承丰富的历史文化知识。从酒的起源、酿造技艺、酒器文化到酒礼酒…
阅读更多...
Github上传大于100M的文件（ubuntu教程）

Github上传大于100M的文件（ubuntu教程）

安装Git-lfs Git Large File Storage (LFS) 使用 Git 内部的文本指针替换音频样本、视频、数据集和图形等大文件&#xff0c;同时将文件内容存储在 GitHub.com 或 GitHub Enterprise 等远程服务器上。官网下载&#xff1a;https://git-lfs.github.com/ ./install.sh上传 比如…
阅读更多...
教你如何安装 IntelliJ IDEA

教你如何安装 IntelliJ IDEA

安装 IntelliJ IDEA 的步骤通常如下&#xff0c;这里提供的是基于 Windows 系统的安装指南。 下载 IntelliJ IDEA 1. 访问 JetBrains 官方网站&#xff1a;[https://www.jetbrains.com/idea/download/](Download IntelliJ IDEA – The Leading Java and Kotlin IDE) 2. 选择适…
阅读更多...
一文带你入门【论文排版】利器·LaTeX ｜Macos

一文带你入门【论文排版】利器·LaTeX ｜Macos

小罗碎碎念 我在刚开始写公众号的时候&#xff0c;写过一期推文&#xff0c;详细的讲解过如何使用LaTeX快速的进行论文排版。不过当时用的是windows的系统&#xff0c;这一次把Mac端的教程补上。 windows系统教程 https://zhuanlan.zhihu.com/p/677481269 LaTeX是一种流行的排…
阅读更多...
【UIDynamic-动力学-UICollisionBehavior-action Objective-C语言】

【UIDynamic-动力学-UICollisionBehavior-action Objective-C语言】

一、我们说，这个碰撞行为啊，collision，它里边还有一个属性，叫做action，它能够干什么，它能够实时的去监听， 1.实时的去监听，我们当前的这个view的一个frame的变化， 它会调用action的方法，实际上，action方法，它是一个block，然后呢，view的frame变化的时候，它会一直…
阅读更多...
Keil生成bin文件

Keil生成bin文件

keil软件默认是只生成hex文件虽然也可以下载但是有时候要用到bin文件 只需要加入以下代码在keil软件中即可 fromelf.exe --bin -o “$LL.bin” “#L” 然后编译 输出信息&#xff0c;可以看到已经生成了bin文件
阅读更多...
Nacos从入门到实战

Nacos从入门到实战

一、Nacos介绍 1.什么是Nacos 官方&#xff1a;一个更易于构建云原生应用的动态服务发现&#xff08;Nacos Discovery&#xff09;、服务配置&#xff08;Nacos Config&#xff09;和服务管理平台 集 注册中心配置中心服务管理 平台 注册中心&#xff1a;把所有的服务注册进去…
阅读更多...
第6章 设备驱动程序（3）

第6章 设备驱动程序（3）

目录 6.5 块设备操作 6.5.1 块设备的表示 6.5.2 数据结构 6.5.3 向系统添加磁盘和分区 6.5.4 打开块设备文件 本专栏文章将有70篇左右&#xff0c;欢迎关注&#xff0c;查看后续文章。 6.5 块设备操作 特点&#xff1a; 随机访问任意位置。 固定块大小的传输。 块设备在内…
阅读更多...
MySQL进阶——索引【核心】

MySQL进阶——索引【核心】

目录 1索引概述 2索引结构 2.1 B-Tree&#xff08;多路平衡查找树&#xff09; 2.2 BTree 2.3 hash 3索引分类 3.1MySQL中分4类 3.2 InnoDB存储引擎分两类&#xff08;SQL优化中重要&#xff09; 4索引语法 4.1创建和查看索引 4.2删除索引 5 SQL性能分析 5.1 查看执…
阅读更多...
Ubuntu安装docker 详细教程

Ubuntu安装docker 详细教程

Ubuntu安装docker&#xff0c;以及docker compose踩了一步一步的坑&#xff0c;真的特别抓马&#xff01;&#xff01;&#xff01; 因此分享我的安装教程和踩坑&#xff0c;希望给大家一些帮助吧 安装详细教程 卸载docker停止 docker 运行使用以下命令来卸载 Docker 软件包及其…
阅读更多...
国产数据库中读写分离实现机制

国产数据库中读写分离实现机制

在数据库高可用架构下会存在1主多备的部署&#xff0c;备节点可以根据业务场景分发一部分流量以充分利用资源&#xff0c;并减轻主库的压力&#xff0c;因此在数据库的功能上需要读写分离来实现。 充分利用备节点的资源&#xff0c;提升业务的吞吐量&#xff1b;防止运维等非业…
阅读更多...
助力低空经济-eVTOL/无人机ADS-B航管应答机选型指南

助力低空经济-eVTOL/无人机ADS-B航管应答机选型指南

一、低空经济概述 “低空经济”在今年全国两会首次写入政府工作报告。近日&#xff0c;工业和信息化部、科学技术部、财政部、中国民用航空局印发《通用航空装备创新应用实施方案&#xff08;2024—2030年&#xff09;》&#xff0c;提出到2030年&#xff0c;推动低空经济形成…
阅读更多...
c语言回顾-结构体（2）

c语言回顾-结构体（2）

前言 前面讲了结构体的概念&#xff0c;定义&#xff0c;赋值&#xff0c;访问等知识&#xff0c;本节内容小编将讲解结构体的内存大小的计算以及通过结构体实现位段&#xff0c;话不多说&#xff0c;直接上干货&#xff01;&#xff01;&#xff01; 1.结构体内存对齐 说到计…
阅读更多...
自建消息推送工具 Gotify 实现消息私有化通知

自建消息推送工具 Gotify 实现消息私有化通知

本文首发于只抄博客，欢迎点击原文链接了解更多内容。 前言 之前分享了如何通过 Webhook 将 VPS 与 NAS 上部署的应用消息推送到钉钉、飞书、企业微信，但是对于部分用户来说，可能因为以下种种原因，不方便使用常见的办公 IM 软件来进行消息推送： 消息涉及隐私敏感信息，不希…
阅读更多...
11.6.k8s实战-节点扩缩容

11.6.k8s实战-节点扩缩容

目录 一&#xff0c;需求描述 二、集群缩容-节点下线 1&#xff0c;节点下线案例说明 2&#xff0c;查看现有节点 3&#xff0c;查看所有名称空间下的pod ​编辑4&#xff0c;驱逐下线节点的pod 5&#xff0c;驱逐后再次查看pod 6&#xff0c;驱逐pod后再次查看节点信息…
阅读更多...
新书速览|Ubuntu Linux运维从零开始学

新书速览|Ubuntu Linux运维从零开始学

《Ubuntu Linux运维从零开始学》 本书内容 Ubuntu Linux是目前最流行的Linux操作系统之一。Ubuntu的目标在于为一般用户提供一个最新的、相当稳定的、主要由自由软件构建而成的操作系统。Ubuntu具有庞大的社区力量&#xff0c;用户可以方便地从社区获得帮助。《Ubuntu Linux运…
阅读更多...
熟练一种编程语言再学另一种语言时，叠的是buff还是debuff？

熟练一种编程语言再学另一种语言时，叠的是buff还是debuff？

在大多数情况下&#xff0c;尤其是对于广泛使用的高级编程语言&#xff0c;它们之间存在正向的相互促进作用&#xff0c;熟练使用一种语言后再去学习另一种语言&#xff0c;大概率能叠个buff。 首先&#xff0c;学习编程语言的基础是通用的&#xff0c;比如软硬件和网络基础、算…
阅读更多...
最新文章

Copyright @ 2022~2023