数据结构基础--------【二叉树题型】

news2024/9/30 23:40:11

1、前提(待补充)

1.**DFS（Depth First Search）😗*递归法得到最终的数组（深度优先算法）

其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，如果遇到死路就往回退，回退过程中如果遇到没探索过的支路，就进入该支路继续深入，每个节点只能访问一次。

深度优先搜索应用：先序遍历，中序遍历，后序遍历。二叉树的前序、中序、后序遍历，本质上可以认为是深度优先遍历。是一种回溯思想。

2.BFS（Breadth First Search）:迭代法实现层序遍历，每次遍历二叉树的某一层。
它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。基本过程，BFS是从根节点开始，沿着树(图)的宽度遍历树(图)的节点。如果所有节点均被访问，则算法中止。一般用队列数据结构来辅助实现算法。

广度优先搜索应用：层序遍历、最短路径、求二叉树的最大高度、由点到面遍历图、拓扑排序

2、题型

1、广度优先BFS

按照每层队列入队出队的逻辑，依次访问每层元素：

【102】二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。（即逐层地，从左到右访问所有节点）。

    vector<vector<int>> levelOrder(TreeNode* root){
        vector<vector<int>> ret ;
        if(!root) return ret;
        queue <TreeNode*> q;//定义辅助队列
        q.push(root);
        while(!q.empty()){
            int csize = q.size();//每层的列数
            ret.push_back(vector<int>());//ret中添加空的一维数组 创建
            for(int i =1;i<=csize;i++){
                auto node  = q.front();
                q.pop();
                ret.back().push_back(node->val);
                if(node->left)q.push(node->left);//需要更新q,否则第一次 q.pop()以后，q就为空了
                if(node->right)q.push(node->right);
            }
        }
        return ret;
    }

root = [3,1,4,null,2] 则返回的应该改是{{3}，{1，4}，{2}}

【1302】层数最深叶子节点的和

给你一棵二叉树的根节点 root ，请你返回 层数最深的叶子节点的和 。
解:到ret的最后一层，然后再累加。每一层更新一下sum

【429】N叉树的层序遍历

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。
比二叉树的分支更多了，不止左右子树，所以分组的时候要用for循环去分

