查找-多路查找详解篇

多路查找树

多路查找树（Multway Search Tree）是一种高级的树形数据结构，它
允许每个节点有多个子节点（通常大于等于2）。多路查找树的每个节点
可以存储多个关键字和对应的值。

分类

2-3树（2-3 Tree）：
2-3树是一种最简单的多路查找树，每个节点可以存储1个或2个关键字，
并有2个或3个子节点。
2-3树的特点是所有叶子节点都在同一层，且根节点到每个叶子节点的
路径长度相等，保持树的平衡性。B-树（B-tree）：
B-树是一种平衡的多路查找树，每个节点可以存储多个关键字，并有相
应数量的子节点。
B-树的特点是节点的关键字按照升序排列，具有高度平衡的特性，主要
用于在磁盘等外部存储设备中高效存储和检索数据。B+树（B+ tree）：
B+树是B-树的一种变种，在B-树的基础上做了一些优化，特别适合于范
围查询和顺序访问。
B+树的特点是只有叶子节点存储了真实数据，而内部节点仅用于索引，
叶子节点通过指针连接形成一个链表，方便范围查询。B树（B-tree）：
B*树也是B-树的一种变种，与B+树类似，它在B-树的基础上做了一些改
进。
B*树通过在非叶子节点中存储部分关键字，扩大了节点的使用率，减少
了磁盘访问次数，并提高了空间和时间的效率。Trie树（字典树或前缀树）：
Trie树是一种特殊的多路查找树，在处理字符串和前缀匹配的情况下非
常有用。
Trie树的特点是每个节点代表一个字符，从根节点到叶子节点的路径可
以表示一个完整的字符串。除此以外，还有如2-3-4树、2-3-4-树、B*+树等。每种多路查找树在
平衡性、存储结构、查询性能等方面可能有所不同，选择合适的多路查
找树取决于应用需求和数据特点。对于大规模的外部存储数据，B-树和
B+树是常见的选择；对于高效的字符串匹配和前缀查询，Trie树是一种
有效的数据结构。

详细介绍

在这里插入图片描述

2-3树（2-3 Tree）

2-3树是一种平衡的多路查找树，每个节点可以存储1个或2个关键字，并有2个
或3个子节点。以下是关于2-3树的详细介绍：

在这里插入图片描述

结构特点：

2-3树由节点组成，每个节点可以存储1个或2个关键字，这些关键字按升序排列。
每个节点有2个或3个子节点，对应于存储的关键字个数。
所有叶子节点都在同一层，且根节点到每个叶子节点的路径长度相等，保持树的
平衡性。

插入操作：

1、当要插入一个关键字时，从根节点开始，判断关键字应插入的位置。
2、如果节点已满（即已有两个关键字），则需要进行节点分裂操作。将中间较大的关键字移动到上一层的父节点，并将两个剩余的关键字分别创建为新的子节点。
3、如果节点还没有满，则直接将关键字插入到正确的位置。

在这里插入图片描述

删除操作：

当要删除一个关键字时，从根节点开始，找到包含该关键字的节点。如果该节点是叶子节点，直接删除关键字即可。如果该节点是内部节点，有几种情况需要处理：如果该节点有2个关键字，则可以直接删除关键字，不需要做其他操作。如果该节点有1个关键字：如果其兄弟节点有2个关键字，则可以借用兄弟节点的一个关键字，并进行相关的调整。如果其兄弟节点也只有1个关键字，则需要进行合并操作，将关键字和子节点合并到一起。

查询操作：

2-3树的查询操作与二叉查找树类似，从根节点开始，根据关键字的大小比较，
向左或向右子节点递归查询，直到找到匹配的关键字或遇到叶子节点。

强调

2-3树的特点在于其每个节点可以存储多个关键字，这样可以减少树的高度，提
供更高效的搜索和插入操作。它保持了树的平衡性，且所有叶子节点都在同一层，
这样可以保证较为平衡的查询性能。然而，2-3树的实现和维护操作较为复杂，
导致其并不常用，更常见的是其变种B-树和B+树，它们在2-3树的基础上进行了
一些优化和改进。

Java代码实现

