基础数据结构--二叉树

一、二叉树的定义

二叉树是 n( n >= 0 ) 个结点组成的有限集合，这个集合要么是空集（当 n 等于 0 时），要么是由一个根结点和两棵互不相交的二叉树组成。其中这两棵互不相交的二叉树被称为根结点的左子树和右子树。

如图所示，2 是 1 的左子树，3 是 1 的右子树；同时，4 和 5 分别是 2 的左右子树，6 和 7 分别是 3 的左右子树。

二、二叉树的特点

二叉树是一种树，它有如下几个特征：

1）每个结点最多二棵子树，即每个结点的孩子结点个数为 0、1、2。

2）这两棵子树是有顺序的，分别叫：左子树 和 右子树，就像左手和右手一样，是不能颠倒的。

3）如果只有一棵子树的情况，也需要区分顺序，如图所示：

b 为 a 的左子树

c 为 a 的右子树

三、特殊二叉树

1、斜树

所有结点都只有左子树的二叉树，被称为左斜树，像这样：

所有结点都只有右子树的二叉树，被称为右斜树，像这样：

斜树有点类似线性表，所以线性表可以理解为一种特殊形式的树。

2、满二叉树

对于一棵二叉树，如果它的所有根结点和内部结点都存在左右子树，且所有叶子结点都在同一层，这样的树就是满二叉树，像这样：

满二叉树有如下几个特点：

1）叶子结点一定在最后一层

2）非叶子结点的度为 2

3）深度相同的二叉树中，满二叉树的结点个数最多，为 2^h-1（其中 h 代表树的深度）

3、完全二叉树

对一棵具有 n 个结点的二叉树，按照层序进行编号，如果编号 i 的结点和同样深度的满二叉树中的编号 i 的结点在二叉树中，位置完全相同则被称为 完全二叉树。

满二叉树一定是完全二叉树，而完全二叉树则不一定是满二叉树，完全二叉树有如下几个特点：

1）叶子结点只能出现在最下面两层

2）最下层的叶子结点，一定是集中在左边的连续位置，倒数第二层如果有叶子结点一定集中在右边的连续位置

3）如果某个结点度为 1，则只有左子树，即 不存在只有右子树 的情况

4）同样结点数的二叉树，完全二叉树的深度最小

如下图所示，就不是一棵完全二叉树，因为 5 号结点没有右子树，但是 6 号结点是有左子树的，不满足上述第 2 点。

四、二叉树的性质

以下性质对理解二叉树有很好的帮助，可以尝试自行证明。或许在后续遇到贪心相关问题时，需要用到这些证明。

1）二叉树的第 i（i >= 1）层上最多 2^(i-1) 个结点；

2）深度为 h 的二叉树至多 2^h - 1 个结点；

3）n 个结点的完全二叉树的深度为 floor(log2n) + 1（其中 floor(x) 代表对 x 取下整）；

五、二叉树的顺序存储

二叉树的顺序存储就是指：利用顺序表对二叉树进行存储。结点的存储位置即顺序表的索引，能够体现结点之间的逻辑关系比如父结点和孩子结点之间的关系，左右兄弟结点之间的关系 等等。

1、完全二叉树

来看一棵完全二叉树，我们对它进行如下存储：

编号代表了顺序表索引的绝对位置，映射后如下

这里为了方便，我们把顺序表索引为 0 的位置给留空了。

这样一来，当知道某个结点在顺序表中的索引 x，就可以知道它左右儿子的索引分别为 2x 和 2x+1。反之，当知道某个结点的索引 x，也能知道它父结点的索引为 floor(x/2)。

2、非完全二叉树

对于非完全二叉树，只需要将对应不存在的结点设置为空即可

编号代表了顺序表索引的绝对位置，映射后如下

3、稀疏二叉树

对于较为稀疏的二叉树，就会有如下情况出现。这时候如果用这种方式进行存储，就比较浪费内存了

编号代表了顺序表索引的绝对位置，映射后如下：

下标0123456789101112
data-abcd--gh----

这种情况下，为了提升内存利用率，我们可以采用链表进行存储。