/*
// 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) {
        vector<vector<int>>ret;//定义返回向量
        queue<Node*> q;//定义辅助队列
        if(!root)return ret;
        q.push(root);//队头push进
        while(!q.empty()){
            ret.push_back(vector<int>());
            int csize = q.size();
            for(int i =1;i<=csize;i++){
                auto node = q.front();//取队头
                q.pop();//弹出队头
                ret.back().push_back(node->val);//每次都是在数组尾更新值
                //N叉树需要去遍历每个值
                for(int j = 0;j< node->children.size();j++){
                    if(node->children[j])q.push(node->children[j]);
                }
            }
        }
       // reverse(ret.begin(), ret.back());
        return ret;

    }
};

【199】二叉树右视图

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

这道题还是层序遍历的变形，需要注意的是熟练掌握cize = q.size()是每一层的列数，灵活运用这一特质。

/**
 * 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) {
        vector<int> ret;//定义返回数组
        if(!root)return ret;//如果二叉树为空，返回空数组
        queue<TreeNode*>q;//定义辅助队列
        q.push(root);//将根节点push进队列
        while(!q.empty()){
            int cize = q.size();//列数(！！)
            for(int i = 0;i<cize;i++){
                auto node = q.front();
                q.pop();
                if(i == (cize -1))ret.push_back(node->val);//返回每一层最后
                if(node->left)q.push(node->left);
                if(node->right)q.push(node->right);
            }
        }
        return ret;
    }
};

【637】二叉树的层平均值

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

特别注意：返回如果有精度要求，那么每层和就要设为double 类型。

/**
 * 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) {
        vector<double> ret;//定义返回数组
        if(!root)return ret;
        queue<TreeNode*>q;//定义辅助队列
        q.push(root);//根结点入队头
        while(!q.empty()){
            int csize = q.size();//每一层的列数
            double sum = 0;//每层和 double类型
            for(int i = 0;i< csize;i++){
                auto node = q.front();//取队头
                q.pop();
                sum+=node->val;
                if(node->left)q.push(node->left);
                if(node->right)q.push(node->right);
            }
            ret.push_back(sum/csize);//每层求均值
        }
        return ret;
    }
};

【515】找到每行最大值

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

/**
 * 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) {
        vector<int> ret;//定义返回数组
        if(!root)return ret;
        queue<TreeNode*> q;//定义辅助队列
        q.push(root);//把树根结点推入
        vector<vector<int>> aux;//定义辅助一维向量数组
        while(!q.empty()){
            aux.push_back(vector<int>());
            int csize = q.size();//列数
            for(int i=0;i<csize;i++){
                auto node = q.front();
                q.pop();
                aux.back().push_back(node->val);
                if(node->left)q.push(node->left);
                if(node->right)q.push(node->right);;
            }
        }
        //看作一维向量数组
        for(auto row:aux){//遍历每行
            int max = row[0];//取第一个值作为比较
            for(int col:row){
                if(col>max){
                    max = col;
                }
            }
            ret.push_back(max);
        }
        return ret;
    }
};

【103】二叉树的锯齿形层序遍历

给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[20,9],[15,7]]

/**
 * 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> reverse_level(vector<int> vec){//reverse函数
        int vecsize = vec.size();
        int temp =0;
        for(int i=0;i<vecsize/2;i++){//遍历到中间
            temp = vec[vecsize-i-1];
            vec[vecsize-i-1] = vec[i];
            vec[i] = temp; 
        }
        return vec; 
    }

    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>> ret;//定义返回的一维数组
        if(!root)return ret;
        queue<TreeNode*> q;//定义辅助队列
        q.push(root);//把root推入q队列
        while(!q.empty()){
            ret.push_back(vector<int>());//推入一维空数组
            int csize = q.size();//列数
            for(int i =0;i<csize;i++){
                auto node = q.front();
                q.pop();
                ret.back().push_back(node->val);
                if(node->left)q.push(node->left);
                if(node->right)q.push(node->right);
            }

        }
        int count_level =0;
        for(vector<int> row:ret){
            count_level++;//更新层数
            if(count_level%2==0){//偶数层
             ret[count_level-1] = reverse_level(row);//偶数层颠倒
            }
        }
        
        return ret;
    }
};

2、深度优先DFS

2.1.二叉树的高度和深度

深度：根节点—>该节点 最长边数 +1（前序）

高度：叶节点---->该节点 最长边数 +1（后序）

对于二叉树，深度：根节点到它的叶节点，高度：叶节点到它的根节点。

注意：树的高度和深度都是一样的，但是具体到树的某个节点，深度和高度就是不一样的。

在这里插入图片描述
如上图树的高度和深度都是4（看层数=边数+1），节点8 的高度是2 深度是3（都是从1开始的），节点5的高度是4 深度是3。

假设我构造一个二叉树：

        5
       / \
      2   3
     / \   
    1   4

我要求他的深度：此时先遍历左子树再遍历右子树：5->2->1 到底返回1，回溯到2再到4 ，返回1，再到2，返回2。5–>3返回1，再到5，返回3和2的最大值 3。
在这里插入图片描述

//求二叉树的高度/深度
#include <iostream>
#include <stdio.h>
using namespace std;

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) {}
};

int high(TreeNode* node){
    if(!node)return 0;
    cout<<"node is"<<node->val<<endl;
    int h_left = high(node->left);
    int h_right=high(node->right);
    int res = h_right>h_left ? h_right+1:h_left+1;
    cout<<"res is"<<res<<endl;
    return res;
}

int main() {
    TreeNode* node = new TreeNode(5);
    TreeNode* nodel = new TreeNode(2);
    TreeNode* noder = new TreeNode(3);
    TreeNode* nodell = new TreeNode(1);
    TreeNode* nodelr = new TreeNode(4);
    node->left = nodel;
    node->right =noder;
    nodel->left =nodell;
    nodel->right=nodelr;
    int nodehigh =0;
    nodehigh = high(node);
    cout<<"final res:"<<nodehigh<<endl;
    return 0;
}

【100】验证树是否一致

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的.

/**
 * 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:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        if(p==nullptr || q== nullptr)return false;
        if(p == nullptr&& q == nullptr)return true;
        if(p->val != q->val)return false;
        return isSameTree(p->left, q->left)&&isSameTree(p->right, q->right);
    }
};

if(p==NULL&&q==NULL) return true;
if(p==NULL||q==NULL) return false;
if(p->val!=q->val) return false;
return isSameTree(p->left,q->left)&&isSameTree(p->right,q->right);

【108】AVL树

递归

给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。

高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。

由于是升序序列，于是可以选择中间元素作为根节点。

示例1:

输入：nums = [-10,-3,0,5,9]
输出：[0,-3,9,-10,null,5]
解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：
//如果看成链式结构的话，发现顺序并没有发生变化
image-20230817105118425 image-20230817105148170 


/**
 * 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:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        int len = nums.size();//得到数组长度  每次取mid
        return dfs(nums,0,len);
    }

    TreeNode* dfs(vector<int>& vec,int left,int right){
        if(left>=right)return NULL;//注意也不能等于 len = 0 空节点
        int mid = (left+right)/2;//得到mid
        TreeNode* curr= new TreeNode(vec[mid]);//！新建结点 值
        curr->left = dfs(vec,left,mid);//递归 左节点
        curr->right = dfs(vec,mid+1,right);//右节点
        return curr;
    }
};

这道题非常有意思是如何去创建这个新的结点。首先要更新节点值：

TreeNode* curr = new TreeNode(val);//创建一个节点,并且存入值

curr->left = …

curr->right = …

规定左右子树。

【144】前序遍历

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。前中后序遍历都用递归的方式去实现。

输入：root = [1,null,2,3]
输出：[1,2,3]//返回的是值，所以vector<int>
输入：root = []
输出：[]
输入：root = [1]
输出：[1]
输入：root = [1,null,2]
输出：[1,2]

可以从题解中得出，先序遍历的顺序是NLR，基本上就是输入什么，输出什么，去掉null就好了。特别的，当root为空的时候，应该返回空集。

/**
 * 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> preorderTraversal(TreeNode* root) {
        vector<int> vec;//初始化返回向量
        traversal(root,vec);
        return vec;
    }
    //回归
    void traversal(TreeNode* curr,vector<int>& vec){
        if(NULL == curr)return;//如果root为空,则直接返回空向量
        //如果root不为空 前序遍历
        vec.push_back(curr->val);//中
        traversal(curr->left,vec);//左
        traversal(curr->right,vec);//右
    }
    
};

用全局变量会加快一点速度

class Solution {
public:
    vector<int> vec;//返回节点值 的前序遍历向量
    vector<int> preorderTraversal(TreeNode* root) {
        traversal(root);
        return  vec;
    }
    void traversal(TreeNode* curr){
        if(!curr)return;
        vec.push_back(curr->val);//返回的是节点值
        traversal(curr->left);
        traversal(curr->right);
    }
    
};

【94】中序遍历

给你二叉树的根节点 root ，返回它节点值的 中序 遍历。中序遍历LNR，Inorder

输入：root = [1,null,2,3]
输出：[1,3,2]
输入：root = []
输出：[]
输入：root = [1]
输出：[1]

/**
 * 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> inorderTraversal(TreeNode* root) {
		vector<int> vec;//声明返回向量
        traversal(root,vec);
        return vec;
    }
    void traversal(TreeNode* root,vector<int> &vec)
    {
        if(root ==nullptr)return;
        traversal(root->left,vec);//L
        vec.push_back(root->val);//N
        traversal(root->right,vec);//R
    }
};

【145】后续遍历

给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。

输入：root = [1,null,2,3]
输出：[3,2,1]
输入：root = []
输出：[]
输入：root = [1]
输出：[1]

/**
 * 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> postorderTraversal(TreeNode* root) {
		vector<int> vec;//声明返回向量 也可以返回到全局变量去
        traversal(root,vec);
        return vec;
    }
    void traversal(TreeNode* root,vector<int> &vec)
    {
        if(root ==nullptr)return;
        traversal(root->left,vec);//L
        traversal(root->right,vec);//R
         vec.push_back(root->val);//N
    }
};

【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) {}
 * };
 */
