Java 数据结构篇-实现二叉搜索树的核心方法

🔥博客主页： 【小扳_-CSDN博客】
❤感谢大家点赞👍收藏⭐评论✍ 

文章目录

        1.0 二叉搜索树的概述

        2.0 二叉搜索树的成员变量及其构造方法

        3.0 实现二叉树的核心接口

        3.1 实现二叉搜索树 - 获取值 get(int key)

        3.2 实现二叉搜索树 - 获取最小的关键字 min(BinaryNode node)

        3.3 实现二叉搜索树 - 获取最大的关键字 max(BinaryNode node)

        3.4 实现二叉搜索树 - 增、更新 put( int key, Object value)

        3.5 实现二叉搜索树 - 查找关键字的后驱节点 successor(int key)

        3.6 实现二叉搜索树 - 查找关键字的前驱节点 predecessor(int key)

        3.7 实现二叉搜索树 - 删除关键字节点 delete(int key)

        3.8 实现二叉搜索树 - 查找范围小于关键字的节点值 less(int key)

        3.9 实现二叉搜索树 - 查找范围大于关键字的节点值 greater(int key)

        4.0 实现二叉搜索树 - 查找范围大于 k1 且小于 k2 关键字的节点值 between(int k1, int k2)

        5.0 实现二叉搜索树核心方法的完整代码

        1.0 二叉搜索树的概述

        二叉搜索树是一种数据结构，用于存储数据并支持快速的插入、删除和搜索操作。它是一种树形结构。

        它具有以下特点：

                - 每个节点最多有两个子节点，分别称为左子节点和右子节点。

                - 对于每个节点，其左子节点的值小于该节点的值，右子节点的值大于该节点的值。

                - 中序遍历二叉搜索树可以得到有序的元素序列。

        由于其特性，二叉搜索树在插入、删除和搜索操作上具有较高的效率。在平均情况下，这些操作的时间复杂度为 O(log n)，其中 n 为树中节点的数量。然而，如果树的结构不平衡，最坏情况下这些操作的时间复杂度可能会达到 O(n)。由于其高效的搜索特性，二叉搜索树常被用于实现关联数组和集合等数据结构。然而，为了避免树的结构不平衡导致性能下降，人们也发展了平衡二叉搜索树（如红黑树、AVL树）等变种。

        2.0 二叉搜索树的成员变量及其构造方法

        外部类成员变量有：根节点、节点类（内部类）。

        外部类构造方法：默认的构造方法，对外公开二叉搜索树的核心方法。

        节点类的成员变量有：

                - key 关键字：相对比一般的二叉树，二叉搜索树可以明显提高增删查改的效率原因在于关键字，可以根据比较两个关键字的大小进行操作。

                - value 值：作用则为存放值。

                - left ：链接左节点。

                - right：链接右节点。

        节点类的构造方法：

                带两个参数的构造方法：参数为 key 、value 

                带四个参数的构造方法：参数为 key 、value 、left 、right

代码如下：

public class BinaryTree {BinaryNode root = null;static class BinaryNode {int key;Object value;BinaryNode left;BinaryNode right;public BinaryNode(int kty, Object value) {this.key = kty;this.value = value;}public BinaryNode(int key, Object value, BinaryNode left, BinaryNode right) {this.key = key;this.value = value;this.left = left;this.right = right;}}}

        补充二叉搜索树在增、删、查、改的效率高的原因：

        二叉搜索树的高效性与其关键字的特性密切相关。二叉搜索树的关键特性是，对于每个节点，其左子节点的值小于该节点的值，右子节点的值大于该节点的值。这种特性使得在二叉搜索树中进行搜索、插入和删除操作时，可以通过比较关键字的大小来快速定位目标节点，从而实现高效的操作。在平均情况下，这些操作的时间复杂度为 O(log n)，其中 n 为树中节点的数量。因此，关键字的有序性是二叉搜索树能够实现高效操作的关键原因之一。

        3.0 实现二叉树的核心接口