六、二叉树的链式存储

二叉树每个结点至多有两个孩子结点，所以对于每个结点设置一个 数据域（data） 和 两个 指针域（left 和 right） 即可。指针域 分别指向 左孩子结点 和 右孩子结点。

七、二叉树的遍历概念

二叉树的遍历是指从根结点出发，按照某种次序依次访问二叉树中的所有结点，使得每个结点访问一次且仅被访问一次。

对于线性表的遍历，要么从头到尾，要么从尾到头，遍历方式较为单纯。但是树不一样，它的每个结点都有可能有两个孩子结点，所以遍历的顺序面临着不同的选择。

二叉树的常用遍历方法，有以下四种：前序遍历、中序遍历、后序遍历、层序遍历。

下标0123456789101112
data-abcd-efgh--i

八、二叉树的前序遍历

如果二叉树为空则直接返回，否则先访问根结点，再递归前序遍历左子树，再递归前序遍历右子树。前序遍历的结果如下：abdghcefi

九、二叉树的中序遍历

如果二叉树为空则直接返回，否则先递归中序遍历左子树，再访问根结点，再递归中序遍历右子树。中序遍历的结果如下：gdhbaecif。

十、二叉树的后序遍历

如果二叉树为空则直接返回，否则先递归后遍历左子树，再递归后序遍历右子树，再访问根结点。后序遍历的结果如下：ghdbeifca。

十一、二叉树的层序遍历

如果二叉树为空直接返回，否则依次从树的第一层开始，从上至下逐层遍历，在同一层中，按从左到右的顺序对结点逐个访问。图中二叉树层序遍历的结果为：abcdefghi。

一、二叉树结点定义

#include <iostream>

using namespace std;



template < typename T >

    struct TreeNode {

        T val; // (1)

        TreeNode * left; // (2)

        TreeNode * right; // (3)

        TreeNode(): val(0), left(NULL), right(NULL) {} // (4)

        TreeNode(T x): val(x), left(NULL), right(NULL) {} // (5)

    };

(1) 定义了一个类型为 T 的成员变量 val，用于存储树节点的值。

(2) 定义了一个指向 TreeNode 类型的指针成员变量 left，用于存储左子结点的指针。

(3) 定义了一个指向 TreeNode 类型的指针成员变量 right，用于存储右子结点的指针。

(4) 定义了一个无参的构造函数，在创建树节点时将 val、left 和 right 都初始化为 NULL，并将 val 的值设置为 0。

(5) 定义了一个带参的构造函数，在创建树节点时将传入的参数赋值给 val，并将 left 和 right 都初始化为 NULL。

二、二叉树类的定义

template < typename T >

    class Tree {

        private:

            TreeNode < T > * nodes;

        TreeNode < T > * root;

        size_t nodeSize;

        TreeNode < T > * Create(T a[], int size, int nodeId, T nullNode); // (1)

        void visit(TreeNode < T > * node); // (2)

        void preOrder(TreeNode < T > * node); // (3)

        void inOrder(TreeNode < T > * node); // (4)

        void postOrder(TreeNode < T > * node); // (5)

        public:

            Tree(); // (6)

        Tree(int maxNodes); // (7)

        ~Tree(); // (8)

        TreeNode < T > * GetTreeNode(int id); // (9)

        void CreateTree(T a[], int size, T nullNode); // (10)

        void preOrderTraversal(); // (11)

        void inOrderTraversal(); // (12)

        void postOrderTraversal(); // (13)

    };

(1) 这是一个模板函数声明，用于创建一个具有类型为 T 的树，是用于递归调用的。

(2) 这是一个成员函数声明，用于访问树结点（这里的实现就是打印结点的值）。

(3) 这是一个成员函数声明，用于前序遍历树结点。

(4) 这是一个成员函数声明，用于中序遍历树结点。

(5) 这是一个成员函数声明，用于后序遍历树结点。

(6) 这是构造函数声明，用于创建树结点池。

(7) 这是构造函数声明，用于创建一个具有最大结点数为 maxNodes 的树。