//递归问题
#include<algorithm>
class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root == nullptr)return 0;//边界条件
        return max(maxDepth(root->left),maxDepth(root->right))+1;//非边界条件逻辑
        //加一是把当前结点算进去了 比如最后一个叶结点深度是0，但是高度是1
    }
};

//其中max函数是包含在algorithm中的
template<class T>
const T& max(const T&a,const T&b)
{
    return (a < b)?b:a;
}

树为什么是一种递归问题？

image-20230703205635250

他这个遍历的方式是根结点-左-右，这种常识要记住

maxDepth是怎么运行的：递归

演示网站：Python Tutor code visualizer: Visualize code in Python, JavaScript, C, C++, and Java

递归就是要明白代码的边界条件和非边界条件的逻辑。

计算机怎么执行递归的？栈，最后放进去的结点最先出来，空间复杂度o(n)

【104】二叉树最大深度

输入：root = [3,9,20,null,null,15,7]
输出：3

二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

/**
 * 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) {}
 * };
 */
//递归问题
#include<algorithm>
class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root == nullptr)return 0;//边界条件
        return max(maxDepth(root->left),maxDepth(root->right))+1;//非边界条件逻辑
        //加一是把当前结点算进去了 比如最后一个叶结点深度是0，但是高度是1
    }
};