​
public interface BinarySearchTreeInterface {/***查找 key 对应的 value*/Object get(int key);/*** 查找最小关键字对应值*/Object min();/*** 查找最大关键字对应值*/Object max();/*** 存储关键字与对应值*/void put(int key, Object value);/*** 查找关键字的后驱*/Object successor(int key);/*** 查找关键字的前驱*/Object predecessor(int key);/*** 根据关键字删除*/Object delete(int key);
}​

        3.1 实现二叉搜索树 - 获取值 get(int key)

        实现思路为：从根节点开始，先判断当前的节点 p.key 与 key 进行比较，若 p.key > key，则向左子树下潜 p = p.left ；若 p.key < key ，则向右子树下潜 p = p.right ；若 p.key == key ，则找到到了关键字，返回该节点的值 p.value 。按这样的规则一直循环下去，直到 p == null 退出循环，则说明没有找到对应的节点，则返回 null 。

代码如下：

    @Overridepublic Object get(int key) {if (root == null) {return null;}BinaryNode p = root;while(p != null) {if (p.key > key) {p = p.left;}else if (p.key < key) {p = p.right;}else {return p.value;}}return null;}

        若 root 为 null ，则不需要再进行下去了，直接结束。

        3.2 实现二叉搜索树 - 获取最小的关键字 min(BinaryNode node)

        实现思路：在某一个树中，需要得到最小的关键字，由根据数据结构的特点，最小的关键字在数的最左边，简单来说：一直向左子树遍历下去，直到 p.left == null 时，则该 p 节点就是最小的关键字了。然后找到了最小的节点，返回该节点的值即可。

代码如下：

非递归实现：

    @Overridepublic Object min() {if (root == null) {return null;}BinaryNode p = root;while(p.left != null) {p = p.left;}return p.value;}//重载了一个方法，带参数的方法。public Object min(BinaryNode node) {if (node == null) {return null;}BinaryNode p = node;while (p.left != null) {p = p.left;}return p.value;}

递归实现：

    //使用递归实现找最小关键字public Object minRecursion() {return doMin(root);}private Object doMin(BinaryNode node) {if (node == null) {return null;}if (node.left == null) {return node.value;}return doMin(node.left);}

        

        3.3 实现二叉搜索树 - 获取最大的关键字 max(BinaryNode node)

        实现思路为：在某一个树中，需要得到最大的关键字，由根据数据结构的特点，最大的关键字在数的最右边，简单来说：一直向右子树遍历下去，直到 p.right == null 时，则该 p 节点就是最大的关键字了。然后找到了最大的节点，返回该节点的值即可。

代码如下：

非递归实现：

    @Overridepublic Object max() {if (root == null) {return null;}BinaryNode p = root;while(p.right != null) {p = p.right;}return p.value;}//重载了一个带参数的方法public Object max(BinaryNode node) {if (node == null) {return null;}BinaryNode p = node;while (p.right != null) {p = p.right;}return p.value;}

递归实现：

    //使用递归实现找最大关键字public Object maxRecursion() {return doMax(root);}private Object doMax(BinaryNode node) {if (node == null) {return null;}if (node.right == null) {return node.value;}return doMax(node.right);}

        3.4 实现二叉搜索树 - 增、更新 put( int key, Object value)

        实现思路为：在二叉搜索树中先试着查找是否存在与 key 对应的节点 p.key 。若找到了，则为更新该值 p.value = value 即可。若找不到，则需要新增该关键字节点。

        具体来分析如何新增关键字，先定义 BinaryNode parent 、 BinaryNode p，p 指针在去比较 key 之前，先让 parent 指向 p 。最后循环结束后， p == null ，对于 parent 来说，此时正指着 p 节点的双亲节点。 接着创建一个新的节点，BinaryNode newNode = new BinaryNode(key, value) ，则此时还需要考虑的是，该新的节点该连接到 parent 的左孩子还是右孩子 ？需要比较 parent.key 与 newNode.key 的大小即可，若 parent.key > newNode.key，则链接到 parent.left 处；若 prent.key < newNode.key ，则连接到 parent.right 处。