(8) 这是析构函数声明，用于销毁树对象并释放内存。

(9) 这是一个成员函数声明，用于获取指定编号的树结点。

(10) 这是一个成员函数声明，用于创建树。

(11) 这是一个成员函数声明，用于执行前序遍历。

(12) 这是一个成员函数声明，用于执行中序遍历。

(13) 这是一个成员函数声明，用于执行后序遍历。

三、二叉树的创建

template < typename T >

    Tree < T > ::Tree() {

        nodeSize = 100001;

        nodes = new TreeNode < T > [nodeSize];

    }



template < typename T >

    Tree < T > ::Tree(int maxNodes) {

        nodeSize = maxNodes;

        nodes = new TreeNode < T > [nodeSize];

    }

这是两个不同参数的 Tree 的构造函数的实现，用来生成树的结点池。

四、二叉树的销毁

template<typename T>

Tree<T>::~Tree() {

    delete[] nodes;

}

当树销毁的时候，利用 delete 来清理结点池的内存空间。

五、获取二叉树的结点

template<typename T>

TreeNode<T>* Tree<T>::GetTreeNode(int id) {

    return &nodes[id];

}

通过 id 在 nodes 数组中索引，通过 O(1) 的时间复杂度内快速找到对应的树结点，然后再取地址并返回，就得到了 id 对应的树结点的地址。

六、访问二叉树的结点

template<typename T>

void Tree<T>::visit(TreeNode<T> *node) {

    cout << node->val;

}

用于访问传入的二叉树结点 node，为了体现二叉树的遍历，所以这里的实现是输出它的值。

七、二叉树的初始化

template < typename T >

    TreeNode < T > * Tree < T > ::Create(T a[], int size, int nodeId, T nullNode) {

        if (nodeId >= size || a[nodeId] == nullNode) {

            return NULL; // (1)

        }

        TreeNode < T > * nowNode = GetTreeNode(nodeId); // (2)

        nowNode -> val = a[nodeId]; // (3)

        nowNode -> left = Create(a, size, nodeId * 2, nullNode); // (4)

        nowNode -> right = Create(a, size, nodeId * 2 + 1, nullNode); // (5)

        return nowNode; // (6)

    }



template < typename T >

    void Tree < T > ::CreateTree(T a[], int size, T nullNode) {

        root = Create(a, size, 1, nullNode); // (7)

    }

(1) 如果树结点编号 nodeId 大于等于数组大小 size，或者数组中编号为 nodeId 的元素的值等于空节点值 nullNode，则返回 NULL 表示创建一颗空树。

(2) 通过调用 GetTreeNode 方法获取编号为 nodeId 的树结点。

(3) 将数组中编号为 nodeId 的元素的值赋给当前树结点。

(4) 递归调用 Create 方法创建当前节点的左子结点，其中 nodeId 乘以 2 作为左子结点的编号。

(5) 递归调用 Create 方法创建当前节点的右子结点，其中 nodeId 乘以 2 加 1 作为右子结点的编号。

(6) 返回创建成功的树结点。

(7) 将根结点的指针设置为通过调用 Create 方法创建的树结点。

八、二叉树的前序遍历

template < typename T >

    void Tree < T > ::preOrder(TreeNode < T > * node) {

        if (node) {

            visit(node); // (1)

            preOrder(node -> left); // (2)

            preOrder(node -> right); // (3)

        }

    }



template < typename T >

    void Tree < T > ::preOrderTraversal() {

        preOrder(root); // (4)

    }

(1) 调用 `visit` 函数访问当前树节点。

(2) 递归调用 `preOrder` 方法遍历当前节点的左子树。

(3) 递归调用 `preOrder` 方法遍历当前节点的右子树。

(4) 调用 `preOrder` 方法遍历根节点，即开始树的前序遍历。

九、二叉树的中序遍历

template < typename T >

    void Tree < T > ::inOrder(TreeNode < T > * node) {

        if (node) {

            inOrder(node -> left); // (1)

            visit(node); // (2)

            inOrder(node -> right); // (3)

        }

    }



