二叉搜索树的基础操作

如果对于二叉搜索树不是太清楚，为什么要使用二叉搜索树？作者推荐：二叉搜索树的初步认识_加瓦不加班的博客-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.hqwc.cn/news/129033.html

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

相关文章

前端预览、下载二进制文件流（png、pdf）

前端预览、下载二进制文件流（png、pdf）

前端请求设置 responseType: “blob” 后台接口返回的文件流如下&#xff1a; 拿到后端返回的文件流后&#xff1a; 预览 <iframe :src"previewUrl" frameborder"0" style"width: 500px; height: 500px;"></iframe>1、预览 v…
阅读更多...
Redis-03持久化

Redis-03持久化

1、RDB持久化 Redis是一个键值对数据库服务器&#xff0c;服务器中通常包含着任意个非空数据库&#xff0c;而每个非空数据库中又可以包含任意个键值对&#xff0c;通常情况下将服务器中的非空数据库以及它们的键值对统称为数据库状态 Redis是内存数据库&#xff0c;它将自己…
阅读更多...
java Spring Boot 手动启动热部署

java Spring Boot 手动启动热部署

好 接下来 我们讲一个对开发非常重要的东西 热部署 因为 我们在开发过程中总会希望快点看到效果 或者 你的企业项目一般很大很复杂&#xff0c;重启是一件非常麻烦的事 或者你在和前端同事联调&#xff0c;有一点小问题 你改完就要重启 前端还得等你&#xff0c;非常不友好 那…
阅读更多...
数据重整：用Java实现精准Excel数据排序的实用策略

数据重整：用Java实现精准Excel数据排序的实用策略

摘要&#xff1a;本文由葡萄城技术团队原创并首发。转载请注明出处&#xff1a;葡萄城官网&#xff0c;葡萄城为开发者提供专业的开发工具、解决方案和服务&#xff0c;赋能开发者。 前言 在数据处理或者数据分析的场景中&#xff0c;需要对已有的数据进行排序&#xff0c;在E…
阅读更多...
NPM使用

NPM使用

nodejs 安装查看&#xff1a;windows11 安装Nodejs-CSDN博客 一、初始化项目 1、创建文件夹 E:\vue\projectCode\npm-demo 2、打开cmd 进入E:\vue\projectCode\npm-demo目录输入cmd 点击回车 3、先看看npm命令是否可用 npm -v 4、初始化项目 npm init package name: (npm…
阅读更多...
c语言练习题83：#include“ “和#include＜＞的区别

c语言练习题83：#include“ “和#include＜＞的区别

#include" "和#include<>的区别 #include<> 默认根据环境变量的值去先搜索标准库&#xff0c;搜索系统文件会比较快。 #include“” 先搜索当前工程的路径&#xff0c;搜索自己自定义的文件会比较快。 因此自定义的头文件的名称包含在<>中的话…
阅读更多...
【Linux】冯诺依曼体系结构初识操作系统

【Linux】冯诺依曼体系结构初识操作系统

文章目录 1. 冯诺依曼体系结构2. 初识操作系统2.1 操作系统是什么&#xff1f;2. 为什么要有操作系统3. 操作系统是怎么管理的4. 系统调用&#xff08;System Call&#xff09; 1. 冯诺依曼体系结构 我们常见的计算机&#xff0c;如笔记本。我们不常见的计算机&#xff0c;如服…
阅读更多...
CS5232/CS5212支持热拔插应用主板DP转VGA转接芯片方案设计

CS5232/CS5212支持热拔插应用主板DP转VGA转接芯片方案设计

北京集睿致远CS5212是DP转VGA芯片&#xff0c;应用于各种转接线或主板应用。但对于主板市场DP转VGA转接板更适合用CS5232,其优势是&#xff1a;支持热拔插&#xff0c;温度范围也更广。 CS5232管脚定义: CS5232设计参考原理图如下&#xff1a; 以上综合来看&#xff0c;CS5232…
阅读更多...
HttpClient实现爬虫开发

HttpClient实现爬虫开发

网络爬虫是一种高效获取网络信息的方式&#xff0c;而HttpClient是一个强大而灵活的Java库&#xff0c;提供了方便的API和丰富的功能&#xff0c;使其成为开发高效且灵活的网络爬虫的理想选择。本文将分享如何利用HttpClient库进行网络爬虫开发&#xff0c;帮助您更好地理解并实…
阅读更多...
HarmonyOS学习路之方舟开发框架—学习ArkTS语言（状态管理 八）

HarmonyOS学习路之方舟开发框架—学习ArkTS语言（状态管理 八）

其他状态管理概述 除了前面章节提到的组件状态管理和应用状态管理&#xff0c;ArkTS还提供了Watch和$$来为开发者提供更多功能&#xff1a; Watch用于监听状态变量的变化。$$运算符&#xff1a;给内置组件提供TS变量的引用&#xff0c;使得TS变量和内置组件的内部状态保持同步…
阅读更多...
连续子数组的最大和

连续子数组的最大和

这其实用到的是一个dp的动态规划数组来描写的。 用两个变量就能解决了&#xff0c;一个是max(记录前i个数中子数组的最大的和), 一个是sum是记录前i个数组的和最大值和自己去比较&#xff0c;就是前i-1个和是8&#xff0c;自己是-2&#xff0c; 8 - 2 > -2&#xff0c;所以…
阅读更多...
websocket实现go（server）与c#（client）通讯

websocket实现go（server）与c#（client）通讯

go 服务端 使用到github.com/gorilla/websocket package mainimport ("fmt""github.com/gorilla/websocket""log""net/http" )func main() {var upgrader websocket.Upgrader{ReadBufferSize: 1024,WriteBufferSize: 1024,CheckOr…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023