【559】N叉树的最大深度

给定一个 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:
    int maxDepth(Node* root) {
        if(root == nullptr)return 0;
        int depth = 0;//初始化深度
        //int n = root->children.size();
        for(int i= 0;i<root->children.size();i++){
            depth = max(depth,maxDepth(root->children[i]));//第二层马上跳到第三层
        }
        return depth + 1;
        
    }
};

用拷贝的形式传入形参

用数组的方式比容器的快

【111】二叉树的最小深度

给定一个二叉树，找出其最小深度。（最小层数）最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

**说明：**叶子节点是指没有子节点的节点。（易错点：当数退化成链表的时候，最小深度不是1，而是从根节点到叶子节点的长度）

/**
 * 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) {
        if(root == nullptr)return 0;
        //线性表情况
        if(root->left==nullptr && root->right != nullptr)return minDepth(root->right)+1;//这是一个递归
        if(root->right==nullptr && root->left != nullptr)return minDepth(root->left)+1;//这是一个递归
        //一般情况
        return min(minDepth(root->left),minDepth(root->right))+1;
    }
};

【543】二叉树的直径

给你一棵二叉树的根节点，返回该树的 直径 。

二叉树的 直径 是指树中任意两个节点之间最长路径的 长度 。这条路径可能经过也可能不经过根节点 root 。

两节点之间路径的 长度 由它们之间边数表示。

总结：做DFS的题都可以把题目往左右子树深度去想

这里的直径 = 左子树深度+右子树深度（不包括根节点）

错误写法：得到的都是0

/**
 * 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) {}
 * };
 */
//根节点为root的二叉树的直径 = 左子树的最大深度（不包括根节点）+右子树的最大深度（不包括根节点）
class Solution {
public:
    int ans = 0;
    int depth(TreeNode* rt){//回溯要单独写
        if(!rt)return 0;
        int L = depth(rt->left);//左儿子为根的子树深度
        int R = depth(rt->right);
        ans = max(ans,L+R);//计算diameter（返回每个节点的最大直径）
        return max(L,R)+1;//返回节点深度 正常深度应该+1
    }
    
    int diameterOfBinaryTree(TreeNode* root) {
        depth(root);
        return ans;
    }
};

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

MMGPL: 多模态医学数据分析与图提示学习| 文献速递-基于深度学习的多模态数据分析与生存分析

MMGPL: 多模态医学数据分析与图提示学习| 文献速递-基于深度学习的多模态数据分析与生存分析

Title 题目 MMGPL: Multimodal Medical Data Analysis with Graph Prompt Learning MMGPL: 多模态医学数据分析与图提示学习 01 文献速递介绍 神经学障碍&#xff0c;包括自闭症谱系障碍&#xff08;ASD&#xff09;&#xff08;Lord等&#xff0c;2018年&#xff09;和阿…
阅读更多...
使用Maven命令将第三方jar包安装到maven本地仓库

使用Maven命令将第三方jar包安装到maven本地仓库

使用Maven命令将第三方jar包安装到maven本地仓库 事例&#xff1a; 第三方jar包 &#xff1a;common-pojo-1.0-SNAPSHOT.jar Maven命令 mvn install:install-file -Dfilejar包在本地磁盘的路径 -DgroupId组织名称 -DartifactId项目名称 -Dversion版本号 -Dpackaging打包方式 完…
阅读更多...
LLM-大模型私有模型训练步骤方法总结

