二叉树基础oj练习【11道题】

news2024/11/20 6:36:56

二叉树基础oj练习

1.单值二叉树

题目：

单值二叉树

如果二叉树每个节点都具有相同的值，那么该二叉树就是单值二叉树。

只有给定的树是单值二叉树时，才返回 true；否则返回 false。

示例 1：

img

输入：[1,1,1,1,1,null,1]
输出：true

示例 2：

img

输入：[2,2,2,5,2]
输出：false

提示：

  1. 给定树的节点数范围是 [1, 100]。
  2. 每个节点的值都是整数，范围为 [0, 99] 。

思路：

image-20240512232747144

如图所示，我们采取前序遍历二叉树，让每个根都去和他的左子树和右子树的值去比较。

一旦有不同就返回false，都相同就一直遍历，直至找到叶子结点，也就是root是NULL的时候，返回true。

代码：

struct TreeNode 
{
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

bool isUnivalTree(struct TreeNode* root)
{
    // 如果一开始就是NULL 那就相当于全部节点都是NULL
    // 如果一直判断都找不到不一样的值，就说明全都是一样的，
    // 如果全部前序遍历的递归函数全部都返回true，那就是单值二叉树
    if (root == NULL)
        return true;

    // 让当前根节点，去和左右孩子对比
    if (root->left && root->left->val != root->val)
        return false; // 不一样就返回false

    if (root->right && root->right->val != root->val)
        return false;

    // 这里其实就是前序遍历二叉树
    return isUnivalTree(root->left) && isUnivalTree(root->right);
}

2.二叉树的最大深度

题目：

二叉树的最大深度

给定一个二叉树 root ，返回其最大深度。

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

示例 1：

img

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

示例 2：

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

提示：

  • 树中节点的数量在 [0, 104] 区间内。
  • -100 <= Node.val <= 100

思路：

求出左子树的深度和右子树的深度，判断谁大， 大的就 + 1

代码：

struct TreeNode
{
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
    
};


int maxDepth(struct TreeNode* root)
{
    if (root == NULL)
        return 0;

    // 计算左子树的深度 和 右子树的深度
    int leftdepth = maxDepth(root->left);
    int rightdepth = maxDepth(root->right);

    // 判断谁大，大的深度+1 就是最大深度
    return leftdepth > rightdepth ? leftdepth + 1 : rightdepth + 1;
}

3.翻转二叉树

题目：

翻转二叉树

给定一棵二叉树的根节点 root，请左右翻转这棵二叉树，并返回其根节点。

示例 1：

img

输入：root = [5,7,9,8,3,2,4]
输出：[5,9,7,4,2,3,8]

提示：

  • 树中节点数目范围在 [0, 100] 内
  • -100 <= Node.val <= 100

思路：

