二叉搜索树的基础操作

如果对于二叉搜索树不是太清楚，为什么要使用二叉搜索树？作者推荐：二叉搜索树的初步认识_加瓦不加班的博客-CSDN博客

定义节点

static class BSTNode {int key; // 若希望任意类型作为 key, 则后续可以将其设计为 Comparable 接口Object value;BSTNode left;BSTNode right;public BSTNode(int key) {this.key = key;this.value = key;}public BSTNode(int key, Object value) {this.key = key;this.value = value;}public BSTNode(int key, Object value, BSTNode left, BSTNode right) {this.key = key;this.value = value;this.left = left;this.right = right;}
}

查询

参照图：

递归实现

//解题思路：从根节点出发 比根节点大的向右找 比根节点小的向左找  如果相等则返回
public Object get(int key) {return doGet(root, key);
}
//查询方法：递归实现
private Object doGet(BSTNode node, int key) {if (node == null) {return null; // 没找到}if (key < node.key) {return doGet(node.left, key); // 向左找} else if (node.key < key) {return doGet(node.right, key); // 向右找} else {return node.value; // 找到了}
}

非递归实现

public Object get(int key) {BSTNode node = root;while (node != null) {if (key < node.key) {node = node.left;} else if (node.key < key) {node = node.right;} else {return node.value;}}return null;
}

Comparable

随便给个泛型T就能参与大小比较吗？不能,所以我们要对T进行限制，让它能够参与大小比较，那么就需要实现一个接口： Comparable 接口

如果希望让除 int 外更多的类型能够作为 key，一种方式是 key 必须实现 Comparable 接口。

代码实现：

//<T extends Comparable<T>>:将来我的泛型T就有个上限了，必须是Comparable的子类型，那么T就再也不是任意类型
public class BSTTree2<T extends Comparable<T>> {static class BSTNode<T> {T key; // 若希望任意类型作为 key, 则后续可以将其设计为 Comparable 接口Object value;BSTNode<T> left;BSTNode<T> right;public BSTNode(T key) {this.key = key;this.value = key;}public BSTNode(T key, Object value) {this.key = key;this.value = value;}public BSTNode(T key, Object value, BSTNode<T> left, BSTNode<T> right) {this.key = key;this.value = value;this.left = left;this.right = right;}}//定义根节点BSTNode<T> root;public Object get(T key) {return doGet(root, key);}//注意：key.compareTo(p.key)的方法比较//-1： key p.key//0： key =p.key//1： key p.key//递归的实现private Object doGet(BSTNode<T> node, T key) {if (node == null) {return null;}int result = node.key.compareTo(key);if (result > 0) {return doGet(node.left, key);} else if (result < 0) {return doGet(node.right, key);} else {return node.value;}}//非递归的实现//注意：key.compareTo(p.key)的方法比较//-1： key p.key//0： key =p.key//1： key p.key//非递归的实现public Object get(T key){BSTNode<T> p=root;while (p!=null){int result = key.compareTo(p.key);if(result<0){p=p.left;}else if(result>0){p=p.right;}else {return p.value;}}return null;}}

还有一种做法不要求 key 实现 Comparable 接口，而是在构造 Tree 时把比较规则作为 Comparator 传入，将来比较 key 大小时都调用此 Comparator 进行比较，这种做法可以参考 Java 中的 java.util.TreeMap

当然我们也可以实现像Map一样的格式，给value也加个泛型，然后我们将key的泛型修改一下名字，就更像Map<K,V>:

public class BSTTree2<K extends Comparable<K>, V> {
static class BSTNode<K, V> {K key;V value;BSTNode<K, V> left;BSTNode<K, V> right;public BSTNode(K key) {this.key = key;}public BSTNode(K key, V value) {this.key = key;this.value = value;}public BSTNode(K key, V value, BSTNode<K, V> left, BSTNode<K, V> right) {this.key = key;this.value = value;this.left = left;this.right = right;}
}BSTNode<K, V> root;public V get(K key) {BSTNode<K, V> p = root;while (p != null) {/*-1 key < p.key0 key == p.key1 key > p.key*/int result = key.compareTo(p.key);if (result < 0) {p = p.left;} else if (result > 0) {p = p.right;} else {return p.value;}}return null;}
}

但是后面，我们为了更加使得我们小白能够更好理解代码，我们还是以int key,object value来实现后续的代码。

查询最小值

参照图：

递归实现

思路：从根节点开始，一直往左走，一直走到最后的节点没有左孩子就停止

//思路：从根节点开始，一直往左走，一直走到最后的节点没有左孩子就停止
public Object min() {return doMin(root);
}public Object doMin(BSTNode node) {if (node == null) {//当给的节点为Null 我们就不需要去找return null;}// 左边已走到头if (node.left == null) { //最小的节点return node.value;}return doMin(node.left);
}

非递归实现

public Object min() {if (root == null) {return null;}BSTNode p = root;// 左边未走到头while (p.left != null) {p = p.left;}return p.value;
}

查询最大值

参考：其实现方法与《最小》的操作基本上是一样的

递归实现

public Object max() {return doMax(root);
}public Object doMax(BSTNode node) {if (node == null) {return null;}// 右边已走到头if (node.left == null) { return node.value;}return doMin(node.right);
}

非递归实现

public Object max() {if (root == null) {return null;}BSTNode p = root;// 右边未走到头while (p.right != null) {p = p.right;}return p.value;
}

新增操作

参考图：

解题思路：

//1.key在该二叉树中有 那就更新key所对应的value值
//2.key在该二叉树中没有 那就新增key与所对应的value值

新增前：

新增后：

图示解析：以上述图为例，新增前，从根节点开始找，找到8时，9大于8，那么就要要继续向右找，但是此时前进不了了，因为8已经是叶子节点，走到头还没有找到9，那么就新增9连通值一起创建出来，做为8的右孩子新增进去。

递归实现

public void put(int key, Object value) {root = doPut(root, key, value);
}private BSTNode doPut(BSTNode node, int key, Object value) {if (node == null) {return new BSTNode(key, value);}if (key < node.key) {node.left = doPut(node.left, key, value);} else if (node.key < key) {node.right = doPut(node.right, key, value);} else {node.value = value;}return node;
}

  • 若找到 key，走 else 更新找到节点的值

  • 若没找到 key，走第一个 if，创建并返回新节点

    • 返回的新节点，作为上次递归时 node 的左孩子或右孩子

    • 缺点是，会有很多不必要的赋值操作

非递归实现

public void put(int key, Object value) {BSTNode node = root;BSTNode parent = null;while (node != null) {parent = node;// 4 7 8if (key < node.key) {node = node.left;} else if (node.key < key) {node = node.right;//4->7 7->8 8->null} else {// 1. key 存在则更新node.value = value;return;}}// 2. key 不存在则新增if (parent == null) {//当我二叉树是null，那么parent初始就是Null 那么新增的key就是根节点root = new BSTNode(key, value);} else if (key < parent.key) {parent.left = new BSTNode(key, value);} else {parent.right = new BSTNode(key, value);}
}

查询节点的前驱后继

什么叫屈曲与后继？

答：

一个节点的前驱（前任）节点是指比它小的节点中，最大的那个

一个节点的后继（后任）节点是指比它大的节点中，最小的那个

1 2 3 4 5 6 7 8

例如上图中

  • 1 没有前驱，后继是 2

  • 2 前驱是 1，后继是 3

  • 3 前驱是 2，后继是 4

  • ...

查询节点前驱

简单的办法是中序遍历，即可获得排序结果，此时很容易找到前驱后继

二叉树的中序遍历就是升序的结果

要效率更高，需要研究一下规律，找前驱分成 2 种情况：

  1. 节点有左子树，此时前驱节点就是左子树中的最大值， 图中属于这种情况的有

    • 2 的前驱是1

    • 4 的前驱是 3

    • 6 的前驱是 5

    • 7 的前驱是 6

    个人理解：比如:(4的前驱节点有 1 2 3，其中最大值就是3)

  2. 节点没有左子树，若离它最近的祖先自从左而来，此祖先即为前驱，如

    • 3 的祖先 2 自左而来，前驱 2

    • 5 的祖先 4 自左而来，前驱 4

    • 8 的祖先 7 自左而来，前驱 7

    • 1 没有这样的祖先，前驱 null

个人理解：比如:(5的祖先节点有 6 7 4，其中以5为参考点，右边6和7都是比5大的，左边4是比5小的，从左而来的祖先4即为前驱)

比如:(3的祖先节点有 2 4，其中以3为参考点，右边4是比3大的，左边2是比3小的，从左而来的祖先2即为前驱)

// 情况2 - 有祖先自左而来
//对于情况2，我们如何知道哪些节点是要找节点的祖先，又是如何知道这些祖先节点哪些是自从左而来的呢？
//以5节点为例，那我要找到5这个节点的过程中，它必然已经经历过一些节点了，从根节点4开始找，5比4大就向右找，7比5大就向左找，6比5大就像左找，找到了


//在从根节点开始4 7 6是不是都是5的祖先？是的  其实循环的每步都是在经历他这些祖先节点，好，现在知道怎么去获取祖先节点。


//那我们怎么去进一步判断 它这个祖先是左边来还是从右边来呢？
//答：你看4到7是不是向右走，那么以5为参考点，那么4是不是在左边？那么7到6、6到5都是向左走，但是以5为参考点，那么7到6、6到5都是向右走
//所以只要我们看到这种向右走的代码if (p.key < key) {p = p.right;}那就表示祖先是自左而来
//而且我们每次循环更新都是最新也就是最近的自左而来的祖先节点

在predecessor方法之前，我们对于Max方法进行简单的修改，因为我们上面写的Max方法仅仅只是针对于root根节点来查询最大：

   //非递归实现  针对于root的max方法public Object max() {return   max(root);
//        if (root == null) {
//            return null;
//        }
//        BSTNode p = root;
//        // 右边未走到头
//        while (p.right != null) {
//            p = p.right;
//        }
//        return p.value;}//通用的Max方法private Object max(BSTNode node){if (node == null) {return null;}BSTNode p = node;// 右边未走到头while (p.right != null) {p = p.right;}return p.value;}

然后我们就开始书写查询节点的前驱代码：

public Object predecessor(int key) {BSTNode ancestorFromLeft = null;BSTNode p = root;//查找用户给的Key在二叉树中是否有while (p != null) {if (key < p.key) {p = p.left;} else if (p.key < key) {ancestorFromLeft = p;p = p.right;} else {break;}}//key没找到，说明也就没有前任节点if (p == null) {return null;}// 情况1 - 有左孩子if (p.left != null) {return max(p.left);}// 情况2 - 有祖先自左而来//对于情况2，我们如何知道哪些节点是要找节点的祖先，又是如何知道这些祖先节点哪些是自从左而来的呢？//以5节点为例，那我要找到5这个节点的过程中，它必然已经经历过一些节点了，从根节点4开始找，5比4大就向右找，7比5大就向左找，6比5大就像左找，找到了//在从根节点开始4 7 6是不是都是5的祖先？是的  其实循环的每步都是在经历他这些祖先节点，好，现在知道怎么去获取祖先节点。//那我们怎么去进一步判断 它这个祖先是左边来还是从右边来呢？//答：你看4到7是不是向右走，那么以5为参考点，那么4是不是在左边？那么7到6、6到5都是向左走，但是以5为参考点，那么7到6、6到5都是向右走//所以只要我们看到这种向右走的代码if (p.key < key) {p = p.right;}那就表示祖先是自左而来//而且我们每次循环更新都是最新也就是最近的自左而来的祖先节点return ancestorFromLeft != null ? ancestorFromLeft.value : null;
}

查询节点后继

找后继也分成 2 种情况 与找前任的代码相类似

  1. 节点有右子树，此时后继节点即为右子树的最小值，如

    • 2 的后继 3

    • 3 的后继 4

    • 5 的后继 6

    • 7 的后继 8

  2. 节点没有右子树，若离它最近的祖先自从右而来，此祖先即为后继，如

    • 1 的祖先 2 自右而来，后继 2

    • 4 的祖先 5 自右而来，后继 5

    • 6 的祖先 7 自右而来，后继 7

    • 8 没有这样的祖先，后继 null

在successor方法之前，我们对于Min方法进行简单的修改，因为我们上面写的Min方法仅仅只是针对于root根节点来查询最小：

    //非递归实现public Object min() {return min(root);
//        if (root == null) {
//            return null;
//        }
//        BSTNode p = root;
//        // 左边未走到头
//        while (p.left != null) {
//            p = p.left;
//        }
//        return p.value;}private Object min(BSTNode node){if (node == null) {return null;}BSTNode p = node;// 左边未走到头while (p.left != null) {p = p.left;}return p.value;}

然后我们就开始书写查询节点的后继代码：

public Object successor(int key) {BSTNode ancestorFromRight = null;BSTNode p = root;while (p != null) {if (key < p.key) {ancestorFromRight = p;p = p.left;} else if (p.key < key) {p = p.right;} else {break;}}if (p == null) {return null;}// 情况1 - 有右孩子if (p.right != null) {return min(p.right);}// 情况2 - 有祖先自右而来return ancestorFromRight != null ? ancestorFromRight.value : null;
}

删除操作

要删除某节点（称为 D），必须先找到被删除节点的父节点，这里称为 Parent

1.删除节点没有左孩子，将右孩子托孤给 Parent

2.删除节点没有右孩子，将左孩子托孤给 Parent

3.删除节点左右孩子都没有，已经被涵盖在情况1、情况2当中，把null托孤给Parent

4.删除节点左右孩子都有，可以将它的后继节点（称为S)托孤给Parent,设S的父亲为SP,又分两种情况:

               1.SP 就是被删除节点，此时 D 与 S 紧邻，只需将 S 托孤给 Parent

               2.SP 不是被删除节点，此时 D 与 S 不相邻，此时需要将 S 的后代托孤给 SP，再将 S 托孤给 Parent

非递归实现

/*** <h3>根据关键字删除</h3>** @param key 关键字* @return 被删除关键字对应值*/
public Object delete(int key) {BSTNode p = root;BSTNode parent = null;//记录待删除节点的父亲while (p != null) {if (key < p.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.left == null) {shift(parent, p, p.right); // 情况1} else if (p.right == null) {shift(parent, p, p.left); // 情况2} else {// 情况4：被删除节点是左、右都有子节点，所以找后继节点：节点有右子树，此时后继节点即为右于树的最小值// 4.1 被删除节点找后继BSTNode s = p.right;//后继节点BSTNode sParent = p; // 后继父亲while (s.left != null) {  //当循环结束，后继节点即为ssParent = s;s = s.left;}// 4.2 删除和后继不相邻, 处理后继的后事if (sParent != p) {                shift(sParent, s, s.right); // 不可能有左孩子：因为节点有右子树，此时后继节点即为右于树的最小值s.right = p.right;//顶上去的后继节点的右孩子==被删除节点的右孩子}// 4.3 后继取代被删除节点shift(parent, p, s);s.left = p.left;//shift方法只改变了父类节点的左右孩子的指向，而没有改变你后继节点的做左右孩子的指向}return p.value;
}/*** 托孤方法** @param parent  被删除节点的父亲* @param deleted 被删除节点* @param child   被顶上去的节点*/
// 只考虑让 n1父亲的左或右孩子指向 n2, n1自己的左或右孩子并未在方法内改变
private void shift(BSTNode parent, BSTNode deleted, BSTNode child) {//情况讨论：当被删除节点就是根节点，而根节点是没有父亲的if (parent == null) {root = child;//你们被删除节点的子节点就成根节点} else if (deleted == parent.left) {parent.left = child;} else {parent.right = child;}
}

递归实现

  /*** <h3>根据关键字删除</h3>** @param key 关键字* @return 被删除关键字对应值  是删除单个节点，当该节点被删除，则它的子节点将会与该节点的父类节点进行连接*/public Object remove(int key) {ArrayList<Object> result = new ArrayList<>(); // 保存被删除节点的值root = doRemove(root, key, result);return result.isEmpty() ? null : result.get(0);}/*4/ \2   6/     \1       7node 起点返回值 删剩下的孩子(找到) 或 null(没找到)*///递归实现删除操作  BSTNode node:我要删除时，从哪个节点开始删除  node是起点private BSTNode doRemove(BSTNode node, int key, ArrayList<Object> result) {//1.没有找到的情况：if (node == null) {return null;}//2.找到的情况：if (key < node.key) {//向左查找node.left = doRemove(node.left, key, result);return node;}if (node.key < key) {//向右查找node.right = doRemove(node.right, key, result);return node;}result.add(node.value);if (node.left == null) { // 情况1 - 只有右孩子return node.right;}if (node.right == null) { // 情况2 - 只有左孩子return node.left;}//s：后继节点BSTNode s = node.right; // 情况3 - 有两个孩子while (s.left != null) {s = s.left;}//while循环结束以后，找到了后继节点s.right = doRemove(node.right, s.key, new ArrayList<>());s.left = node.left;return s;}

对于第四种情况进行代码解析：

当D与S紧邻：

当D与S不是紧邻：

对于remove方法的解析：

说明

  1. ArrayList<Object> result 用来保存被删除节点的值

  2. 第二、第三个 if 对应没找到的情况，继续递归查找和删除，注意后续的 doDelete 返回值代表删剩下的，因此需要更新

  3. 最后一个 return 对应删除节点只有一个孩子的情况，返回那个不为空的孩子，待删节点自己因没有返回而被删除

  4. 第四个 if 对应删除节点有两个孩子的情况，此时需要找到后继节点，并在待删除节点的右子树中删掉后继节点，最后用后继节点替代掉待删除节点返回，别忘了改变后继节点的左右指针

范围查询

下面三种题型的核心解题思路：

我们利用中序遍历的特性：遍历出来的都是升序的结果来进行范围查询

找小的

    /*4/   \2     6/ \   / \1   3 5   7*/
//找 > key 的所有 value
//解题思路：我们利用中序遍历的特性：遍历出来的都是升序的结果
public List<Object> less(int key) { //当我们输入的是6//result：将符合条件的加入到result中ArrayList<Object> result = new ArrayList<>();//中序遍历过程：BSTNode p = root;LinkedList<BSTNode> stack = new LinkedList<>();while (p != null || !stack.isEmpty()) {if (p != null) {stack.push(p);p = p.left;} else {BSTNode pop = stack.pop();if (pop.key < key) {result.add(pop.value);} else {//当我们遇到比key大的分支时，该分支的子分支就没必要多此一举的进行判断，直接跳出//比如：当key=6，那么我们6右节点就不需要多此一举的去判断，而是直接跳出break;}p = pop.right;}}return result;
}

找大的

方法与《找小的》操作类似

第一种方法：

    /*4/   \2     6/ \   / \1   3 5   7*/
//解题思路：我们利用中序遍历的特性：遍历出来的都是升序的结果
public List<Object> greater(int key) {ArrayList<Object> result = new ArrayList<>();BSTNode p = root;LinkedList<BSTNode> stack = new LinkedList<>();while (p != null || !stack.isEmpty()) {if (p != null) {stack.push(p);p = p.left;} else {BSTNode pop = stack.pop();if (pop.key > key) {//在这里，我们遍历>key的就不需要break,让它执行到子节点为Nullresult.add(pop.value);}p = pop.right;}}return result;
}

但这样效率不高，可以用 RNL 遍历

什么是RNL 遍历？

答：

注：

前三中就是我们之前所讲的前、中、后序遍历 N：值 L：左 R：右

  • Pre-order, NLR

  • In-order, LNR

  • Post-order, LRN

以下三种遍历与上三种遍历的区别：上三种是先左后右，下三种是先右后左

  • Reverse pre-order（反向前序遍历）, NRL

  • Reverse in-order（中向前序遍历）, RNL

  • Reverse post-order（反向后序遍历）, RLN

第二种方法：

public List<Object> greater(int key) {ArrayList<Object> result = new ArrayList<>();BSTNode p = root;//RNL 遍历:得到的是降序的结果LinkedList<BSTNode> stack = new LinkedList<>();while (p != null || !stack.isEmpty()) {if (p != null) {stack.push(p);p = p.right;} else {BSTNode pop = stack.pop();if (pop.key > key) {result.add(pop.value);} else {break;}p = pop.left;}}return result;
}

找之间

方法与《找小的》操作类似

public List<Object> between(int key1, int key2) {ArrayList<Object> result = new ArrayList<>();BSTNode p = root;LinkedList<BSTNode> stack = new LinkedList<>();while (p != null || !stack.isEmpty()) {if (p != null) {stack.push(p);p = p.left;} else {BSTNode pop = stack.pop();if (pop.key >= key1 && pop.key <= key2) {result.add(pop.value);} else if (pop.key > key2) {break;}p = pop.right;}}return result;
}

小结

优点：

  1. 如果每个节点的左子树和右子树的大小差距不超过一，可以保证搜索操作的时间复杂度是 O(log n)，效率高。

  2. 插入、删除结点等操作也比较容易实现，效率也比较高。

  3. 对于有序数据的查询和处理，二叉查找树非常适用，可以使用中序遍历得到有序序列。

缺点：

  1. 如果输入的数据是有序或者近似有序的，就会出现极度不平衡的情况，可能导致搜索效率下降，时间复杂度退化成O(n)。

  2. 对于频繁地插入、删除操作，需要维护平衡二叉查找树，例如红黑树、AVL 树等，否则搜索效率也会下降。

  3. 对于存在大量重复数据的情况，需要做相应的处理，否则会导致树的深度增加，搜索效率下降。

  4. 对于结点过多的情况，由于树的空间开销较大，可能导致内存消耗过大，不适合对内存要求高的场景。

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

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

相关文章

3.（vue3.x+vite）class动态绑定的方式

3.（vue3.x+vite）class动态绑定的方式

前端技术社区总目录（订阅之前请先查看该博客） 效果浏览 代码如下 <template><div><div :class="{acti
阅读更多...
通用监控视频web播放方案

通用监控视频web播放方案

业务场景 对接监控视频&#xff0c;实现海康大华等监控摄像头的实时画面在web端播放 方案一&#xff0c;使用 RTSP2webnode.jsffmpeg 说明&#xff1a;需要node环境&#xff0c;原理就是RTSP2web实时调用ffmpeg解码。使用单独html页面部署到服务器后&#xff0c;在项目中需要播…
阅读更多...
IP 子网划分（VLSM）

IP 子网划分（VLSM）

目录 一、 为什么要划分子网 二、如何划分子网 1、划分两个子网 2、划分多个子网 一、 为什么要划分子网 假设有一个B类IP地址172.16.0.0&#xff0c;B类IP的默认子网掩码是 255.255.0.0&#xff0c;那么该网段内IP的变化范围为 172.16.0.0 ~ 172.16.255.255&#xff0c;即…
阅读更多...
【Java 进阶篇】HTML块级元素详解

【Java 进阶篇】HTML块级元素详解

HTML&#xff08;Hypertext Markup Language&#xff09;是用于创建网页的标记语言。在HTML中&#xff0c;元素被分为块级元素和内联元素两种主要类型。块级元素通常用于构建网页的结构&#xff0c;而内联元素则嵌套在块级元素内&#xff0c;用于添加文本和其他内容。本文将重点…
阅读更多...
C++设计模式-单件（Singleton）

C++设计模式-单件（Singleton）

目录 C设计模式-单件&#xff08;Singleton&#xff09; 一、意图 二、适用性 三、结构 四、参与者 五、代码 C设计模式-单件&#xff08;Singleton&#xff09; 一、意图 保证一个类仅有一个实例&#xff0c;并提供一个访问它的全局访问点。 二、适用性 当类只能有一…
阅读更多...
【17】c++设计模式——＞原型模式

【17】c++设计模式——＞原型模式

原型模式的定义 c中的原型模式&#xff08;Prototype Pattern&#xff09;是一种创建型设计模式&#xff0c;其目的是通过复制&#xff08;克隆&#xff09;已有对象来创建新的对象&#xff0c;而不需要显示的使用构造函数创建对象&#xff0c;原型模式适用于创建复杂对象时&a…
阅读更多...
浅谈内存函数以及模拟实现

浅谈内存函数以及模拟实现

1.memcpy void * memcpy ( void * destination, const void * source, size_t num ); 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。 这个函数在遇到 \0 的时候并不会停下来。 如果source和destination有任何的重叠&#xff0c;复制的结果都…
阅读更多...
保姆级微服务部署教程

保姆级微服务部署教程

大家好&#xff0c;我是鱼皮。 项目上线是每位学编程同学必须掌握的基本技能。之前我已经给大家分享过很多种上线单体项目的方法了&#xff0c;今天再出一期微服务项目的部署教程&#xff0c;用一种最简单的方法&#xff0c;带大家轻松部署微服务项目。 开始之前&#xff0c;…
阅读更多...
Linux虚拟机搭建RabbitMQ集群

Linux虚拟机搭建RabbitMQ集群

普通集群模式&#xff0c;意思就是在多台机器上启动多个 RabbitMQ 实例&#xff0c;每台机器启动一个。创建的 queue&#xff0c;只会放在一个 RabbitMQ 实例上&#xff0c;但是每个实例都同步 queue 的元数据&#xff08;元数据可以认为是 queue 的一些配置信息&#xff0c;通…
阅读更多...
自定义无边框窗口

自定义无边框窗口

效果&#xff1a; 可拖动拉伸 ui&#xff1a;设计如下 样式表&#xff1a;在ui CustomDialog 里设置的 #widget_title{background: #E6F1EB;border-top-left-radius: 20px;border-top-right-radius: 20px;}#widget_client{background-color: rgb(255, 255, 255);border-bottom…
阅读更多...
react create-react-app v5配置 px2rem （不暴露 eject方式）

react create-react-app v5配置 px2rem （不暴露 eject方式）

环境信息&#xff1a; create-react-app v5 “react”: “^18.2.0” “postcss-plugin-px2rem”: “^0.8.1” 配置步骤&#xff1a; 不暴露 eject 配置自己的webpack&#xff1a; 1.下载react-app-rewired 和 customize-cra-5 npm install react-app-rewired customize-cra…
阅读更多...
十三、Django之添加用户（原始方法实现）

十三、Django之添加用户（原始方法实现）

修改urls.py path("user/add/", views.user_add),添加user_add.html {% extends layout.html %} {% block content %}<div class"container"><div class"panel panel-default"><div class"panel-heading"><h3 c…
阅读更多...
OSI七层网络模型

OSI七层网络模型

1. OSI模型 网络协议是网络中两台计算机之间传输数据的标准语言。各种计算机系统使用 OSI&#xff08;Open Systems Interconnection&#xff09;模型规定的标准相互通信。OSI 模型有七个抽象层&#xff0c;每个层都有不同的职责和协议。 下图显示了 OSI 模型中每一层的功能。…
阅读更多...
【python海洋专题十四】读取多个盐度nc数据画盐度季节变化图

【python海洋专题十四】读取多个盐度nc数据画盐度季节变化图

本期内容 读取多个盐度文件&#xff1b;拼接数据在画盐度的季节分布图Part01. 使用数据 IAP 网格盐度数据集 数据详细介绍&#xff1a; 见文件附件&#xff1a; pages/file/dl?fid378649712527544320 全球温盐格点数据.pdf IAP_Global_ocean_gridded_product.pdf 全球温…
阅读更多...
python实现UI自动化配置谷歌浏览器驱动

python实现UI自动化配置谷歌浏览器驱动

web端UI自动化执行在哪个浏览器&#xff0c;需要对应哪个浏览器的驱动。以谷歌浏览器为例&#xff0c;进行配置。一、查看谷歌浏览器版本 如下截图&#xff1a;我的谷歌浏览器版本是&#xff1a; 117.0.5938.150 二、下载对应版本谷歌浏览器驱动 首先可以从其他版本驱动地址中…
阅读更多...
【AI】深度学习——人工智能、深度学习与神经网络

【AI】深度学习——人工智能、深度学习与神经网络

文章目录 0.1 如何开发一个AI系统0.2 表示学习(特征处理)0.2.1 传统特征学习特征选择过滤式包裹式 L 1 L_1 L1​ 正则化 特征抽取监督的特征学习无监督的特征学习 特征工程作用 0.2.2 语义鸿沟0.2.3 表示方式关联 0.2.4 表示学习对比 0.3 深度学习0.3.1 表示学习与深度学习0.3.…
阅读更多...
云原生Kubernetes：K8S集群kubectl命令汇总

云原生Kubernetes：K8S集群kubectl命令汇总

目录 一、理论 1.概念 2. kubectl 帮助方法 3.kubectl 子命令使用分类 4.使用kubectl 命令的必要环境 5.kubectl 详细命令 一、理论 1.概念 kubectl是一个命令行工具&#xff0c;通过跟 K8S 集群的 API Server 通信&#xff0c;来执行集群的管理工作。 kubectl命令是操…
阅读更多...
智慧楼宇3D数据可视化大屏交互展示实现了楼宇能源的高效、智能、精细化管控

智慧楼宇3D数据可视化大屏交互展示实现了楼宇能源的高效、智能、精细化管控

智慧园区是指将物联网、大数据、人工智能等技术应用于传统建筑和基础设施&#xff0c;以实现对园区的全面监控、管理和服务的一种建筑形态。通过将园区内设备、设施和系统联网&#xff0c;实现数据的传输、共享和响应&#xff0c;提高园区的管理效率和运营效益&#xff0c;为居…
阅读更多...
增强现实抬头显示AR-HUD

增强现实抬头显示AR-HUD

增强现实抬头显示&#xff08;AR-HUD&#xff09;可以将当前车身状态、障碍物提醒等信息3D投影在前挡风玻璃上&#xff0c;并通过自研的AR-Creator算法&#xff0c;融合实际道路场景进行导航&#xff0c;使驾驶员无需低头即可了解车辆实时行驶状况。结合DMS系统&#xff0c;可以…
阅读更多...
一个rar压缩包如何分成三个？

一个rar压缩包如何分成三个？

一个rar压缩包体积太大了&#xff0c;想要将压缩包分为三个&#xff0c;该如何做到&#xff1f;其实很简单&#xff0c;方法就在我们经常使用的WinRAR当中。 我们先将压缩包内的文件解压出来&#xff0c;然后查看一下&#xff0c;然后打开WinRAR软件&#xff0c;找到文件&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023