LLM-大模型私有模型训练步骤方法总结

文章目录 前言预训练&#xff08;Pretrained&#xff09;步骤模型选择确定应用场景数据采集清理数据预训练模型 微调&#xff08;Fine Tuning&#xff09;合规对齐 (Alignment)集成 LLM 至 APP总结 前言 本文将从宏观层面说明 LLM 私有模型的训练步骤&#xff0c;包括预训练&a…
阅读更多...
【多媒体】Java实现MP4和MP3音视频播放器【JavaFX】【更多功能的播放器】【音视频播放】

【多媒体】Java实现MP4和MP3音视频播放器【JavaFX】【更多功能的播放器】【音视频播放】

在Java中播放视频可以使用多种方案&#xff0c;最常见的是通过Swing组件JFrame和JLabel来嵌入JMF(Java Media Framework)或Xuggler。不过&#xff0c;JMF已经不再被推荐使用&#xff0c;而Xuggler是基于DirectX的&#xff0c;不适用于跨平台。而且上述方案都需要使用第三方库。…
阅读更多...
前端构建工具（webpackvite）

前端构建工具（webpackvite）

这里写目录标题 构建工具webpack介绍配置文件简介entryoutputloaderbabel插件开发服务器&#xff08;webpack-dev-server&#xff09;soureMap vite 构建工具 当我们习惯了在node中编写代码的方式后&#xff0c;在回到前端编写html、css、js这些东西会感觉到各种的不便。比如:…
阅读更多...
【PB案例学习笔记】-30动态打开窗口

【PB案例学习笔记】-30动态打开窗口

写在前面 这是PB案例学习笔记系列文章的第30篇&#xff0c;该系列文章适合具有一定PB基础的读者。 通过一个个由浅入深的编程实战案例学习&#xff0c;提高编程技巧&#xff0c;以保证小伙伴们能应付公司的各种开发需求。 文章中设计到的源码&#xff0c;小凡都上传到了gite…
阅读更多...
【C++报错已解决】Multiple Definition of Symbol

【C++报错已解决】Multiple Definition of Symbol

&#x1f3ac; 鸽芷咕&#xff1a;个人主页 &#x1f525; 个人专栏: 《C干货基地》《粉丝福利》 ⛺️生活的理想&#xff0c;就是为了理想的生活! 文章目录 引言一、问题描述1.1 报错示例1.2 报错分析1.3 解决思路 二、解决方法&#xff1a;方法一&#xff1a;使用extern关键…
阅读更多...
Linux驱动开发-03字符设备驱动框架搭建

Linux驱动开发-03字符设备驱动框架搭建

一、字符设备驱动开发步骤 驱动模块的加载和卸载&#xff08;将驱动编译模块&#xff0c;insmod加载驱动运行&#xff09;字符设备注册与注销&#xff08;我们的驱动实际上是去操作底层的硬件&#xff0c;所以需要向系统注册一个设备&#xff0c;告诉Linux系统&#xff0c;我有…
阅读更多...
最新知识付费系统3.0整站+自动采集同步插件

最新知识付费系统3.0整站+自动采集同步插件

支持分类替换 将主站同步过来的文章分类进行替换 支持自定义文章作者&#xff08;选择多个作者则同步到的文章作者将会随机分配&#xff09; 支持添加黑名单分类 添加后 如果同步过来的文章包含黑名单分类将不会发布文章 自动检测同步&#xff0c;无需人工值守以及挂采集软件…
阅读更多...
ProFuzzBench入门教学——使用（Ubuntu22.04）

ProFuzzBench入门教学——使用（Ubuntu22.04）

ProFuzzBench是网络协议状态模糊测试的基准测试。它包括一套用于流行协议&#xff08;例如 TLS、SSH、SMTP、FTP、SIP&#xff09;的代表性开源网络服务器&#xff0c;以及用于自动执行实验的工具。详细参考&#xff1a;阅读笔记——《ProFuzzBench: A Benchmark for Stateful …
阅读更多...
研华运动控制卡在LabVIEW中的应用

研华运动控制卡在LabVIEW中的应用