// 2-3树的节点类
class Node {private int[] keys;  // 节点的关键字private Node[] children;  // 子节点数组private int size;  // 节点包含的关键字数量private boolean isLeaf;  // 是否为叶子节点public Node(boolean isLeaf) {this.keys = new int[3];this.children = new Node[4];this.size = 0;this.isLeaf = isLeaf;}// 从节点中查找关键字的位置public int findKey(int key) {for (int i = 0; i < size; i++) {if (keys[i] == key) {return i;} else if (keys[i] > key) {return -1;}}return -1;}// 在节点中插入关键字public void insertKey(int key) {if (size == 0) {keys[0] = key;size++;} else {int i = size - 1;while (i >= 0 && keys[i] > key) {keys[i + 1] = keys[i];i--;}keys[i + 1] = key;size++;}}// 在节点中删除关键字public void deleteKey(int key) {int index = findKey(key);if (index != -1) {for (int i = index; i < size - 1; i++) {keys[i] = keys[i + 1];}size--;}}// 获取节点的关键字数量public int getSize() {return size;}// 判断节点是否为叶子节点public boolean isLeaf() {return isLeaf;}// 获取节点指定位置的子节点public Node getChild(int index) {return children[index];}// 设置节点指定位置的子节点public void setChild(int index, Node child) {children[index] = child;}
}// 2-3树类
class TwoThreeTree {private Node root;public TwoThreeTree() {root = null;}// 在2-3树中插入关键字public void insert(int key) {if (root == null) {root = new Node(true);root.insertKey(key);} else {Node newNode = insertKey(root, key);if (newNode != null) {Node oldRoot = root;root = new Node(false);root.setChild(0, oldRoot);root.setChild(1, newNode);root.insertKey(newNode.keys[0]);root.insertKey(oldRoot.keys[0]);}}}// 在给定的节点中插入关键字private Node insertKey(Node node, int key) {if (node.isLeaf()) {node.insertKey(key);if (node.getSize() > 2) {return splitLeaf(node);}} else {int i = node.getSize() - 1;while (i >= 0 && key < node.getChild(i).keys[0]) {i--;}Node newNode = insertKey(node.getChild(i + 1), key);if (newNode != null) {node.insertKey(newNode.keys[0]);}

B-树（B-tree）

B-树（B-tree）是一种平衡的多路查找树，广泛应用于在磁盘等外部存储设备中
高效地存储和检索大量数据。以下是关于B-树的详细介绍：

在这里插入图片描述

结构特点：

B-树由节点组成，每个节点可以存储多个
关键字，这些关键字按升序排列。
B-树的特点是节点的关键字按升序排列，具有高度平衡的特性。
每个节点通常有多个子节点，最多可以拥有m个子节点，其中m称为B-树的阶数。

插入操作：

1、当要插入一个关键字时，从根节点开始，判断关键字应插入的位置。
2、如果节点已满，则需要进行节点分裂操作。将中间位置的关键字提升为父节点，并将节点分裂为两个节点，将剩余的关键字均匀分配到这两个节点中。
3、如果要插入的节点还没有满，则直接将关键字插入到合适的位置。

删除操作：

1、当要删除一个关键字时，从根节点开始，找到包含该关键字的节点。
2、如果该节点是叶子节点，直接删除关键字即可。如果该节点是内部节点，需要找到其前驱或后继关键字来替代删除的关键字。
3、在删除操作后，如果节点中的关键字数量过少，则需要进行节点合并或者从兄弟节点中借用关键字来保持树的平衡。

查询操作：

B-树的查询操作与二叉查找树类似，从根节点开始，根据关键字的大小比较，
向左或向右子节点递归查询，直到找到匹配的关键字或遇到叶子节点。

在这里插入图片描述

强调

B-树适用于大规模数据存储和查询的场景，尤其是需要在外部存储设备上进行操
作的情况。B-树的高度平衡保证了较为均衡的查询性能，因为从根节点到叶子节
点的路径长度相等或差别不大。B-树的阶数m可以根据具体应用和硬件限制来选
择，通常情况下，较大的阶数有助于减少磁盘访问的次数，提高效率。B-树的变种B+树在B-树的基础上做了一些优化，将所有数据存储在叶子节点中，
使得范围查询和顺序访问更加高效。因此，在现代数据库系统和文件系统中，
B+树更加常见和广泛应用。

代码实现

import java.util.ArrayList;
import java.util.List;class BMinusTreeNode {public boolean isLeaf; // 是否是叶子节点public List<Integer> keys; // 节点中存储的关键字public List<BMinusTreeNode> children; // 节点的子节点public BMinusTreeNode() {keys = new ArrayList<>();children = new ArrayList<>();}
}class BMinusTree {private BMinusTreeNode root;private int t; // B-树的阶数public BMinusTree(int degree) {root = new BMinusTreeNode();root.isLeaf = true;t = degree;}public void insert(int key) {// 根节点满了就分裂if (root.keys.size() == (2 * t)) {BMinusTreeNode newRoot = new BMinusTreeNode();newRoot.children.add(root);splitChild(newRoot, 0, root);root = newRoot;}insertNonFull(root, key);}private void insertNonFull(BMinusTreeNode node, int key) {int index = node.keys.size() - 1;if (node.isLeaf) {while (index >= 0 && node.keys.get(index) > key) {index--;}node.keys.add(index + 1, key);} else {while (index >= 0 && node.keys.get(index) > key) {index--;}index++;if (node.children.get(index).keys.size() == (2 * t)) {splitChild(node, index, node.children.get(index));if (node.keys.get(index) < key) {index++;}}insertNonFull(node.children.get(index), key);}}private void splitChild(BMinusTreeNode parent, int index, BMinusTreeNode node) {BMinusTreeNode newNode = new BMinusTreeNode();newNode.isLeaf = node.isLeaf;parent.keys.add(index, node.keys.get(t - 1));parent.children.add(index + 1, newNode);for (int i = t; i < 2 * t - 1; i++) {newNode.keys.add(node.keys.get(i));}if (!node.isLeaf) {for (int i = t; i < 2 * t; i++) {newNode.children.add(node.children.get(i));}}for (int i = 2 * t - 2; i >= t - 1; i--) {node.keys.remove(i);}if (!node.isLeaf) {for (int i = 2 * t - 1; i >= t; i--) {node.children.remove(i);}}}

B+树（B+tree）

B+树（B+ tree）是B-树的一种变种，特别适用于范围查询和顺序访问。

结构特点：

B+树与B-树类似，由节点组成，每个节点可以存储多个关键字，这些关键字按升
序排列。B+树的特点是只有叶子节点存储了真实数据，而内部节点仅用于索引。叶子节点
通过指针连接形成一个链表，方便范围查询和顺序访问。
内部节点特点：
内部节点存储关键字和指向子节点的指针。
内部节点的关键字按升序排列，用于指示范围查询的起点。
内部节点的指针指向比关键字更大的子节点。
叶子节点特点：
叶子节点存储真实数据和指向下一个叶子节点的指针。
叶子节点的关键字按升序排列，支持范围查询和顺序访问。
所有叶子节点通过指针连接成一个链表，便于范围查询和顺序访问。

插入操作：

当要插入一个关键字时，从根节点开始，找到合适的叶子节点。
如果叶子节点已满，则需要进行节点分裂操作。将中间位置的关键字提升到父节
点，并将两个剩余的部分分别创建为新的叶子节点。
如果叶子节点还没有满，则直接将关键字插入到合适的位置。

删除操作：

当要删除一个关键字时，从根节点开始，找到包含该关键字的叶子节点。
直接删除叶子节点中的关键字，并更新链表指针。
删除操作后，如果叶子节点的关键字个数过少，则需要从兄弟节点借用关键字或
进行节点合并。

查询操作：


B+树的查询操作与B-树类似，从根节点开始，根据关键字的大小比较，向左或向右子节点递归查询，直到找到匹配的关键字或遇到叶子节点。
对于范围查询和顺序访问，可以从叶子节点开始，沿着链表进行遍历。

强调

B+树的特点在于只有叶子节点存储真实数据，这样使得范围查询和顺序访问更加
高效，因为数据在叶子节点上连续存储，读取连续的数据块比随机读取更快。而
内部节点仅存储索引信息，可以容纳更多的索引，提高了查询效率。B+树的实现
适用于需要高效地处理大量数据的数据库和文件系统，能够提供较高的查询性能
和存储效率。

代码实现

import java.util.ArrayList;
import java.util.List;class BPlusTreeNode {public boolean isLeaf;public List<Integer> keys;public List<Object> values;public List<BPlusTreeNode> children;public BPlusTreeNode next;public BPlusTreeNode() {isLeaf = false;keys = new ArrayList<>();values = new ArrayList<>();children = new ArrayList<>();next = null;}
}class BPlusTree {private BPlusTreeNode root;private int m;public BPlusTree(int m) {root = new BPlusTreeNode();root.isLeaf = true;this.m = m;}// 插入操作public void insert(int key, Object value) {if (root.keys.size() == m) {BPlusTreeNode newRoot = new BPlusTreeNode();newRoot.children.add(root);splitChild(newRoot, 0, root);root = newRoot;}insertNonFull(root, key, value);}// 非满子节点插入操作private void insertNonFull(BPlusTreeNode node, int key, Object value) {int index = node.keys.size() - 1;if (node.isLeaf) {while (index >= 0 && node.keys.get(index) > key) {index--;}node.keys.add(index + 1, key);node.values.add(index + 1, value);node.next = node.next;} else {while (index >= 0 && node.keys.get(index) > key) {index--;}index++;if (node.children.get(index).keys.size() == m) {splitChild(node, index, node.children.get(index));if (node.keys.get(index) < key) {index++;}}insertNonFull(node.children.get(index), key, value);}}// 分裂满子节点private void splitChild(BPlusTreeNode parent, int index, BPlusTreeNode node) {BPlusTreeNode newNode = new BPlusTreeNode();newNode.isLeaf = node.isLeaf;parent.keys.add(index, node.keys.get(m / 2));parent.children.add(index + 1, newNode);newNode.keys.addAll(node.keys.subList((m / 2) + 1, m));newNode.values.addAll(node.values.subList((m / 2) + 1, m));if (!node.isLeaf) {newNode.children.addAll(node.children.subList((m / 2) + 1, m + 1));node.children.subList((m / 2) + 1, m + 1).clear();} else {newNode.next = node.next;node.next = newNode;}node.keys.subList(m / 2, m).clear();node.values.subList(m / 2, m).clear();}// 搜索操作public List<Object> search(int key) {return search(root, key);}private List<Object> search(BPlusTreeNode node, int key) {int index = 0;while (index < node.keys.size() && key > node.keys.get(index)) {index++;}if (index < node.keys.size() && key == node.keys.get(index)) {return node.values.get(index);} else if (node.isLeaf) {return null;} else {return search(node.children.get(index), key);}}
}

B树（B-tree）

B树（B-tree）是一种平衡的多路查找树，主要用于在磁盘等外部存储设备中高
效地存储和检索大量数据。以下是关于B树的详细介绍：

结构特点：

B树由节点组成，每个节点可以存储多个关键字，这些关键字按升序排列。
B树的特点是节点的关键字按升序排列，具有高度平衡的特性。
每个节点通常有多个子节点，最多可以拥有m个子节点，其中m称为B树的阶数。

插入操作：

当要插入一个关键字时，从根节点开始，判断关键字应插入的位置。
如果节点已满（即已有m-1个关键字），则需要进行节点分裂操作。将中间位置
的关键字提升为父节点，并将节点分裂为两个节点，将剩余的关键字均匀分配到
这两个节点中。
如果要插入的节点还没有满，则直接将关键字插入到合适的位置。

删除操作：

当要删除一个关键字时，从根节点开始，找到包含该关键字的节点。
如果该节点是叶子节点，直接删除关键字。
如果该节点是内部节点，有几种情况需要处理：
如果该节点有足够多的关键字，则可以直接删除关键字。
如果该节点的关键字数量过少，需要考虑兄弟节点的关键字数量以及兄弟节点合
并的情况。

查询操作：

B树的查询操作与二叉查找树类似，从根节点开始，根据关键字的大小比较，向
左或向右子节点递归查询，直到找到匹配的关键字或遇到叶子节点。
B树适用于大规模数据存储和查询的场景，特别适用于外部存储设备上的数据存
储。其平衡性保证了较为均衡的查询性能，因为从根节点到叶子节点的路径长度
相等或差别不大。B树的阶数m可以根据具体应用和硬件限制来选择，较大的阶数
有助于减少磁盘访问的次数，提高效率。

强调

B树的变种B+树在B树的基础上做了一些优化，将所有的数据都存储在叶子节点
中，使得范围查询和顺序访问更加高效。因此，B+树在现代数据库系统和文件
系统中更为常见和广泛应用。、

代码实现

import java.util.ArrayList;
import java.util.List;class BTreeNode {int degree; // B树的阶数List<Integer> keys; // 节点中存储的关键字List<BTreeNode> children; // 节点的子节点boolean isLeaf; // 是否是叶子节点public BTreeNode(int degree, boolean isLeaf) {this.degree = degree;this.isLeaf = isLeaf;keys = new ArrayList<>();children = new ArrayList<>();}
}class BTree {BTreeNode root; // B树的根节点int degree; // B树的阶数public BTree(int degree) {this.degree = degree;root = new BTreeNode(degree, true);}// 插入关键字public void insert(int key) {if (root.keys.size() == (2 * degree - 1)) {BTreeNode newRoot = new BTreeNode(degree, false);newRoot.children.add(root);splitChild(newRoot, 0, root);root = newRoot;}insertNonFull(root, key);}// 在非满节点插入关键字private void insertNonFull(BTreeNode node, int key) {int index = node.keys.size() - 1;if (node.isLeaf) {while (index >= 0 && key < node.keys.get(index)) {index--;}node.keys.add(index + 1, key);} else {while (index >= 0 && key < node.keys.get(index)) {index--;}index++;if (node.children.get(index).keys.size() == (2 * degree - 1)) {splitChild(node, index, node.children.get(index));if (key > node.keys.get(index)) {index++;}}insertNonFull(node.children.get(index), key);}}// 分裂子节点private void splitChild(BTreeNode parent, int index, BTreeNode node) {BTreeNode newNode = new BTreeNode(degree, node.isLeaf);parent.keys.add(index, node.keys.get(degree - 1));parent.children.add(index + 1, newNode);for (int i = 0; i < degree - 1; i++) {newNode.keys.add(node.keys.get(i + degree));if (!node.isLeaf) {newNode.children.add(node.children.get(i + degree));}}if (!node.isLeaf) {newNode.children.add(node.children.get(2 * degree - 1));}for (int i = degree - 1; i >= 0; i--) {node.keys.remove(i + degree - 1);if (!node.isLeaf) {node.children.remove(i + degree);}}}// 搜索关键字public boolean search(int key) {return search(root, key);}private boolean search(BTreeNode node, int key) {int index = 0;while (index < node.keys.size() && key > node.keys.get(index)) {index++;}if (index < node.keys.size() && key == node.keys.get(index)) {return true;} else if (node.isLeaf) {return false;} else {return search(node.children.get(index), key);}}
}

Trie树（字典树或前缀树）

Trie树，也被称为字典树或前缀树，是一种用于高效存储和搜索字符串的树型数
据结构。Trie树的主要特点是通过字符串的前缀来进行搜索和匹配。

结构特点：

Trie树由根节点和一系列子节点组成。
根节点不包含任何关键字，每个子节点都表示一个字符，并按字符的顺序连接形
成路径。
从根节点到每个叶子节点的路径都对应一个字符串。
每个节点可以存储额外的信息，如词频或附加数据等。

插入操作：

当要插入一个字符串时，从根节点开始，逐个字符按顺序插入。
如果某个字符对应的子节点不存在，则创建一个新的子节点。
插入字符串的最后一个字符后，将当前节点标记为一个单词的结束。

搜索操作：

当要搜索一个字符串时，从根节点开始，逐个字符按顺序匹配。
如果某个字符对应的子节点存在，则继续匹配下一个字符。
如果匹配遇到缺失的字符或到达某个节点后没有子节点，则表示字符串不在Trie
树中。
如果匹配成功并且在Trie树中找到最后一个字符，则表示字符串存在于Trie树中。

删除操作：

当要删除一个字符串时，从根节点开始，逐个字符按顺序遍历。
如果遍历过程中发现某个字符对应的子节点不存在，则表示字符串不存在于Trie
树中。
如果遍历成功，并到达字符串的最后一个字符，将当前节点的结束标记取消。
如果遍历成功，但还存在其他相关字符串（例如，删除"abc"但还有"abcd"），
可以保留当前节点以表示其他相关字符串。

优点：

搜索的时间复杂度与字符串长度无关，仅与Trie树的高度相关，通常比哈希表更
高效。
可以高效地搜索具有相同前缀的字符串集合。
对于字符串的前缀匹配和自动补全，Trie树可以提供高效的结果。

缺点:

空间消耗较大，尤其在处理大量长字符串时。为了缓解这个问题，可以使用压缩
的Trie树，如压缩前缀树（Patricia树）或Trie树的变种来减少存储空间。

代码实现

class TrieNode {private TrieNode[] children;private boolean isEndOfWord;public TrieNode() {children = new TrieNode[26]; // 26个英文字母isEndOfWord = false;}public TrieNode getChild(char ch) {return children[ch - 'a'];}public void setChild(char ch, TrieNode node) {children[ch - 'a'] = node;}public boolean isEndOfWord() {return isEndOfWord;}public void setEndOfWord(boolean isEndOfWord) {this.isEndOfWord = isEndOfWord;}
}class Trie {private TrieNode root;public Trie() {root = new TrieNode();}public void insert(String word) {TrieNode node = root;for (char ch : word.toCharArray()) {if (node.getChild(ch) == null) {node.setChild(ch, new TrieNode());}node = node.getChild(ch);}node.setEndOfWord(true);}public boolean search(String word) {TrieNode node = findNode(word);return node != null && node.isEndOfWord();}public boolean startsWith(String prefix) {TrieNode node = findNode(prefix);return node != null;}private TrieNode findNode(String str) {TrieNode node = root;for (char ch : str.toCharArray()) {node = node.getChild(ch);if (node == null) {return null;}}return node;}
}

使用示例

public class Main {public static void main(String[] args) {Trie trie = new Trie();trie.insert("apple");trie.insert("banana");trie.insert("grape");System.out.println(trie.search("apple")); // 输出: trueSystem.out.println(trie.search("orange")); // 输出: falseSystem.out.println(trie.startsWith("app")); // 输出: trueSystem.out.println(trie.startsWith("ban")); // 输出: trueSystem.out.println(trie.startsWith("grap")); // 输出: true}
}

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

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

相关文章

什么是多运行时架构？

什么是多运行时架构？

服务化演进中的问题 自从数年前微服务的概念被提出&#xff0c;到现在基本成了技术架构的标配。微服务的场景下衍生出了对分布式能力的大量需求&#xff1a;各服务之间需要相互协作和通信&#xff0c;以及共享状态等等&#xff0c;因此就有了各种中间件来为业务服务提供这种分…
阅读更多...
逻辑斯特回归

逻辑斯特回归

*分类是离散的&#xff0c;回归是连续的 下载数据集 trainTrue&#xff1a;下载训练集 逻辑斯蒂函数保证输出值在0-1之间 能够把实数值映射到0-1之间 导函数类似正态分布 其他饱和函数sigmoid functions 循环神经网络经常使用tanh函数 与线性回归区别 塞戈马无参数&#x…
阅读更多...
STM32CubeMX v6.9.0 BUG：FLASH_LATENCY设置错误导致初始化失败

STM32CubeMX v6.9.0 BUG：FLASH_LATENCY设置错误导致初始化失败

背景 今天在调试外设功能时&#xff0c;发现设置了使用外部时钟之后程序运行异常&#xff0c;进行追踪调试并与先前可以正常运行的项目进行对比之后发现这个问题可能是由于新版本的STM32CubeMX配置生成代码时的BUG引起的。 测试环境 MCU: STM32H750VBT6 STM32CubeIDE: Versi…
阅读更多...
大数据处理架构详解：Lambda架构、Kappa架构、流批一体、Dataflow模型、实时数仓

大数据处理架构详解：Lambda架构、Kappa架构、流批一体、Dataflow模型、实时数仓

前言 本文隶属于专栏《大数据理论体系》&#xff0c;该专栏为笔者原创&#xff0c;引用请注明来源&#xff0c;不足和错误之处请在评论区帮忙指出&#xff0c;谢谢&#xff01; 本专栏目录结构和参考文献请见大数据理论体系 姊妹篇 《分布式数据模型详解&#xff1a;OldSQL &…
阅读更多...
【Linux从入门到精通】进程的控制（进程退出+进程等待）

【Linux从入门到精通】进程的控制（进程退出+进程等待）

本篇文章主要讲述的是进程的退出和进程等待。希望本篇文章的内容会对你有所帮助。 文章目录 一、fork创建子进程 1、1 在创建子进程中操作系统的作用 1、2 写时拷贝 二、进程终止 2、1 常见的进程退出 2、2 进程的退出码 2、2、1 运行结果正确实例 2、2、2 运行结果不正确实例…
阅读更多...
购物车功能实现(小兔鲜儿)【Vue3】

购物车功能实现(小兔鲜儿)【Vue3】

购物车 流程梳理和本地加入购物车实现 购物车业务逻辑梳理拆解 整个购物车的实现分为两个大分支, 本地购物车操作和接口购物车操作由于购物车数据的特殊性,采取Pinia管理购物车列表数据并添加持久化缓存 本地购物车 - 加入购物车实现 添加购物车 基础思想&#xff1a;如果…
阅读更多...
高算力AI模组前沿应用：基于ARM架构的SoC阵列式服务器

高算力AI模组前沿应用：基于ARM架构的SoC阵列式服务器

本期我们带来高算力AI模组前沿应用&#xff0c;基于ARM架构的SoC阵列式服务器相关内容。澎湃算力、创新架构、异构计算&#xff0c;有望成为未来信息化社会的智能算力底座。 ▌性能优势AI驱动&#xff0c;ARM架构服务器加速渗透 一直以来&#xff0c;基于ARM架构的各类处理器…
阅读更多...
python 字符串操作

python 字符串操作

1.字符串的使用 1.1 字符串的截取 str len1800 截取字符串中数字&#xff0c;并转化为数字 str1 str[4:] #得到字符串 1800&#xff0c; num eval(str1) #将字符串转换为数字&#xff0c;eval 用于比较复杂的情况&#xff0c;也可以直接用int(str1) #eval用于更复杂…
阅读更多...
mybatisplus映射解读

mybatisplus映射解读

目录 自动映射 表映射 字段映射 字段失效 视图属性 Mybatis框架之所以能够简化数据库操作&#xff0c;是因为他内部的映射机制&#xff0c;通过自动映射&#xff0c;进行数据的封装&#xff0c;我们只要符合映射规则&#xff0c;就可以快速高效的完成SQL操作的实现。既然…
阅读更多...
STM32 Flash学习（一）

STM32 Flash学习（一）

STM32 FLASH简介 不同型号的STM32&#xff0c;其Flash容量也不同。 MiniSTM32开发板选择的STM32F103RCT6的FLASH容量为256K字节&#xff0c;属于大容量产品。 STM32的闪存模块由&#xff1a;主存储器、信息块和闪存存储器接口寄存器等3部分组成。 主存储器&#xff0c;该部分…
阅读更多...
3分钟学会设计模式 -- 单例模式

3分钟学会设计模式 -- 单例模式

►单例模式 ►使用场景 在编写软件时&#xff0c;对于某些类来说&#xff0c;只有一个实例很重要。例如&#xff0c;一个系统中可以存在多个打印任务&#xff0c;但是只能有一个正在工作的任务&#xff1b;一个系统中可以多次查询数据库&#xff0c;但是只需要一个连接&#x…
阅读更多...
Dart - 语法糖（持续更新）

Dart - 语法糖（持续更新）

文章目录 前言开发环境中间表示语法糖1. 操作符/运算符&#xff08;?./??/??/../?../.../...?&#xff09;2. 循环&#xff08;for-in&#xff09;3. 函数/方法&#xff08;>&#xff09;4. 关键字&#xff08;await for&#xff09; 最后 前言 通过将dill文件序列化…
阅读更多...
HTML快速学习

HTML快速学习

目录 一、网页元素属性 1.全局属性 2.标签 2.1其他标签 2.2表单标签 2.3图像标签 2.4列表标签 2.5表格标签 2.6文本标签 二、编码 1.字符的数字表示法 2.字符的实体表示法 三、实践一下 一、网页元素属性 1.全局属性 id属性是元素在网页内的唯一标识符。 class…
阅读更多...
【使用深度学习的城市声音分类】使用从提取音频特征（频谱图）中提取的深度学习进行声音分类研究（Matlab代码实现）

【使用深度学习的城市声音分类】使用从提取音频特征（频谱图）中提取的深度学习进行声音分类研究（Matlab代码实现）

&#x1f4a5;&#x1f4a5;&#x1f49e;&#x1f49e;欢迎来到本博客❤️❤️&#x1f4a5;&#x1f4a5; &#x1f3c6;博主优势&#xff1a;&#x1f31e;&#x1f31e;&#x1f31e;博客内容尽量做到思维缜密&#xff0c;逻辑清晰&#xff0c;为了方便读者。 ⛳️座右铭&a…
阅读更多...
SpringMVC-mybatis中可以返回查询的个数，但是都为null。。。

SpringMVC-mybatis中可以返回查询的个数，但是都为null。。。

通过postman测试请求时&#xff0c;显示查询成功&#xff0c;返回一个json数组&#xff0c;里面也有数据&#xff0c;但是数据都是null。 说明&#xff1a;确实是sql执行成功了&#xff0c;只不过是没有将sql中的字段的值给注入到对象的属性中去。。。 Select("SELECT * …
阅读更多...
cv2抛出异常 “install libgtk2.0-dev and pkg-config, then re-run cmake or configure”

cv2抛出异常 “install libgtk2.0-dev and pkg-config, then re-run cmake or configure”

背景&#xff1a; linux中使用cv2显示图片的时候&#xff0c;运行提示异常&#xff1a; 处理方式&#xff1a; 网友的推荐操作&#xff1a; 切换至root模式安装 apt-get install libgtk2.0-dev进入OpenCV下载目录&#xff0c;重新编译 cd /home/XXX/opencv mkdir release …
阅读更多...
项目2 | 负载均衡式在线OJ

项目2 | 负载均衡式在线OJ

啊我摔倒了..有没有人扶我起来学习.... &#x1f471;个人主页&#xff1a; 《 C G o d 的个人主页》 \color{Darkorange}{《CGod的个人主页》} 《CGod的个人主页》交个朋友叭~ &#x1f492;个人社区&#xff1a; 《编程成神技术交流社区》 \color{Darkorange}{《编程成神技术…
阅读更多...
pytorch2.x 官方quickstart测试

pytorch2.x 官方quickstart测试

文章目录 1.本地环境2.[安装pytorch](https://pytorch.org/get-started/locally/) (Windows GPU版本&#xff09;3. [官方quickstart](https://pytorch.org/tutorials/beginner/basics/quickstart_tutorial.html) 1.本地环境 D:\python2023>nvidia-smi Thu Jul 27 23:27:45…
阅读更多...
数据库字段变更监控平台设计开发

数据库字段变更监控平台设计开发

序&#xff1a; 在开发过程中&#xff0c;在值班解决客服问题时&#xff0c;在分析定位别人写的业务代码问题时&#xff0c;重点是不是自己写的代码&#xff0c;只看到了数据库中落库最终数据&#xff0c;并不知道业务逻辑问题发生时数据库表中当时数据情况&#xff1f;如果能知…
阅读更多...
【开源项目】低代码数据可视化开发平台go-view

【开源项目】低代码数据可视化开发平台go-view

数据可视化开发平台go-view 基本介绍 GoView 是一个Vue3搭建的低代码数据可视化开发平台&#xff0c;将图表或页面元素封装为基础组件&#xff0c;无需编写代码即可完成业务需求。 它的技术栈为&#xff1a;Vue3 TypeScript4 Vite2 NaiveUI ECharts5 Axios Pinia2 Plop…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023