template < typename T >

    void Tree < T > ::inOrderTraversal() {

        inOrder(root); // (4)

    }

(1) 递归调用 `inOrder` 函数遍历当前节点的左子树。

(2) 调用 `visit` 函数访问当前树节点。

(3) 递归调用 `inOrder` 函数遍历当前节点的右子树。

(4) 调用 `inOrder` 函数遍历根节点，即开始树的中序遍历。

十、二叉树的后序遍历

template < typename T >

    void Tree < T > ::postOrder(TreeNode < T > * node) {

        if (node) {

            postOrder(node -> left); // (1)

            postOrder(node -> right); // (2)

            visit(node); // (3)

        }

    }



template < typename T >

    void Tree < T > ::postOrderTraversal() {

        postOrder(root); // (4)

    }

(1) 递归调用 `postOrder` 函数遍历当前节点的左子树。

(2) 递归调用 `postOrder` 函数遍历当前节点的右子树。

(3) 调用 `visit` 函数访问当前树节点。

(4) 调用 `postOrder` 函数遍历根节点，即开始树的后序遍历。

十一、二叉树的完整源码

#include <iostream>

using namespace std;



template < typename T >

    struct TreeNode {

        T val;

        TreeNode * left;

        TreeNode * right;

        TreeNode(): val(0), left(NULL), right(NULL) {}

        TreeNode(T x): val(x), left(NULL), right(NULL) {}

    };



template < typename T >

    class Tree {

        private:

            TreeNode < T > * nodes;

        TreeNode < T > * root;

        size_t nodeSize;

        TreeNode < T > * Create(T a[], int size, int nodeId, T nullNode);

        void visit(TreeNode < T > * node);

        void preOrder(TreeNode < T > * node);

        void inOrder(TreeNode < T > * node);

        void postOrder(TreeNode < T > * node);

        public:

            Tree();

        Tree(int maxNodes);

        ~Tree();

        TreeNode < T > * GetTreeNode(int id);

        void CreateTree(T a[], int size, T nullNode);

        void preOrderTraversal();

        void inOrderTraversal();

        void postOrderTraversal();

    };



template < typename T >

    Tree < T > ::Tree() {

        nodeSize = 100001;

        nodes = new TreeNode < T > [nodeSize];

    }



template < typename T >

    Tree < T > ::Tree(int maxNodes) {

        nodeSize = maxNodes;

        nodes = new TreeNode < T > [nodeSize];

    }



template < typename T >

    Tree < T > ::~Tree() {

        delete[] nodes;

    }



template < typename T >

    TreeNode < T > * Tree < T > ::GetTreeNode(int id) {

        return & nodes[id];

    }



template < typename T >

    void Tree < T > ::visit(TreeNode < T > * node) {

        cout << node -> val;

    }

template < typename T >

    TreeNode < T > * Tree < T > ::Create(T a[], int size, int nodeId, T nullNode) {

        if (nodeId >= size || a[nodeId] == nullNode) {

            return NULL;

        }

        TreeNode < T > * nowNode = GetTreeNode(nodeId);

        nowNode -> val = a[nodeId];

        nowNode -> left = Create(a, size, nodeId * 2, nullNode);

        nowNode -> right = Create(a, size, nodeId * 2 + 1, nullNode);

        return nowNode;

    }



template < typename T >

    void Tree < T > ::CreateTree(T a[], int size, T nullNode) {

        root = Create(a, size, 1, nullNode);

    }



template < typename T >

    void Tree < T > ::preOrder(TreeNode < T > * node) {

        if (node) {

            visit(node);

            preOrder(node -> left);

            preOrder(node -> right);

        }

    }



template < typename T >

    void Tree < T > ::preOrderTraversal() {

        preOrder(root);

    }



template < typename T >

    void Tree < T > ::inOrder(TreeNode < T > * node) {

        if (node) {

            inOrder(node -> left);

            visit(node);

            inOrder(node -> right);

        }

    }



template < typename T >

    void Tree < T > ::inOrderTraversal() {

        inOrder(root);

    }