  • 如果root不为空，那就交换其左子树和右子树

image-20240513120414247

然后让每个左子树和右子树都要调转顺序就行了

代码：

思路1：
struct TreeNode 
{
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

typedef struct TreeNode TreeNode;

// 第一种思路 (前序)
TreeNode* mirrorTree(TreeNode* root)
{
    if (root == NULL)
        return  NULL;

    // 让根原本指向的左子树和右子树 调转  
    // 让指向左子树的指针，指向右子树，指向右子树的指针指向左子树
    TreeNode* tmp = root->left;
    root->left = root->right;
    root->right = tmp;

    // 每个左子树和右子树都要翻转
    mirrorTree(root->left);
    mirrorTree(root->right);

    ret
思路2：
// 第二种思路 (中序和后序结合)
TreeNode* mirrorTree(TreeNode* root)
{
    if (root == NULL)
    {
        return NULL;
    }
    else
    {
        // 先让左子树翻转，翻转完会返回左子树的根节点，让指向右子树的指针指向这个节点
        // 右子树同理
        // 这样就实现了根节点的左右子树翻转
        TreeNode* right = root->right;
        root->right = mirrorTree(root->left);
        root->left = mirrorTree(right);

        return root;
    }

}

4.二叉树的前序遍历

题目：

二叉树的前序遍历

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

示例 1：

img

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

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

示例 4：

img

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

示例 5：

img

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

提示：

  • 树中节点数目在范围 [0, 100] 内
  • -100 <= Node.val <= 100

思路：

  1. 其实就是要让二叉树前序遍历
  2. 但是题目需要我们将遍历到的节点的值放进数组里面，而我们又不知道二叉树有多少个节点，这样就不知道数组要开辟多少空间，
  3. 因此我们需要先编写一个获取二叉树节点个数的函数
  4. 然后就让前序遍历二叉树，把遍历到的值放进数组中就行了
  5. 但是需要注意的是，传数组的下标i进去的时候，需要传址调用（因为我们采用递归来实现前序遍历）

代码：

struct TreeNode 
{
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
    
};

/*
 * Note: The returned array must be malloced, assume caller calls free().
 */

    typedef struct TreeNode TreeNode;

// 获取二叉树的节点个数
int TreeSize(TreeNode* root)
{
    if (root == NULL)
    {
        return 0;
    }

    return 1 + TreeSize(root->left) + TreeSize(root->right);
}

// 前序遍历  （递归实现）
void _preorderTraversal(TreeNode* root, int* retArr, int* pi)
{
    if (root == NULL)
        return;

    retArr[(*pi)] = root->val; // i 的值我们通过解引用去拿到
    (*pi)++;


    _preorderTraversal(root->left, retArr, pi);
    _preorderTraversal(root->right, retArr, pi);
}

int* preorderTraversal(struct TreeNode* root, int* returnSize)
{
    // 创建一个数组 空间个数是二叉树的节点数
    int* retArr = (int*)malloc(sizeof(int) * TreeSize(root));

    // 前序遍历 (要把二叉树节点的值 放进retArr数组中)
    int i = 0;
    _preorderTraversal(root, retArr, &i);
    // 这里是一定要传 i的地址的，不然每次递归的时候，都会开辟新的函数栈帧，i的值无法被改变。 传值调用
    // 传地址进去就是 传址调用

    *returnSize = TreeSize(root);

    return retArr;
}

要注意递归展开的过程，理解了就能知道为什么要传址调用了。

5.二叉树的中序遍历

题目：

二叉树的中序遍历

给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

示例 1：

img

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

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

提示：

  • 树中节点数目在范围 [0, 100] 内
  • -100 <= Node.val <= 100

思路：

中序遍历 - 左子树 ——根——右子树

除了要在递归的时候注意顺序，其他思路和前序是一样的。

代码：

typedef struct TreeNode TreeNode;

// 获取二叉树节点个数
int TreeSize(TreeNode* root)
{
    if (root == NULL)
        return 0;

    // 二叉树节点个数 = 1 + 左子树节点个数 + 右子树节点个数
    return 1 + TreeSize(root->left) + TreeSize(root->right);
}

// 中序遍历
void _inorderTraversal(TreeNode* root, int* retArr, int* pi)
{
    if (root == NULL)
        return;

    // 这里我们要中序遍历，【左子树 根 柚子树】
    _inorderTraversal(root->left, retArr, pi);

    retArr[(*pi)] = root->val;
    (*pi)++;

    _inorderTraversal(root->right, retArr, pi);
}


int* inorderTraversal(struct TreeNode* root, int* returnSize)
{
    // 要将遍历到的节点放进数组中
    // 我们不知道二叉树节点多少，也就不知道数组要开辟多少空间。因此需要自己写一个获取二叉树节点个数的函数
    int size = TreeSize(root);
    int* retArr = (int*)malloc(sizeof(int) * size);

    //中序遍历）（递归实现）
    int i = 0;
    _inorderTraversal(root, retArr, &i);

    *returnSize = size;

    return retArr;
}

6.二叉树的后序遍历

题目：

二叉树的后序遍历

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

示例 1：

img

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

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

提示：

  • 树中节点的数目在范围 [0, 100] 内
  • -100 <= Node.val <= 100

思路：

后序遍历 - 左子树——右子树——根

注意递归时的调用顺序，其他思路和前序中序差不多。

代码：

struct TreeNode 
{
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
    
};

/*
 * Note: The returned array must be malloced, assume caller calls free().
 */

typedef struct TreeNode TreeNode;

// 获取二叉树的节点个数
int TreeSize(TreeNode* root)
{
    if (root == NULL)
    {
        return 0;
    }

    return 1 + TreeSize(root->left) + TreeSize(root->right);
}

// 后序遍历
void _postorderTraversal(TreeNode* root, int* retArr, int* pi)
{
    if (root == NULL)
        return;

    // 后序遍历 【左子树 右子树 根】
    _postorderTraversal(root->left, retArr, pi);
    _postorderTraversal(root->right, retArr, pi);

    retArr[(*pi)] = root->val;
    (*pi)++;
}

int* postorderTraversal(struct TreeNode* root, int* returnSize)
{
    // 要将遍历到的节点放进数组中
    // 我们不知道二叉树节点多少，也就不知道数组要开辟多少空间。因此需要自己写一个获取二叉树节点个数的函数
    int size = TreeSize(root);
    int* retArr = (int*)malloc(sizeof(int) * size);

    // 后序遍历（递归实现）
    int i = 0;
    _postorderTraversal(root, retArr, &i);

    *returnSize = size;

    return retArr;
}

7.相同的树

题目：

相同的树

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

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

示例 1：

img

输入：p = [1,2,3], q = [1,2,3]
输出：true

示例 2：

img

输入：p = [1,2], q = [1,null,2]
输出：false

示例 3：

img

输入：p = [1,2,1], q = [1,1,2]
输出：false

提示：

  • 两棵树上的节点数目都在范围 [0, 100] 内
  • -104 <= Node.val <= 104

思路：

  1. 首先我们要对传进来的两个树，是否是空树进行判断。
  2. 不是空树我们就要去判断他们的结构是否相同，也是为了防止对NULL进行解引用
  3. 结构都相同那就去判断他们的值是否相同，不同就返回false
  4. 然后通过递归去判断两个数的每一个节点是否相同

代码：

struct TreeNode 
{
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

bool isSameTree(struct TreeNode* p, struct TreeNode* q)
{
    // 判断传进来的两棵树是否是空树
    if (p == NULL && q == NULL)
        return true;

    // 为了防止对NULL解引用，我们要先对其结构判断是否相同
    if (p != NULL && q == NULL)
        return false;
    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);
}

8.对称二叉树

题目：

对称二叉树

给你一个二叉树的根节点 root ， 检查它是否轴对称。

示例 1：

img

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

示例 2：

img

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

提示：

  • 树中节点数目在范围 [1, 1000] 内
  • -100 <= Node.val <= 100

**进阶：**你可以运用递归和迭代两种方法解决这个问题吗？

思路：

  1. 首先我们要判断传进来的树是否是空树，空树就是true。
  2. 然后我们要判断根的左子树和右子树结构是否轴对称，结构都不轴对称，false
  3. 结构轴对称了我们就要去判断其值是否轴对称

代码:

struct TreeNode 
{
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

typedef struct TreeNode TreeNode;

bool isMirror(TreeNode* left, TreeNode* right)
{
    // 判断左右子树的结构
    if (left == NULL && right == NULL)
        return true;
    // 左子树或这样右子树有一个是NULL 就是false
    if (right == NULL || left == NULL)
        return false;

    // 除了结构要对称，也要判断其值是否轴对称
    return (left->val == right->val) &&
        isMirror(left->left, right->right) &&
        isMirror(left->right, right->left);
}

bool isSymmetric(struct TreeNode* root)
{
    // 判断传进来的树是否为空
    if (root == NULL)
        return true;

    // 判断每个左子树右子树是否轴对称
    return isMirror(root->left, root->right);
}

9.另一棵树的子树

题目：

另一棵树的子树

给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在，返回 true ；否则，返回 false 。

二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。

示例 1：

img

输入：root = [3,4,5,1,2], subRoot = [4,1,2]
输出：true

示例 2：

img

输入：root = [3,4,5,1,2,null,null,null,null,0], subRoot = [4,1,2]
输出：false

提示：

  • root 树上的节点数量范围是 [1, 2000]
  • subRoot 树上的节点数量范围是 [1, 1000]
  • -104 <= root.val <= 104
  • -104 <= subRoot.val <= 104

思路：

让root上的每一课树都去和subRoob这课树去比较是否相同。

在比较树是否相同的时候，要注意结构和值都要比较是否相同。

递归到NULL就要返回

代码：

struct TreeNode 
{
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

// 判断两棵树是否相同
bool isSameTree(struct TreeNode* p, struct TreeNode* q)
{
    // 判断传进来的两棵树是否是空树
    if (p == NULL && q == NULL)
        return true;

    // 为了防止对NULL解引用，我们要先对其结构判断是否相同
    if (p != NULL && q == NULL)
        return false;
    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);
}


bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot)
{
    if(root == NULL)
        return false;

    // 让root中的每一课树 都去和 subRoot这课树进行比较，如果有相同的，那就是true。

    // 先让root根结点去和subRoot进行比较
    if(isSameTree(root, subRoot))
        return true;

    // 走到这里，说明根节点不包含subRoob这棵树
    // 那就继续让root中的左子树和右子树 去比较
    return isSubtree(root->left, subRoot) || isSubtree(root->right, subRoot);
}

如果理解困难就去画递归展开图

image-20240513202057395

10.平衡二叉树

题目：

平衡二叉树

给定一个二叉树，判断它是否是 平衡二叉树

示例 1：

img

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

示例 2：

img

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

示例 3：

输入：root = []
输出：true

提示：

  • 树中的节点数在范围 [0, 5000] 内
  • -104 <= Node.val <= 104

思路：

  1. 求出每个根结点的左子树和右子树的高度， 判断其相减的绝对值是否小于等于1
  2. 如果小于等于1 ，那这个根结点代表的子树是平衡二叉树， 但是这样就ok了嘛？
  3. 不是，我们还有继续遍历二叉树，必须是每个子树都是平衡二叉树，整个树才是平衡二叉树。
  4. 因此我们还要接着遍历，判断根结点的左子树代表的子树是否是平衡二叉树，右子树代表的子树是否是平衡二叉树，直至遍历完全部的子树。

image-20240513221453719

代码：

struct TreeNode 
{
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

// 计算传进来的树 的最大深度
int MaxDepth(struct TreeNode* root) // 时间复杂度为O（N）
{
    if (root == NULL)
        return 0;

    // 左子树和右子树的深度都要计算
    int leftdepth = MaxDepth(root->left);
    int rightdepth = MaxDepth(root->right);

    // 树的深度 = 左子树/右子树 的最大深度 + 1
    return leftdepth > rightdepth ? leftdepth + 1 : rightdepth + 1;
}

bool isBalanced(struct TreeNode* root) // 时间复杂度为 O(N^2)
{
    // 如果传进来的根结点，是空，那说明这个根结点代表的子树是平衡二叉树
    if (root == NULL)
        return true;

    // 如果不是空就去计算这个根节点 左子树和右子树的深度 并判断其相减的绝对值是否<=1
    int leftdepth = MaxDepth(root->left);
    int rightdepth = MaxDepth(root->right);
    if (abs(leftdepth - rightdepth) > 1)
        return false;

    // 每一个根结点(每一个根节点都代表一个子树)都要去判断是否是平衡二叉树
    return isBalanced(root->left) && isBalanced(root->right);
}

尽管上面我们的代码可以实现功能，但是我们的时间复杂度是O(N^2)。

这是因为我们的代码是采用的前序遍历二叉树，会有大量的重复计算——就比如，其实我们再调用第一次函数的时候，所有节点的左右子树的深度都被计算过了，但是我们仍然会进行重复计算。 这就导致我们的代码效率比较低下。

那我们是否可以做到优化呢？

其实是可以的，我们可以采用后序遍历二叉树。

从最后的左右子树开始计算其深度，并判断是否为平衡二叉树，如果是就返回深度，往上遍历，这样子处理，每个根节点的深度就只用被计算一次，并且遇到不是平衡二叉树的根节点，也可以及时退出递归。

image-20240514012209623

注意了，这个过程是后序遍历实现的

思路讲完了，我们来实现一下代码：

优化后代码：

bool _isBalanced(struct TreeNode* root, int* pdepth)
{
    // 判断传进来的根节点是否是NULL
    if(root == NULL)
    {
        *pdepth = 0;
        return true;
    }
    
    // 后序遍历 

    // 先递归左子树
    int leftdepth = 0; // 记录左子树的深度
    if(_isBalanced(root->left, &leftdepth) == false)
        return false; // 不是平衡二叉树就不用带上高度的计算了

    // 递归右子树
    int rightdepth = 0; //记录右子树的深度
    if(_isBalanced(root->right, &rightdepth) == false)
        return false; // 不是平衡二叉树就不用带上高度的计算了
    
    int gas = leftdepth - rightdepth;
    if(abs(gas) > 1)
        return false;

    // 走到这里 说明，当前节点是平衡二叉树，那就计算高度
    *pdepth = leftdepth > rightdepth ? leftdepth + 1 : rightdepth + 1;
    return true;
}

bool isBalanced(struct TreeNode* root)  // 时间复杂度是O(N)
{

    //计算其每个左右子树的深度，并判断其是否为平衡二叉树
    // 为了提高效率使用后序遍历二叉树
    // 我们使用子函数去实现后序遍历

    int depth = 0;
    return _isBalanced(root, &depth); // 传第二个参数的目的是判断的同时，带高度 这样才能实现时间复杂度的优化
}

11.二叉树的构建和遍历（清华考研题）

题目：

二叉树遍历_牛客题霸_牛客网 (nowcoder.com)

描述

编一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。 例如如下的先序遍历字符串： ABC##DE#G##F### 其中“#”表示的是空格，空格字符代表空树。建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结果。

输入描述：

输入包括1行字符串，长度不超过100。

输出描述：

可能有多组测试数据，对于每组数据， 输出将输入字符串建立二叉树后中序遍历的序列，每个字符后面都有一个空格。 每个输出结果占一行。

示例1

输入：

abc##de#g##f###

输出：

c b e g d f a

思路：

  1. 先通过前序遍历构建出这个二叉树的。
  2. 然后再用中序遍历去访问这课二叉树

image-20240514094443879

代码：

#include <stdio.h>


typedef struct TreeNode
{
    char val;
    struct TreeNode* left;
    struct TreeNode* right;
}TreeNode;

void InOrder(TreeNode* root)
{
    if(root == NULL)
        return;
    
    // 中序遍历
    InOrder(root->left);
    printf("%c ", root->val);
    InOrder(root->right);
} 

TreeNode* CreateTree(char* str, int* pi)
{
    // 判断此时是否为NULL 
    if(str[*pi] == '#')
    {
        (*pi)++;
        return NULL;
    }
    else 
    {
        // 不为NULL就要构建节点
        TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));

        // 根据先序构建二叉树 【根——左子树——右子树】
        root->val = str[*pi];
        (*pi)++;

        root->left = CreateTree(str, pi); 
        root->right = CreateTree(str, pi);
        
        return root;
    }
}

int main() 
{
    // 让用户输入以先序遍历的字符串
    char str[100];
    scanf("%s", str);

    // 根据字符串去先序构建二叉树
    int i = 0;
    TreeNode* root = CreateTree(str, &i);// 为了让所有递归用的是同一个i 必须传地址

    // 中序遍历二叉树
    InOrder(root);

    return 0;
}

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

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

相关文章

Pycharm导入自定义模块报红

Pycharm导入自定义模块报红

文章目录 Pycharm导入自定义模块报红1.问题描述2.解决办法 Pycharm导入自定义模块报红 1.问题描述 Pycharm 导入自定义模块报红&#xff0c;出现红色下划线。 2.解决办法 打开【File】->【Setting】->【Build,Execution,Deployment】->【Console】->【Python Con…
阅读更多...
HTML的使用（中）

HTML的使用（中）

文章目录 前言一、HTML表单是什么&#xff1f;二、HTML表单的使用 &#xff08;1&#xff09;<form>...</form>表单标记&#xff08;2&#xff09;<input>表单输入标记总结 前言 在许多网页平台上浏览&#xff0c;大多逃不了登录账号。此时在网页中填写的用户…
阅读更多...
5G消息和5G阅信的释义与区别 | 赛邮科普

5G消息和5G阅信的释义与区别 | 赛邮科普

5G消息和5G阅信的释义与区别 | 赛邮科普 在 5G 技术全面普及的当下&#xff0c;历史悠久的短信服务也迎来了前所未有的变革。5G 阅信和 5G 消息就是应运而生的两种短信形态&#xff0c;为企业和消费者带来更加丰富的功能和更加优质的体验。 这两个产品名字和形态都比较接近&am…
阅读更多...
在数据库中使用存储过程插入单组/多组数据

在数据库中使用存储过程插入单组/多组数据

存储过程可以插入单组数据&#xff0c;也可以以字符串的形式插入多组数据&#xff0c;将字符串中的信息拆分成插入的数据。 首先建立一个简单的数据库 create database student; use student;选中数据库之后建立一张学生表 create table stu(uid int primary key,uname varc…
阅读更多...
解决Android Studio Gradle下载慢的问题

解决Android Studio Gradle下载慢的问题

安卓 gradle-7.5-bin.zip 下载慢 https://mirrors.cloud.tencent.com/gradle/7.x.x 找到对应匹配版本 把下载的文件直接复制到 C:\Users\Administrator.gradle\wrapper\dists\gradle-x.x\ 中对应版本目录下&#xff0c;例如需要下载 gradle-2.14.1-all.zip&#xff0c;则下载好…
阅读更多...
最新版Ceph( Reef版本)块存储简单对接k8s(上集)

最新版Ceph( Reef版本)块存储简单对接k8s(上集)

当前ceph 你的ceph集群上执行 1.创建名为k8s-rbd 的存储池 ceph osd pool create k8s-rbd 64 642.初始化 rbd pool init k8s-rbd3 创建k8s访问块设备的认证用户 ceph auth get-or-create client.kubernetes mon profile rbd osd profile rbd poolk8s-rbd部署 ceph-rbd-csi c…
阅读更多...
Spring MVC(四) 数据校验

Spring MVC(四) 数据校验

在开发过程中有一环必不可少的部分就是数据校验&#xff0c;用户在页面中填写的数据通过表单提交时&#xff0c;前端的JS可以做一些是否合法性的验证&#xff0c;比如是否为空、两次密码是否一致、格式是否正确等等验证。当数据到了后台控制器&#xff0c;为了确保程序的健壮性…
阅读更多...
steam商店打不开、steam商店错误代码-118的解决方法

steam商店打不开、steam商店错误代码-118的解决方法

现在steam已经开始了&#xff0c;有很多好玩的游戏都在这段时间相继打折&#xff0c;虽然游戏众多&#xff0c;但是不是所有人都能把这些游戏都买下来&#xff0c;有一些小伙伴喜欢的游戏苦于没有足够的资本去购买&#xff0c;steam会以各种名义举办特惠活动吸引玩家们&#xf…
阅读更多...
2024国考行测、申论资料大全，做好备考真的很重要！

2024国考行测、申论资料大全，做好备考真的很重要！

1. 国考是什么? 国考,全称国家公务员考试,是选拔国家公务员的重要途径。通过国考,你将有机会进入政府部门,为国家建设贡献力量。 2. 国考难在哪里? 国考之所以难,主要体现在以下几个方面: (1) 竞争激烈 每年国考报名人数都在百万以上,而录取率却不足2%。千军万马过独木桥…
阅读更多...
Linux学习笔记8---官方 SDK 移植实验

Linux学习笔记8---官方 SDK 移植实验

在上一章中&#xff0c;我们参考 ST 官方给 STM32 编写的 stm32f10x.h 来自行编写 I.MX6U 的寄存器定义文件。自己编写这些寄存器定义不仅费时费力&#xff0c;没有任何意义&#xff0c;而且很容易写错&#xff0c;幸好NXP 官方为 I.MX6ULL 编写了 SDK 包&#xff0c;在 SDK 包…
阅读更多...
最新Linux Debian12安装和使用ImageMagick图像处理工具 常见图片png、jpg格式转webp格式

最新Linux Debian12安装和使用ImageMagick图像处理工具 常见图片png、jpg格式转webp格式

在Linux系统中&#xff0c;使用ImageMagick可以图片格式转换&#xff0c;其中最常用的是通过命令行工具进行。 ImageMagick是一个非常强大的图像处理工具集&#xff0c;它包含了许多用于图像转换的命令。 一、安装ImageMagick&#xff08;如果尚未安装&#xff09;&#xff1…
阅读更多...
安卓悬浮窗----可移动的悬浮窗

安卓悬浮窗----可移动的悬浮窗

目录 前言一、添加对悬浮窗功能的支持二、通过service实现悬浮窗2.1 窗口属性和标志2.2 窗口移动 三、完整代码 前言 记录一下基础的悬浮窗实现&#xff0c;分为几个重要的点进行阐述。 一、添加对悬浮窗功能的支持 app要实现悬浮窗功能&#xff0c;首先app要添加对悬浮窗功…
阅读更多...
超链接a的应用

超链接a的应用

主要作用&#xff1a;从当前页面进行跳转 1.跳转到页面 <!-- 跳转到其他页面 --><a href"#" target"_blank">鸡你太美</a> <!-- 跳转到本地页面 --><a href"#" target"_self">鸡你太美</a> 2.跳转…
阅读更多...
RAG 面向 LLM: 基于检索增强的大语言模型调研

RAG 面向 LLM: 基于检索增强的大语言模型调研

摘要 作为 AI 领域最先进的技术之一,检索增强生成(RAG)技术可以提供可靠和最新的外部知识,为众多任务提供巨大的便利。特别是在 AI 生成内容(AIGC)时代,RAG 中检索强大的提供额外知识的能力使得检索增强生成能够辅助现有生成式 AI 生产高质量输出。最近,大语言模型(LLM)在语言…
阅读更多...
Vue3组件库开发项目实战——03封装Button组件/输出vitePress文档

Vue3组件库开发项目实战——03封装Button组件/输出vitePress文档

Vue3组件库开发项目实战——01组件开发必备知识导学-CSDN博客 Vue3组件库开发项目实战——02项目搭建&#xff08;配置Eslint/Prettier/Sass/Tailwind CSS/VitePress/Vitest&#xff09;-CSDN博客 在前面两篇博客中&#xff0c;我分别介绍了组件库开发必学知识&#xff0c;以及…
阅读更多...
整合Tess4J图文识别技术

整合Tess4J图文识别技术

仓库地址&#xff1a;https://gitee.com/z3inc/tess4j-demo.git 1. OCR图文识别介绍 OCR&#xff08;全称 Optical Character Recognition&#xff0c;直译为光学字符识别&#xff09;用于图片文字识别&#xff0c;例如 提取图片中车牌号等等。 Java中实现OCR的技术方案有&…
阅读更多...
文本到语音的学习笔记:从Docker开始

文本到语音的学习笔记:从Docker开始

1.docker 是什么意思&#xff1f; Docker 是一种开源的容器化平台&#xff0c;它允许开发者将应用及其依赖打包到一个轻量级、可移植的容器中&#xff0c;然后可以在任何支持Docker的系统上运行这个应用&#xff0c;而不必担心环境差异导致的问题。 以下是Docker的一些关键特…
阅读更多...
品鉴中的精神内涵：如何通过红酒品味生活的美好与哲学

品鉴中的精神内涵：如何通过红酒品味生活的美好与哲学

红酒不仅仅是一种物质享受&#xff0c;更是一种精神体验。在品鉴云仓酒庄雷盛红酒的过程中&#xff0c;我们能够品味到生活的美好与哲学&#xff0c;感受到红酒所蕴含的精神内涵。 红酒的精神内涵源于其酿造过程中所融入的时间和匠心。一瓶上好的红酒需要经过长时间的陈年&…
阅读更多...
二叉树专题（有关二叉树的相关学习）

二叉树专题（有关二叉树的相关学习）

二叉树 1.数概念及结构 1.1树的结构 树是一种非线性的数据结构&#xff0c;它是由n&#xff08;n>0&#xff09;个有限结点组成一个具有层次关系的集合。把它叫做树是因 为它看起来像一棵倒挂的树&#xff0c;也就是说它是根朝上&#xff0c;而叶朝下的。 有一个特殊的结…
阅读更多...
使用yarn/npm安装插件（涉及electron），总是报错证书错误或者ssl解析错误

使用yarn/npm安装插件（涉及electron），总是报错证书错误或者ssl解析错误

同学们可以私信我加入学习群&#xff01; 正文开始 前言一、问题描述二、解决措施总结 前言 最近electron更新到了30大版本&#xff0c;里面更新的一个重大变化是主进程增加了 WebContentsView 和 BaseWindow&#xff0c;对窗口的控制会更加丝滑。 正好最近在做把文章或者视频…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023