代码如下：

    @Overridepublic void put(int key, Object value) {if (root == null) {root = new BinaryNode(key,value);return;}BinaryNode p = root;BinaryNode parent = null;while (p != null) {parent = p;if (p.key > key) {p = p.left;} else if (p.key < key) {p = p.right;}else {p.value = value;return;}}//该树没有该关键字，因此需要新建节点对象BinaryNode newNode = new BinaryNode(key,value);if (newNode.key < parent.key) {parent.left = newNode;}else {parent.right = newNode;}}

        3.5 实现二叉搜索树 - 查找关键字的后驱节点 successor(int key)

        具体实现思路为：先遍历找到该关键字的节点，若找不到，则返回 null ；若找到了，判断以下的两种情况，第一种情况：该节点有右子树，则该关键字的后驱为右子树的最小关键字；第二种情况：该节点没有右子树，则该关键字的后驱为从右向左而来的祖宗节点。最后返回该后驱节点的值 

代码如下：

    @Overridepublic Object successor(int key) {if (root == null) {return null;}//先找到该关键字节点BinaryNode p = root;BinaryNode sParent = null;while (p != null) {if (p.key > key) {sParent = p;p = p.left;} else if (p.key < key) {p = p.right;}else {break;}}//没有找到关键字的情况if (p == null) {return null;}//情况一:该节点存在右子树,则该后继为右子树的最小关键字if (p.right != null) {return min(p.right);}//情况二:该节点不存在右子树，那么该后继就需要到祖宗从右向左的节点if (sParent == null) {//可能不存在后继节点,比如最大关键字的节点就没有后继节点了return null;}return sParent.value;}

        3.6 实现二叉搜索树 - 查找关键字的前驱节点 predecessor(int key)

        具体实现思路为：先对该二叉树进行遍历寻找 key 的节点，若遍历结束还没找到，则返回 null ；若找到了，需要判断以下两种情况：

        第一种情况：该节点有左子树，则该前驱节点为该左子树的最大关键字节点。

        第二种情况：该节点没有左子树，则该前驱节点为从左向右而来的祖宗节点。

        最后返回该前驱节点的值。

代码如下：

    @Overridepublic Object predecessor(int key) {if (root == null) {return null;}BinaryNode p = root;BinaryNode sParent = null;while (p != null) {if (p.key > key) {p = p.left;} else if (p.key < key) {sParent = p;p = p.right;}else {break;}}if (p == null) {return null;}//情况一:存在左子树，则该前任就为左子树的最大关键字节点if (p.left != null) {return max(p.left);}//情况二:不存在左子树，则该前任为从祖宗自左向右而来的节点if (sParent == null) {return null;}return sParent.value;}

        3.7 实现二叉搜索树 - 删除关键字节点 delete(int key)

        具体实现思路为：先遍历二叉树，查找该关键字节点。若遍历结束了还没有找到，则返回 null ；若找到了，则需要以下四种情况：

        第一种情况：找到该删除的节点只有左子树。则直接让该左子树 "托付" 给删除节点的双亲节点，这就删除了该节点了。至于左子树是链接到双亲节点的左边还有右边这个问题，根据该数据结构的特点，由该删除节点来决定。若删除的节点之前是链接该双亲节点的左边，则左子树也是链接到该双亲节点的左边；若删除的节点之前是链接该双亲节点的右边，则左子树也是链接到该双亲节点的右边。

        第二种情况：找到该删除的节点只有右子树。则直接让该右子树 "托付" 给删除节点的双亲节点，这就删除了该节点了。至于右子树是链接到双亲节点的左边还有右边这个问题，根据该数据结构的特点，由该删除节点来决定。若删除的节点之前是链接该双亲节点的左边，则右子树也是链接到该双亲节点的左边；若删除的节点之前是链接该双亲节点的右边，则右子树也是链接到该双亲节点的右边。

        第三种情况：找到该删除节点都没有左右子树。该情况可以归并到以上两种情况的任意一种处理均可。

        第四种情况：找到该删除节点都有左右子树。分两步：第一步，先找后继节点来替换删除节点，找该后继节点直接到删除节点的右子树中找最小的关键字节点即可。第二步，需要先将后继节点的右子树处理好，需要将该右子树交给替换节点的双亲节点链接。还需要判断两种情况：第一种情况，若删除节点与替换节点是紧挨着的，对替换节点的右子树无需要求，只对左子树重新赋值；若删除节点与替换节点不是紧挨着的关系，对替换节点的左右子树都要重新赋值。

代码如下：

    @Overridepublic Object delete(int key) {if (root == null) {return null;}BinaryNode p = root;BinaryNode parent = null;while (p != null) {if (p.key > key) {parent = p;p = p.left;} else if (p.key < key) {parent = p;p = p.right;}else {break;}}//没有找到该关键字的节点if (p == null) {return null;}//情况一、二、三:只有左子树或者右子树或者都没有if (p.right == null) {shift(parent,p,p.left);} else if (p.left == null) {shift(parent,p,p.right);}else {//情况四:有左右子树//替换节点采用删除节点的后继节点//先看被删的节点与替换的节点是否为紧挨在一起BinaryNode s = p.right;BinaryNode sParent = p;while (s.left != null) {sParent = s;s = s.left;}if (sParent != p) {//说明没有紧挨在一起，则需要将替换节点的右子树进行处理shift(sParent,s,s.right);s.right = p.right;}shift(parent,p,s);s.left = p.left;}return p.value;}private void shift(BinaryNode parent, BinaryNode delete, BinaryNode next) {if (parent == null) {root = next;} else if (parent.left == delete) {parent.left = next;}else if (parent.right == delete){parent.right = next;}}

        为了方便，将删除节点与替换节点之间的替换操作单独成一个方法出来。

        递归实现删除关键字 key 节点，同理，也是细分为以上描述的四种情况。

代码如下：

    //使用递归实现删除关键字节点public BinaryNode deleteRecursion(BinaryNode node , int key) {if (node == null) {return null;}if (node.key > key) {node.left = deleteRecursion(node.left,key);return node;} else if (node.key < key) {node.right = deleteRecursion(node.right,key);return node;}else {if (node.right == null) {return node.left;} else if (node.left == null) {return node.right;}else {BinaryNode s = node.right;while (s.left != null) {s = s.left;}s.right = deleteRecursion(node.right,s.key);s.left = node.left;return s;}}}

        3.8 实现二叉搜索树 - 查找范围小于关键字的节点值 less(int key)

        具体实现思路为：利用中序遍历，来遍历每一个节点的 key ，若小于 key 的节点，直接放到数组容器中；若大于 key 的，可以直接退出循环。最后返回该数组容器即可。

代码如下：

    //找 < key 的所有 valuepublic List<Object> less(int key) {if (root == null) {return null;}ArrayList<Object> result = new ArrayList<>();BinaryNode p = root;Stack<BinaryNode> stack = new Stack<>();while (p != null || !stack.isEmpty()) {if (p != null) {stack.push(p);p = p.left;}else {BinaryNode pop = stack.pop();if (pop.key < key) {result.add(pop.value);}else {break;}p = pop.right;}}return result;}

        3.9 实现二叉搜索树 - 查找范围大于关键字的节点值 greater(int key)

        具体实现思路：利用中序遍历，来遍历每一个节点的 key ，若大于 key 的节点，直接放到数组容器中。

代码如下：

    //找 > key 的所有 valuepublic List<Object> greater(int key) {if (root == null) {return null;}ArrayList<Object> result = new ArrayList<>();Stack<BinaryNode> stack = new Stack<>();BinaryNode p = root;while (p != null || !stack.isEmpty()) {if (p != null) {stack.push(p);p = p.left;}else {BinaryNode pop = stack.pop();if (pop.key > key) {result.add(pop.value);}p = pop.right;}}return result;}

该方法的改进：遍历方向进行调整，先从右子树开始，再访问根节点，最后才到左子树。因此只要小于 key 的关键字节点，直接退出循环。

代码如下：

    //改进思路:遍历方向进行调整，先从右子树开始，再访问根节点，最后才到左子树public List<Object> greater1(int key) {if (root == null) {return null;}ArrayList<Object> result = new ArrayList<>();Stack<BinaryNode> stack = new Stack<>();BinaryNode p = root;while (p != null || !stack.isEmpty()) {if (p != null ) {stack.push(p);p = p.right;}else {BinaryNode pop = stack.pop();if (pop.key > key) {result.add(pop.value);}else {break;}p = pop.left;}}return result;}

        4.0 实现二叉搜索树 - 查找范围大于 k1 且小于 k2 关键字的节点值 between(int k1, int k2)

        实现思路跟以上的思路没有什么区别，唯一需要注意的是，当前节点的 key > k2 则可以退出循环了。

代码如下：

//找到 >= k1 且 =< k2 的所有valuepublic List<Object> between(int k1, int k2) {if (root == null) {return null;}ArrayList<Object> result = new ArrayList<>();Stack<BinaryNode> stack = new Stack<>();BinaryNode p = root;while(p != null || !stack.isEmpty()) {if (p != null) {stack.push(p);p = p.left;}else {BinaryNode pop = stack.pop();if (pop.key >= k1 && pop.key <= k2) {result.add(pop.value);} else if (pop.key > k2) {break;}p = pop.right;}}return result;}

        5.0 实现二叉搜索树核心方法的完整代码

实现接口代码：

import java.util.ArrayList;import java.util.List;
import java.util.Stack;public class BinaryTree implements BinarySearchTreeInterface{BinaryNode root = null;static class BinaryNode {int key;Object value;BinaryNode left;BinaryNode right;public BinaryNode(int kty, Object value) {this.key = kty;this.value = value;}public BinaryNode(int key, Object value, BinaryNode left, BinaryNode right) {this.key = key;this.value = value;this.left = left;this.right = right;}}@Overridepublic Object get(int key) {if (root == null) {return null;}BinaryNode p = root;while(p != null) {if (p.key > key) {p = p.left;}else if (p.key < key) {p = p.right;}else {return p.value;}}return null;}@Overridepublic Object min() {if (root == null) {return null;}BinaryNode p = root;while(p.left != null) {p = p.left;}return p.value;}public Object min(BinaryNode node) {if (node == null) {return null;}BinaryNode p = node;while (p.left != null) {p = p.left;}return p.value;}//使用递归实现找最小关键字public Object minRecursion() {return doMin(root);}private Object doMin(BinaryNode node) {if (node == null) {return null;}if (node.left == null) {return node.value;}return doMin(node.left);}@Overridepublic Object max() {if (root == null) {return null;}BinaryNode p = root;while(p.right != null) {p = p.right;}return p.value;}public Object max(BinaryNode node) {if (node == null) {return null;}BinaryNode p = node;while (p.right != null) {p = p.right;}return p.value;}//使用递归实现找最大关键字public Object maxRecursion() {return doMax(root);}private Object doMax(BinaryNode node) {if (node == null) {return null;}if (node.right == null) {return node.value;}return doMax(node.right);}@Overridepublic void put(int key, Object value) {if (root == null) {root = new BinaryNode(key,value);return;}BinaryNode p = root;BinaryNode parent = null;while (p != null) {parent = p;if (p.key > key) {p = p.left;} else if (p.key < key) {p = p.right;}else {p.value = value;return;}}//该树没有该关键字，因此需要新建节点对象BinaryNode newNode = new BinaryNode(key,value);if (newNode.key < parent.key) {parent.left = newNode;}else {parent.right = newNode;}}@Overridepublic Object successor(int key) {if (root == null) {return null;}//先找到该关键字节点BinaryNode p = root;BinaryNode sParent = null;while (p != null) {if (p.key > key) {sParent = p;p = p.left;} else if (p.key < key) {p = p.right;}else {break;}}//没有找到关键字的情况if (p == null) {return null;}//情况一:该节点存在右子树,则该后继为右子树的最小关键字if (p.right != null) {return min(p.right);}//情况二:该节点不存在右子树，那么该后继就需要到祖宗从右向左的节点if (sParent == null) {//可能不存在后继节点,比如最大关键字的节点就没有后继节点了return null;}return sParent.value;}@Overridepublic Object predecessor(int key) {if (root == null) {return null;}BinaryNode p = root;BinaryNode sParent = null;while (p != null) {if (p.key > key) {p = p.left;} else if (p.key < key) {sParent = p;p = p.right;}else {break;}}if (p == null) {return null;}//情况一:存在左子树，则该前任就为左子树的最大关键字节点if (p.left != null) {return max(p.left);}//情况二:不存在左子树，则该前任为从祖宗自左向右而来的节点if (sParent == null) {return null;}return sParent.value;}@Overridepublic Object delete(int key) {if (root == null) {return null;}BinaryNode p = root;BinaryNode parent = null;while (p != null) {if (p.key > key) {parent = p;p = p.left;} else if (p.key < key) {parent = p;p = p.right;}else {break;}}//没有找到该关键字的节点if (p == null) {return null;}//情况一、二、三:只有左子树或者右子树或者都没有if (p.right == null) {shift(parent,p,p.left);} else if (p.left == null) {shift(parent,p,p.right);}else {//情况四:有左右子树//替换节点采用删除节点的后继节点//先看被删的节点与替换的节点是否为紧挨在一起BinaryNode s = p.right;BinaryNode sParent = p;while (s.left != null) {sParent = s;s = s.left;}if (sParent != p) {//说明没有紧挨在一起，则需要将替换节点的右子树进行处理shift(sParent,s,s.right);s.right = p.right;}shift(parent,p,s);s.left = p.left;}return p.value;}private void shift(BinaryNode parent, BinaryNode delete, BinaryNode next) {if (parent == null) {root = next;} else if (parent.left == delete) {parent.left = next;}else if (parent.right == delete){parent.right = next;}}//使用递归实现删除关键字节点public BinaryNode deleteRecursion(BinaryNode node , int key) {if (node == null) {return null;}if (node.key > key) {node.left = deleteRecursion(node.left,key);return node;} else if (node.key < key) {node.right = deleteRecursion(node.right,key);return node;}else {if (node.right == null) {return node.left;} else if (node.left == null) {return node.right;}else {BinaryNode s = node.right;while (s.left != null) {s = s.left;}s.right = deleteRecursion(node.right,s.key);s.left = node.left;return s;}}}//找 < key 的所有 valuepublic List<Object> less(int key) {if (root == null) {return null;}ArrayList<Object> result = new ArrayList<>();BinaryNode p = root;Stack<BinaryNode> stack = new Stack<>();while (p != null || !stack.isEmpty()) {if (p != null) {stack.push(p);p = p.left;}else {BinaryNode pop = stack.pop();if (pop.key < key) {result.add(pop.value);}else {break;}p = pop.right;}}return result;}//找 > key 的所有 valuepublic List<Object> greater(int key) {if (root == null) {return null;}ArrayList<Object> result = new ArrayList<>();Stack<BinaryNode> stack = new Stack<>();BinaryNode p = root;while (p != null || !stack.isEmpty()) {if (p != null) {stack.push(p);p = p.left;}else {BinaryNode pop = stack.pop();if (pop.key > key) {result.add(pop.value);}p = pop.right;}}return result;}//改进思路:遍历方向进行调整，先从右子树开始，再访问根节点，最后才到左子树public List<Object> greater1(int key) {if (root == null) {return null;}ArrayList<Object> result = new ArrayList<>();Stack<BinaryNode> stack = new Stack<>();BinaryNode p = root;while (p != null || !stack.isEmpty()) {if (p != null ) {stack.push(p);p = p.right;}else {BinaryNode pop = stack.pop();if (pop.key > key) {result.add(pop.value);}else {break;}p = pop.left;}}return result;}//找到 >= k1 且 =< k2 的所有valuepublic List<Object> between(int k1, int k2) {if (root == null) {return null;}ArrayList<Object> result = new ArrayList<>();Stack<BinaryNode> stack = new Stack<>();BinaryNode p = root;while(p != null || !stack.isEmpty()) {if (p != null) {stack.push(p);p = p.left;}else {BinaryNode pop = stack.pop();if (pop.key >= k1 && pop.key <= k2) {result.add(pop.value);} else if (pop.key > k2) {break;}p = pop.right;}}return result;}}

 

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

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

相关文章

程序流程图的意义（合集）

程序流程图的意义（合集）

程序流程图的意义 1、矩形 作用&#xff1a;一般用作要执行的处理(process)&#xff0c;在程序流程图中做执行框。 在axure中如果是画页面框架图&#xff0c;那么也可以指代一个页面。有时候我们会把页面和执行命令放在同一个流程中做说明&#xff0c;这个时候将两类不同的矩形…
阅读更多...
算法(2)——滑动窗口

算法(2)——滑动窗口

前言&#xff1a; 步骤及算法模板&#xff1a; 确定两个指针变量&#xff0c;left0,right0; 进窗口&#xff1a; 判断&#xff1a; 出窗口 更新结果 接下来我们的所用滑动窗口解决问题都需要以上几个步骤。 一、长度最小的子数组 209. 长度最小的子数组 - 力扣&#xff08;L…
阅读更多...
Ebullient第一阶段开发小结

Ebullient第一阶段开发小结

一. 简介 距离Ebullient硬件发布已有一段时间&#xff0c;小一个月吧&#xff0c;在这段时间内在努力的编写代码&#xff0c;现在终于完成了第一阶段的功能设计&#xff0c;算是一个小型的样机吧&#xff0c;基本的代码框架基本确定了&#xff0c;相信后续的会快一点(希望如此…
阅读更多...
Nodejs 第二十六章（反向代理）

Nodejs 第二十六章（反向代理）

什么是反向代理? 反向代理&#xff08;Reverse Proxy&#xff09;是一种网络通信模式&#xff0c;它充当服务器和客户端之间的中介&#xff0c;将客户端的请求转发到一个或多个后端服务器&#xff0c;并将后端服务器的响应返回给客户端。 负载均衡&#xff1a;反向代理可以根…
阅读更多...
二、W5100S/W5500+RP2040之MicroPython开发＜DHCP示例＞

二、W5100S/W5500+RP2040之MicroPython开发＜DHCP示例＞

文章目录 1 前言2 相关网络信息2 .1 简介2.2 DHCP工作原理2.3 DHCP的优点2.4 应用场景 3 WIZnet以太网芯片4 DHCP网络设置示例概述以及使用4.1 流程图4.2 准备工作核心4.3 连接方式4.4 主要代码概述4.5 结果演示 5 注意事项6 相关链接 1 前言 在这个智能硬件和物联网时代&#…
阅读更多...
在Python中使用Kafka帮助我们处理数据

在Python中使用Kafka帮助我们处理数据

Kafka是一个分布式的流数据平台&#xff0c;它可以快速地处理大量的实时数据。Python是一种广泛使用的编程语言&#xff0c;它具有易学易用、高效、灵活等特点。在Python中使用Kafka可以帮助我们更好地处理大量的数据。本文将介绍如何在Python中使用Kafka简单案例。 一、安装K…
阅读更多...
C到C++笔记记录

C到C++笔记记录

C到C笔记记录 输入(cin) and 输出(cout)bool内联(inline)重载缺省函数哑元引用(&)C动态内存分配笔记扩充&#xff1a; 输入(cin) and 输出(cout) #include<iostream>using namespace std;void main() {int i;//输入 cincin >> i;//输出 coutcout << i &…
阅读更多...
浅谈云性能测试的关键要点

浅谈云性能测试的关键要点

随着云计算的广泛应用&#xff0c;云性能测试成为确保云服务质量和性能的关键环节。云性能测试不仅涵盖了传统性能测试的方面&#xff0c;还需要考虑云环境的特殊性。以下是云性能测试的几个关键要点&#xff1a; 1. 模拟真实云环境 云环境具有虚拟化、弹性扩展等特点&#xff…
阅读更多...
IDEA tomcat内存不足

IDEA tomcat内存不足

-Xms256m -Xmx256m -XX:MaxNewSize256m -XX:MaxPermSize256m
阅读更多...
API资源对象StorageClass；Ceph存储；搭建Ceph集群；k8s使用ceph

API资源对象StorageClass；Ceph存储；搭建Ceph集群；k8s使用ceph

API资源对象StorageClass;Ceph存储;搭建Ceph集群;k8s使用ceph API资源对象StorageClass SC的主要作用在于&#xff0c;自动创建PV&#xff0c;从而实现PVC按需自动绑定PV。 下面我们通过创建一个基于NFS的SC来演示SC的作用。 要想使用NFS的SC&#xff0c;还需要安装一个NFS…
阅读更多...
Kubernetes 的用法和解析 -- 5

Kubernetes 的用法和解析 -- 5

一.企业级镜像仓库Harbo 准备&#xff1a;另起一台新服务器&#xff0c;并配置docker yum源&#xff0c;安装docker 和 docker-compose 1.1 上传harbor安装包并安装 [rootharbor ~]# tar xf harbor-offline-installer-v2.5.3.tgz [rootharbor ~]# cp harbor.yml.tmpl harbor…
阅读更多...
不会代码循环断言如何实现？只要6步！

不会代码循环断言如何实现？只要6步！

对于使用jmeter工具完成接口测试的测试工程师而言。在工作中&#xff0c;或者在面试中&#xff0c;都会遇到一个问题—— “CSV文档做了一大笔测试数据后&#xff0c;怎么去校验这个结果呢&#xff1f;” 现在大部分测试工程师可能都是通过人工的方法去查看结果&#xff0c;十…
阅读更多...
作业--day33

作业--day33

基于UDP的TFTP文件上传 #include <myhead.h>#define PORT 69 #define IP "192.168.125.59"int down(const char *); int up(const char *);int main(int argc, const char *argv[]) {while(1){system("clear");//打印菜单puts("**************…
阅读更多...
STM32F407-14.3.12-01使用断路功能

STM32F407-14.3.12-01使用断路功能

使用断路功能 使用断路功能时&#xff0c;根据其它控制位&#xff08;TIMx_BDTR 寄存器中的 MOE⑨、OSSI⑪ 和 OSSR⑩ 位以及 TIMx_CR2 寄存器中的 OISx⑰ 和 OISxN⑱ 位&#xff09;修改输出使能信号和无效电平。任何情况下&#xff0c;OCx③ 和 OCxN④ 输出都不能同时置为有效…
阅读更多...
LD2450-24G人体移动跟踪轨迹雷达模块

LD2450-24G人体移动跟踪轨迹雷达模块

文章目录 前言一、LD2450简介特点引脚定义 二、使用步骤上位机使用方法通信协议协议格式数据输出协议 雷达命令配置方式串口解析示例 前言 运动目标跟踪是指在区域内实时跟踪运动目标所在的位置&#xff0c;实现对区域内运动目标测距、测角和测速。LD2450是海凌科24G毫米波雷达…
阅读更多...
基于paddlepaddle的FPS最远点采样

基于paddlepaddle的FPS最远点采样

什么是FPS最远点采样&#xff1f; 最远点采样&#xff08;Farthest Point Sampling&#xff0c;FPS&#xff09;是一种常用的采样算法&#xff0c;主要用于点云数据&#xff08;如激光雷达点云数据、分子坐标等&#xff09;的采样。 为了方便解释&#xff0c;定义一下待采样点…
阅读更多...
深入解析线程安全的Hashtable实现

深入解析线程安全的Hashtable实现

目录 引言 1. Hashtable简介 2. Hashtable线程安全实现原理 2.1. 锁机制 2.2. 分段锁 2.3. CAS操作 3. 线程安全策略 3.1. 同步方法 3.2. 分段锁优化 3.3. 乐观锁和CAS 4. 性能优化 4.1. 负载均衡 4.2. 惰性加载 5. 注意事项 5.1. 死锁和性能问题 5.2. 内存开销…
阅读更多...
嵌入式软件测试（黑盒测试）---三年嵌入式软件测试的理解

嵌入式软件测试（黑盒测试）---三年嵌入式软件测试的理解

文章内容为本人这三年来在嵌入式软件测试&#xff08;黑盒&#xff09;上的一些积累吧&#xff0c;说起来也挺快的&#xff0c;毕业三年的时间就这样过去了&#xff0c;在两家公司工作过&#xff08;现在这家是第二家&#xff09;&#xff0c;这几年的测试项目基本都是围绕着嵌…
阅读更多...
第十三章 枚举类型和泛型

第十三章 枚举类型和泛型

枚举类型可以取代以往的常用的定义方式&#xff0c;即将常量封装在类或者接口中&#xff0c;此外它还提供了安全检查功能。枚举类型本质上还剋以类的形式存在。泛型的出现不仅可以让程序员少写一些代码&#xff0c;更重要的是它可以解决类型安全问题。泛型提供了编译时的安全检…
阅读更多...
redolog有什么用，是怎么工作的

redolog有什么用，是怎么工作的

redolog其实就是想干一件事&#xff1a;当一个事务commit了&#xff0c;那肯定是在内存中改了&#xff0c;但是在磁盘里未必。可能刚提交事务就宕机了&#xff0c;还没来得及写磁盘&#xff08;并且也不会立刻写的&#xff0c;会隔一段时间才刷&#xff09;。redolog就是要保证…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023