template < typename T >

    void Tree < T > ::postOrder(TreeNode < T > * node) {

        if (node) {

            postOrder(node -> left);

            postOrder(node -> right);

            visit(node);

        }

    }



template < typename T >

    void Tree < T > ::postOrderTraversal() {

        postOrder(root);

    }



int main()

{

    const char nullNpde = '-';

    char a[15] = {

        nullNpde,
        'a',
        'b',
        'c',
        'd',

        nullNpde,
        'e',
        'f',
        'g',
        'h',

        nullNpde,
        nullNpde,
        nullNpde,
        nullNpde,
        'i'

    };

    Tree < char > T(15);

    T.CreateTree(a, 15, nullNpde);

    T.preOrderTraversal();
    cout << endl;

    T.inOrderTraversal();
    cout << endl;

    T.postOrderTraversal();
    cout << endl;



    return 0;

}

题集

1. 单值二叉树

​ 2. 完全二叉树的节点个数

3. ​二叉树的前序遍历

​ 4. ​二叉树的中序遍历

​ 5. ​二叉树的后序遍历

​ 6. 翻转二叉树

​ 7. 从根到叶的二进制数之和

性质

单值二叉树

相同的树

对称二叉树

剑指 Offer 28. 对称的二叉树

二叉树的最大深度

剑指 Offer 55 - I. 二叉树的深度

二叉树的最小深度

完全二叉树的节点个数

二叉树的堂兄弟节点

另一棵树的子树

先序遍历

二叉树的前序遍历

找出克隆二叉树中的相同节点

二叉树展开为链表

二叉树的所有路径

从根到叶的二进制数之和

剑指 Offer II 045. 二叉树最底层最左边的值

剑指 Offer II 049. 从根节点到叶节点的路径数字之和

叶子相似的树

左叶子之和

路径总和

特定深度节点链表

最大二叉树

路径总和 II

统计二叉树中好节点的数目

中序遍历

二叉树的中序遍历

后序遍历

二叉树的后序遍历

二叉树的坡度

二叉树剪枝

剑指 Offer II 047. 二叉树剪枝

统计最高分的节点数目

层序遍历

二叉树的层序遍历

剑指 Offer 32 - I. 从上到下打印二叉树

最大层内元素和

剑指 Offer 32 - II. 从上到下打印二叉树 II

剑指 Offer 32 - III. 从上到下打印二叉树 III

二叉树的层序遍历 II

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

二叉树的层平均值

二叉树的锯齿形层序遍历

剑指 Offer II 045. 二叉树最底层最左边的值

找树左下角的值

剑指 Offer II 044. 二叉树每层的最大值

在每个树行中找最大值

二叉树的右视图

剑指 Offer II 046. 二叉树的右侧视图

在二叉树中分配硬币

构造 && 思维

合并二叉树

从前序与中序遍历序列构造二叉树

从中序与后序遍历序列构造二叉树

序列化和反序列化二叉搜索树

二叉树的序列化与反序列化

剑指 Offer 37. 序列化二叉树

剑指 Offer II 048. 序列化与反序列化二叉树

从先序遍历还原二叉树

LCA

剑指 Offer 68 - I. 二叉搜索树的最近公共祖先

剑指 Offer 68 - II. 二叉树的最近公共祖先

二叉搜索树的最近公共祖先

二叉树的最近公共祖先

首个共同祖先

具有所有最深节点的最小子树

最深叶节点的最近公共祖先

从二叉树一个节点到另一个节点每一步的方向