在现代工业和科研领域中&#xff0c;精密运动控制系统的需求日益增加。这些系统广泛应用于自动化生产线、精密机械加工、机器人控制、光学仪器调试和实验室自动化设备等诸多领域。本文以研华公司的运动控制卡为例&#xff0c;详细介绍其在LabVIEW中的应用&#xff0c;展示如何通…
阅读更多...
习题练习以

习题练习以

题意&#xff1a;求i&M的popcount的和&#xff0c;i属于0……N 主要思路还是变加为乘。 举个例子N22&#xff0c;即10110 假设M的第3位是1&#xff0c;分析N中&#xff1a; 00110 00111 00100 00101 发现其实等价于 0010 0011 0000 0001 也就是左边第4位和第5…
阅读更多...
数据库基础练习4

数据库基础练习4

准备 create table dept (dept1 int ,dept_name varchar(11)) charsetutf8; create table emp (sid int ,name varchar(11),age int,worktime_start date,incoming int,dept2 int) charsetutf8;insert into dept values(101,财务),(102,销售),(103,IT技术),(104,行政);INSERT …
阅读更多...
诸葛亮的连环计 责任链模式

诸葛亮的连环计 责任链模式

“万事谋定而后动&#xff0c;一环扣一环&#xff0c;方能成大事。” 在三国时期&#xff0c;诸葛亮以其超凡的智慧闻名天下。在他众多的计策中&#xff0c;有一个鲜为人知却极具智慧的连环计&#xff0c;完美诠释了现代软件设计中的责任链模式。让我们一同探索这个巧妙的计策…
阅读更多...
【安全设备】堡垒机

【安全设备】堡垒机

一、什么是堡垒机 安全运维审计与风险控制系统即堡垒机&#xff0c;前身为跳板机&#xff0c;跳板机是一个简单的管理设备&#xff0c;但缺乏对运维操作的控制和审计能力。堡垒机是一种特定的网络安全设备&#xff0c;用于在一个网络环境中保护数据和网络不受外部和内部用户的…
阅读更多...
Python酷库之旅-第三方库Pandas(013)

Python酷库之旅-第三方库Pandas(013)

目录 一、用法精讲 31、pandas.read_feather函数 31-1、语法 31-2、参数 31-3、功能 31-4、返回值 31-5、说明 31-6、用法 31-6-1、数据准备 31-6-2、代码示例 31-6-3、结果输出 32、pandas.DataFrame.to_feather函数 32-1、语法 32-2、参数 32-3、功能 32-4、…
阅读更多...
Go语言入门之基础语法

Go语言入门之基础语法

Go语言入门之基础语法 1.简单语法概述 行分隔符&#xff1a; 一行代表一个语句结束&#xff0c;无需写分号。将多个语句写在一行可以用分号分隔&#xff0c;但是不推荐 注释&#xff1a; // 或者/* */ 标识符&#xff1a; 用来命名变量、类型等程序实体。 支持大小写字母、数字…
阅读更多...
Golang | Leetcode Golang题解之第226题翻转二叉树

Golang | Leetcode Golang题解之第226题翻转二叉树

题目&#xff1a; 题解&#xff1a; func invertTree(root *TreeNode) *TreeNode {if root nil {return nil}left : invertTree(root.Left)right : invertTree(root.Right)root.Left rightroot.Right leftreturn root }
阅读更多...
Python函数 之 模块和包

Python函数 之 模块和包

1.模块 1, 在Python 中, 每个以 .py 结尾的 Python 代码⽂件 都可以称为是⼀个模块。 2, 在模块中 别⼈书写好的功能(变量, 函数, 类)&#xff0c;我们可以拿来直接使⽤。 3, 我们自己写的代码文件&#xff0c; 想要作为模块让别⼈使⽤, 你的代码⽂件名(模块名) 满足标识符的规…
阅读更多...
大话光学原理：4.散射：瑞利、拉曼、米氏和布里渊

大话光学原理：4.散射：瑞利、拉曼、米氏和布里渊

这是一缕柔和的光&#xff0c;在空气的舞台上轻盈地跳跃。它悠然自得&#xff0c;在宁静的空间中缓缓前行。然而&#xff0c;一片细薄透明的介质挡住了它的脚步&#xff0c;它毫无预兆地撞上了这片障碍。在这短暂的接触中&#xff0c;它被分解成无数微小的粒子&#xff0c;被迫…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023