多低调：性质里的第四题：[剑指 Offer 28. 对称的二叉树]链接错了，应该是(力扣

wian：性质里的第六题：[剑指 Offer 55 - I. 二叉树的深度]链接错了，应该是力扣

多低调：性质里的倒数第三题：[完全二叉树的节点个数] 链接错了，应该是(力扣

Ivor：后序遍历的第3~4题：二叉树剪枝、剑指offerII二叉树剪枝 链接错了，应该是 力扣 、力扣

Ivor：后序遍历的第五题，统计最高分节点数目 链接错了，应该是 力扣

多低调：先序遍历里的第五题：[1022. 从根到叶的二进制数之和]链接错了，应该是（力扣）

多低调：先序遍历里的第七题：[剑指 Offer II 049. 从根节点到叶节点的路径数字之和]链接错了，应该是（力扣）

多低调：先序遍历里的第九题：【404. 左叶子之和】链接错了，应该是（力扣）

多低调：先序遍历里的第十题：【112. 路径总和】链接错了，应该是（力扣）

多低调：先序遍历里的倒数第二题：【113. 路径总和 II】链接错了，应该是（力扣）

低调：先序遍历里的最后一题：【1448. 统计二叉树中好节点的数目】链接错了，应该是（https://leetcode.cn/problems/count-good-nodes-in-b...）

多低调：中序遍历里的最后一题：【94. 二叉树的中序遍历】链接错了，应该是（力扣）

切糕子：层序遍历里的第二题：[剑指 Offer 32 - I. 从上到下打印二叉树]链接错了，应该是（. - 力扣（LeetCode））

切糕子：层序遍历里的第九题：[二叉树的锯齿形层序遍历]链接错了，应该是（. - 力扣（LeetCode））

切糕子：层序遍历里的倒数第二题：[剑指 Offer II 046. 二叉树的右视图]链接错了，应该是（. - 力扣（LeetCode））

切糕子：构造 && 思维里的第四题：[序列化和反序列化二叉搜索树]链接错了，应该是(. - 力扣（LeetCode））

切糕子：构造 && 思维里的倒数第一题：[从先序遍历还原二叉树]链接错了，应该是(. - 力扣（LeetCode））

切糕子：LCA里的第一题：[剑指 Offer 68 - I. 二叉搜索树的最近公共祖先]链接错了，应该是（. - 力扣（LeetCode））

切糕子：LCA里的第三题：[二叉搜索树的最近公共祖先]链接错了，应该是（. - 力扣（LeetCode））

切糕子：LCA里的第四题：[二叉树的最近公共祖先]链接错了，应该是（. - 力扣（LeetCode））

切糕子：LCA里的倒数第三题：[具有所有最深节点的最小子树]链接错了，应该是（. - 力扣（LeetCode））

切糕子：LCA里的倒数第二题：[最深叶节点的最近公共祖先]链接错了，应该是（. - 力扣（LeetCode））

切糕子：LCA里的倒数第一题：[从二叉树一个节点到另一个节点每一步的方向]链接错了，应该是（. - 力扣（LeetCode））

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

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

相关文章

协议幻变者：DeviceNet转ModbusTCP网关开启机器手臂智能新纪元

协议幻变者：DeviceNet转ModbusTCP网关开启机器手臂智能新纪元

技术背景DeviceNet是一种广泛应用于工业自动化领域的现场总线标准&#xff0c;它能够实现控制器与现场设备之间的高效通信&#xff0c;常用于连接各种传感器、执行器以及其他工业设备&#xff0c;如机器人、电机驱动器等&#xff0c;具有实时性强、可靠性高的特点。而ModbusTCP…
阅读更多...
Spring Security 3.0.2.3版本

Spring Security 3.0.2.3版本

“前言” 通过实践而发现真理&#xff0c;又通过实践而证实真理和发展真理。从感性认识而能动地发展到理性认识&#xff0c;又从理性认识而能动地指导革命实践&#xff0c;改造主观世界和客观世界。实践、认识、再实践、再认识&#xff0c;这种形式&#xff0c;循环往复以至无…
阅读更多...
MiFlash 线刷工具下载合集

MiFlash 线刷工具下载合集

MiFlash 线刷工具下载合集 MiFlash 线刷工具下载合集 – MIUI历史版本相较于小米助手的刷机功能&#xff0c;线刷还是偏好使用 MiFlash。特点是界面简单纯粹&#xff0c;有自定义高级选项&#xff0c;可以选择刷机不上 BL 锁&#xff0c;自定义刷机脚本&#xff0c;EDL 刷机模…
阅读更多...
Oracle 多租户架构简介

Oracle 多租户架构简介

目录 零. 简介一. CDB&#xff08;Container Database&#xff0c;容器数据库&#xff09;二. PDB&#xff08;Pluggable Database&#xff0c;可插拔数据库&#xff09;三. CDB 与 PDB 的比较四. 用户的种类五. XE 与 XEPDB1 零. 简介 ⏹Oracle 多租户架构&#xff08;Multit…
阅读更多...
掌握大数据处理利器：Flink 知识点全面总结【上】

掌握大数据处理利器：Flink 知识点全面总结【上】

1.Flink的特点 Apache Flink 是一个框架和分布式处理引擎&#xff0c;用于对无界和有界数据流进行状态计算。 Flink主要特点如下&#xff1a; 高吞吐和低延迟。每秒处理数百万个事件&#xff0c;毫秒级延迟。结果的准确性。Flink提供了事件时间(event--time)和处理时间(proces…
阅读更多...
[论文阅读] (34)ESWA2024 基于SGDC的轻量级入侵检测系统

[论文阅读] (34)ESWA2024 基于SGDC的轻量级入侵检测系统

《娜璋带你读论文》系列主要是督促自己阅读优秀论文及听取学术讲座&#xff0c;并分享给大家&#xff0c;希望您喜欢。由于作者的英文水平和学术能力不高&#xff0c;需要不断提升&#xff0c;所以还请大家批评指正&#xff0c;非常欢迎大家给我留言评论&#xff0c;学术路上期…
阅读更多...
《向量数据库指南》——Milvus Cloud 2.5：Sparse-BM25引领全文检索新时代

《向量数据库指南》——Milvus Cloud 2.5：Sparse-BM25引领全文检索新时代

Milvus Cloud BM25：重塑全文检索的未来 在最新的Milvus Cloud 2.5版本中，我们自豪地引入了“全新”的全文检索能力，这一创新不仅巩固了Milvus Cloud在向量数据库领域的领先地位，更为用户提供了前所未有的灵活性和效率。作为大禹智库的向量数据库高级研究员，以及《向量数据…
阅读更多...
常用的数据库类型都有哪些

常用的数据库类型都有哪些

在Java开发和信息系统架构中&#xff0c;数据库扮演着存储和管理数据的关键角色。数据库种类繁多&#xff0c;各有特色&#xff0c;适用于不同的应用场景。 1. 关系型数据库&#xff08;RDBMS&#xff09;&#xff1a; • 关系型数据库是最为人熟知的数据库类型&#xff0c;数据…
阅读更多...
计算机网络—————考研复试

计算机网络—————考研复试

第一章、计算机网络体系结构 1. OSI参考模型和TCP/IP模型&#xff1a; OSI与TCP/IP的记忆方法&#xff1a;只需把OSI的七层记住&#xff0c;将应用层、表示层、会话层一起记&#xff0c;到TCP/IP变成应用层。物理层和数据链路层换成网络接口层。把网络层换个字变成网际层。 而…
阅读更多...
从2024看2025前端发展趋势

从2024看2025前端发展趋势

前言 又至年关&#xff0c;回顾整个2024年&#xff0c;前端行业仍旧百废待兴&#xff0c;IT业界同样也未见有所起色&#xff0c;AI风潮也从狂热兴奋逐步走向了冷静稳定阶段&#xff0c;造成此形势感观并非单一行业或者某一企业之特例&#xff0c;实为政经等综合影响之结果。因…
阅读更多...
国内机器视觉产业链全解析

国内机器视觉产业链全解析

欢迎关注《光场视觉》 简单的&#xff0c;我们可以把机器视觉产业链可以分为底层开发商&#xff08;核心零部件和软件提供商&#xff09;、集成和软件服务商&#xff08;二次开发&#xff09;&#xff0c;核心零部件及软件又可以再细分为光源、镜头、工业相机、图像采集卡、图…
阅读更多...
node.js之---事件循环机制

node.js之---事件循环机制

事件循环机制 Node.js 事件循环机制&#xff08;Event Loop&#xff09;是其核心特性之一&#xff0c;它使得 Node.js 能够高效地处理大量并发的 I/O 操作。Node.js 基于 非阻塞 I/O&#xff0c;使用事件驱动的模型来实现异步编程。事件循环是 Node.js 实现异步编程的基础&…
阅读更多...
如何在没有 iCloud 的情况下将数据从 iPhone 传输到 iPhone

如何在没有 iCloud 的情况下将数据从 iPhone 传输到 iPhone

概括 您可能会遇到将数据从 iPhone 转移到 iPhone 的情况&#xff0c;尤其是当您获得新的 iPhone 15/14 时&#xff0c;您会很兴奋并希望将数据转移到它。 使用iCloud最终可以做到这一点&#xff0c;但它的缺点也不容忽视&#xff0c;阻碍了你选择它。例如&#xff0c;您需要…
阅读更多...
HTML——26.像素单位

HTML——26.像素单位

<!DOCTYPE html> <html><head><meta charset"UTF-8"><title>像素</title></head><body><!--像素&#xff1a;1.指设备屏幕上的一个点&#xff0c;单位px&#xff0c;如led屏上的小灯朱2.当屏幕分辨率固定时&…
阅读更多...
智能商业分析 Quick BI

智能商业分析 Quick BI

Quick BI 是阿里云提供的一款智能商业分析&#xff08;BI&#xff09;工具&#xff0c;旨在帮助企业快速获取业务洞察、优化决策过程、提升数据分析效率。通过强大的数据可视化和分析功能&#xff0c;Quick BI 能够帮助用户轻松连接多种数据源、创建多维度的报表和仪表盘&#…
阅读更多...
multisim仿真搭建三极管开关电路，低电平（5V）控制高电平（12V）输出

multisim仿真搭建三极管开关电路，低电平（5V）控制高电平（12V）输出

通过三极管搭建电路&#xff0c;低电平&#xff08;5V&#xff09;控制高电平&#xff08;12V&#xff09;输出 低电平输入&#xff1a;当输入信号为低电平时&#xff08;0V&#xff09;&#xff0c;三极管Q1处于截止状态。上拉电阻R1的存在&#xff0c;Q2输入端被拉到低电平&a…
阅读更多...
Python跨年烟花

Python跨年烟花

目录 系列文章 写在前面 技术需求 完整代码 下载代码 代码分析 1. 程序初始化与显示设置 2. 烟花类 (Firework) 3. 粒子类 (Particle) 4. 痕迹类 (Trail) 5. 烟花更新与显示 6. 主函数 (fire) 7. 游戏循环 8. 总结 注意事项 写在后面 系列文章 序号直达链接爱…
阅读更多...
LeetCode - 初级算法 数组（删除排序数组中的重复项）

LeetCode - 初级算法 数组（删除排序数组中的重复项）

免责声明：本文来源于个人知识与公开资料，仅用于学术交流。 删除排序数组中的重复项 这篇文章讨论如何从一个非严格递增的数组 nums 中删除重复的元素，使每个元素只出现一次，并返回新数组的长度。因为数组是排序的，只要是相同的肯定是挨着的，所以我们需要遍历所有数组，然…
阅读更多...
【yolov5】实现FPS游戏人物检测，并定位到矩形框上中部分，实现自瞄

【yolov5】实现FPS游戏人物检测，并定位到矩形框上中部分，实现自瞄

介绍 本人机器学习小白&#xff0c;通过语言大模型百度进行搜索&#xff0c;磕磕绊绊的实现了初步效果&#xff0c;能有一些锁头效果&#xff0c;但识别速度不是非常快&#xff0c;且没有做敌友区分&#xff0c;效果不是非常的理想&#xff0c;但在4399小游戏中爽一下还是可以…
阅读更多...
Java jni调用nnom rnn-denoise 降噪

Java jni调用nnom rnn-denoise 降噪

介绍&#xff1a;https://github.com/majianjia/nnom/blob/master/examples/rnn-denoise/README_CN.md 默认提供了一个wav的例子 #include <stdint.h> #include <stdlib.h> #include <stdio.h> #include <math.h> #include <string.h>#include …
阅读更多...
最新文章

Copyright @ 2022~2023