数据结构与算法-12_二叉搜索树

文章目录

      • 1.概述
      • 2.实现
        • 定义节点
        • 查询
        • Comparable
        • 最小
        • 最大
        • 新增
        • 前驱后继
        • 删除
        • 找小的
        • 找大的
        • 找之间
        • 小结
      • 3.习题
        • E01. 删除节点-Leetcode 450
        • E02. 新增节点-Leetcode 701
        • E03. 查询节点-Leetcode 700
        • E04. 验证二叉搜索树-Leetcode 98
        • E05. 求范围和-Leetcode 938
        • E06. 根据前序遍历结果构造二叉搜索树-Leetcode 1008
        • E07. 二叉搜索树的最近公共祖先-Leetcode 235

1.概述

二叉搜索树（也称二叉排序树）是符合下面特征的二叉树：

  1. 树节点增加 key 属性，用来比较谁大谁小，key 不可以重复
  2. 对于任意一个树节点，它的 key 比左子树的 key 都大，同时也比右子树的 key 都小，例如下图所示

在这里插入图片描述

查找 7 （从根开始）应用二分查找算法，只需三次比较

  • 与 4 比，较之大，向右找
  • 与 6 比，较之大，继续向右找
  • 与 7 比，找到

查找、插入、删除的时间复杂度与树高相关

  • 如果这棵树左右平衡，时间复杂度均是 O ( log ⁡ N ) O(\log{N}) O(logN)
  • 如果这棵树左右高度相差过大，这时是最糟的情况，时间复杂度是 O ( N ) O(N) O(N)
    在这里插入图片描述
  • 二叉搜索树 - binary search tree，简称 BST
  • 二叉排序树 - binary ordered tree 或 binary sorted tree

2.实现

定义节点
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

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

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);
    }

    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;
        }
    }

}
最小

递归实现

public Object min() {
    return doMin(root);
}

public Object doMin(BSTNode node) {
    if (node == 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;
}
新增

递归实现

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;
        if (key < node.key) {
            node = node.left;
        } else if (node.key < key) {
            node = node.right;
        } else {
            // 1. key 存在则更新
            node.value = value;
            return;
        }
    }
    // 2. key 不存在则新增
    if (parent == null) {
        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 的前驱是1
    • 4 的前驱是 3
    • 6 的前驱是 5
    • 7 的前驱是 6
  2. 节点没有左子树，若离它最近的祖先自从左而来，此祖先即为前驱
    • 3 的祖先 2 自左而来，前驱 2
    • 5 的祖先 4 自左而来，前驱 4
    • 8 的祖先 7 自左而来，前驱 7
    • 1 没有这样的祖先，前驱 null

找后继

在这里插入图片描述

  1. 节点有右子树，后继节点即为右子树的最小值
    • 2 的后继 3
    • 3 的后继 4
    • 5 的后继 6
    • 7 的后继 8
  2. 节点没有右子树，若离它最近的祖先自从右而来，此祖先即为后继
    • 1 的祖先 2 自右而来，后继 2
    • 4 的祖先 5 自右而来，后继 5
    • 6 的祖先 7 自右而来，后继 7
    • 8 没有这样的祖先，后继 null
public Object predecessor(int key) {
    BSTNode ancestorFromLeft = null;
    BSTNode p = root;
    while (p != null) {
        if (key < p.key) {
            p = p.left;
        } else if (p.key < key) {
            ancestorFromLeft = p;
            p = p.right;
        } else {
            break;
        }
    }

    if (p == null) {
        return null;
    }
    // 情况1 - 有左孩子
    if (p.left != null) {
        return max(p.left);
    }
    // 情况2 - 有祖先自左而来
    return ancestorFromLeft != null ? ancestorFromLeft.value : null;
}


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) {
            sParent = 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;
    }
    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;
    }
}

递归实现

public Object delete(int key) {
    ArrayList<Object> result = new ArrayList<>();
    root = doDelete(root, key, result);
    return result.isEmpty() ? null : result.get(0);
}

public BSTNode doDelete(BSTNode node, int key, ArrayList<Object> result) {
    if (node == null) {
        return null;
    }
    if (key < node.key) {
        node.left = doDelete(node.left, key, result);
        return node;
    }
    if (node.key < key) {
        node.right = doDelete(node.right, key, result);
        return node;
    }
    result.add(node.value);
    if (node.left != null && node.right != null) {
        BSTNode s = node.right;
        while (s.left != null) {
            s = s.left;
        }
        s.right = doDelete(node.right, s.key, new ArrayList<>());
        s.left = node.left;
        return s;
    }
    return node.left != null ? node.left : node.right;
}

说明

  1. ArrayList<Object> result 用来保存被删除节点的值
  2. 第二、第三个 if 对应没找到的情况，继续递归查找和删除， doDelete 返回值代表删剩下的，需要更新
  3. 最后一个 return 对应删除节点只有一个孩子的情况，返回那个不为空的孩子，待删节点自己因没有返回而被删除
  4. 第四个 if 对应删除节点有两个孩子的情况，此时需要找到后继节点，并在待删除节点的右子树中删掉后继节点，最后用后继节点替代掉待删除节点返回，改变后继节点的左右指针
找小的
public List<Object> less(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) {
                result.add(pop.value);
            } else {
                break;
            }
            p = pop.right;
        }
    }
    return result;
}
找大的
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) {
                result.add(pop.value);
            }
            p = pop.right;
        }
    }
    return result;
}

效率不高，可以用 RNL 遍历

注：

  • 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;
    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. 对于结点过多的情况，由于树的空间开销较大，可能导致内存消耗过大，不适合对内存要求高的场景。

3.习题

E01. 删除节点-Leetcode 450
public TreeNode deleteNode(TreeNode node, int key) {
    if (node == null) {
        return null;
    }
    if (key < node.val) {
        node.left = deleteNode(node.left, key);
        return node;
    }
    if (node.val < key) {
        node.right = deleteNode(node.right, key);
        return node;
    }
    if (node.left == null) { // 情况1 - 只有右孩子
        return node.right;
    }
    if (node.right == null) { // 情况2 - 只有左孩子
        return node.left;
    }
    TreeNode s = node.right; // 情况3 - 有两个孩子
    while (s.left != null) {
        s = s.left;
    }
    s.right = deleteNode(node.right, s.val);
    s.left = node.left;
    return s;
}
E02. 新增节点-Leetcode 701
public TreeNode insertIntoBST(TreeNode node, int val) {
    if(node == null) {
        return new TreeNode(val);
    }
    if(val < node.val) {
        node.left = insertIntoBST(node.left, val);
    } else if(node.val < val) {
        node.right = insertIntoBST(node.right, val);
    }
    return node;
}
E03. 查询节点-Leetcode 700
public TreeNode searchBST(TreeNode node, int val) {
    if(node == null) {
        return null;
    }
    if(val < node.val) {
        return searchBST(node.left, val);
    } else if(node.val < val) {
        return searchBST(node.right, val);
    } else {
        return node;
    }
}
E04. 验证二叉搜索树-Leetcode 98

中序非递归实现

public boolean isValidBST(TreeNode root) {
    TreeNode p = root;
    LinkedList<TreeNode> stack = new LinkedList<>();
    long prev = Long.MIN_VALUE;
    while (p != null || !stack.isEmpty()) {
        if (p != null) {
            stack.push(p);
            p = p.left;
        } else {
            TreeNode pop = stack.pop();
            if (prev >= pop.val) {
                return false;
            }
            prev = pop.val;
            p = pop.right;
        }
    }
    return true;
}
  • 记录 prev 需要用 long，否则若测试用例中最小的节点为 Integer.MIN_VALUE 则测试会失败
  • 如果相邻两个节点相等，也不应当通过测试，例如，下面的树也是不合法的
	2
   / 
  2

中序递归实现

public boolean isValidBST(TreeNode root) {
    if (root == null) {
        return true;
    }
    return doValid(new AtomicLong(Long.MIN_VALUE),root);
}

public boolean doValid(AtomicLong prev, TreeNode node) {
    if (node == null) {
        return true;
    }
    boolean a = doValid(prev, node.left);
    if (prev.get() >= node.val) {
        return false;
    }
    prev.set(node.val);
    boolean b = doValid(prev, node.right);
    return a && b;
}
  • 为何不能用 Long 或 long？因为它们都是局部变量且不可变，因此每次赋值时，并不会改变其它方法调用时的 prev
  • 要么把 prev 设置为 AtomicLong，要么把 prev 设置为全局变量，而不要采用方法参数这样的局部变量

上下限递归

public boolean isValidBST(TreeNode node) {
    return doValid(node, Long.MIN_VALUE, Long.MAX_VALUE);
}

private boolean doValid(TreeNode node, long min, long max) {
    if (node == null) {
        return true;
    }
    if (node.val <= min || node.val >= max) {
        return false;
    }
    return doValid(node.left, min, node.val) && doValid(node.right, node.val, max);
}
  • 设每个节点必须在一个范围内： ( m i n , m a x ) (min, max) (min,max)，不包含边界，若节点值超过这个范围，则返回 false
  • 对于 node.left 范围肯定是 ( m i n , n o d e . v a l ) (min, node.val) (min,node.val)
  • 对于 node.right 范围肯定是 ( n o d e . v a l , m a x ) (node.val, max) (node.val,max)
  • 一开始 min，max 则取 java 中长整数的最小、最大值
  • 上下限递归 = 前序遍历 + 剪枝
E05. 求范围和-Leetcode 938

中序递归实现

public int rangeSumBST(TreeNode node, int low, int high) {
    if (node == null) {
        return 0;
    }
    int a = rangeSumBST(node.left, low, high);
    int b = 0;
    if (node.val >= low && node.val <= high) {
        b = node.val;
    }
    return a + b + rangeSumBST(node.right, low, high);
}

中序非递归实现

public int rangeSumBST(TreeNode node, int low, int high) {
    TreeNode p = node;
    LinkedList<TreeNode> stack = new LinkedList<>();
    int sum = 0;
    while(p != null || !stack.isEmpty()) {
        if (p != null) {
            stack.push(p);
            p = p.left;
        } else {
            TreeNode pop = stack.pop();
            if (pop.val > high) {
                break;
            }
            if (pop.val >= low) {
                sum += pop.val;
            }
            p = pop.right;
        }
    }
    return sum;
}

上下限递归实现

public int rangeSumBST(TreeNode node, int low, int high) {
    if (node == null) {
        return 0;
    }
    if (node.val < low) {
        return rangeSumBST(node.right, low, high);
    } 
    if (node.val > high) {
        return rangeSumBST(node.left, low, high);
    }
    return node.val + 
        rangeSumBST(node.left, low, high) + 
        rangeSumBST(node.right, low, high);
}
  • node.val < low 只需考虑它右子树的累加结果
  • node.val > high 只需考虑它左子树的累加结果
  • node.val 在范围内，需要把当前节点的值加上其左右子树的累加结果
E06. 根据前序遍历结果构造二叉搜索树-Leetcode 1008

直接插入

注意：根据前序遍历的结果，可以唯一地构造出一个二叉搜索树

public TreeNode bstFromPreorder(int[] preorder) {
    TreeNode root = insert(null, preorder[0]);
    for (int i = 1; i < preorder.length; i++) {
        insert(root, preorder[i]);
    }
    return root;
}

private TreeNode insert(TreeNode node, int val) {
    if (node == null) {
        return new TreeNode(val);
    }
    if(val < node.val) {
        node.left = insert(node.left, val);
    } else if(node.val < val){
        node.right = insert(node.right, val);
    }
    return node;
}

上限法

public TreeNode bstFromPreorder(int[] preorder) {
    return insert(preorder, Integer.MAX_VALUE);
}

int i = 0;
private TreeNode insert(int[] preorder, int max) {
    if (i == preorder.length) {
        return null;
    }
    int val = preorder[i];
    System.out.println(val + String.format("[%d]", max));
    if (val > max) {
        return null;
    }
    TreeNode node = new TreeNode(val);
    i++;
    node.left = insert(preorder, node.val); 
    node.right = insert(preorder, max);     
    return node;
}

依次处理 prevorder 中每个值, 返回创建好的节点或 null 作为上个节点的孩子

  1. 如果超过上限, 返回 null
  2. 如果没超过上限, 创建节点, 并将其左右孩子设置完整后返回
    • i++ 需要放在设置左右孩子之前，是从剩下的元素中挑选左右孩子

分治法

public TreeNode bstFromPreorder(int[] preorder) {
    return partition(preorder, 0, preorder.length - 1);
}

private TreeNode partition(int[] preorder, int start, int end) {
    if (start > end) {
        return null;
    }
    TreeNode root = new TreeNode(preorder[start]);
    int index = start + 1;
    while (index <= end) {
        if (preorder[index] > preorder[start]) {
            break;
        }
        index++;
    }
    // index 就是右子树的起点
    root.left = partition(preorder, start + 1, index - 1);
    root.right = partition(preorder, index, end);
    return root;
}
  • 刚开始 8, 5, 1, 7, 10, 12，方法每次执行，确定本次的根节点和左右子树的分界线
  • 第一次确定根节点为 8，左子树 5, 1, 7，右子树 10, 12
  • 对 5, 1, 7 做递归操作，确定根节点是 5， 左子树是 1， 右子树是 7
  • 对 1 做递归操作，确定根节点是 1，左右子树为 null
  • 对 7 做递归操作，确定根节点是 7，左右子树为 null
  • 对 10, 12 做递归操作，确定根节点是 10，左子树为 null，右子树为 12
  • 对 12 做递归操作，确定根节点是 12，左右子树为 null
  • 递归结束，返回本范围内的根节点
E07. 二叉搜索树的最近公共祖先-Leetcode 235

要点：若 p，q 在 ancestor 的两侧，则 ancestor 就是它们的最近公共祖先

public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
    TreeNode ancestor = root;
    while (ancestor.val > p.val && ancestor.val > q.val || 
           ancestor.val < p.val && ancestor.val < q.val) {
        if (ancestor.val > p.val) {
            ancestor = ancestor.left;
        } else {
            ancestor = ancestor.right;
        }
    }
    return ancestor;
}

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

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

相关文章

VB.net实战(VSTO)：Excel插件的安装与卸载

VB.net实战(VSTO)：Excel插件的安装与卸载

1. 安装 1.1编程环境&#xff1a;Visual Studio 2022 1.2创建新项目&#xff1a; 1.3 加入一行测试程序&#xff1a;MsgBox&#xff08;“hello”&#xff09;&#xff0c;点击启动&#xff0c;确认可以弹窗 1.4 点击发布 1.5 找到安装程序&#xff0c;点击安装。打开Excel程…
阅读更多...
XM平台的交易模式模式是什么？

XM平台的交易模式模式是什么？

外汇交易平台的盈利模式主要分为两种&#xff1a;有交易员平台和无交易员平台。 有交易员平台&#xff0c;也称为做市商平台&#xff0c;为客户提供交易市场&#xff0c;并在需要时与客户持相反方向的交易&#xff0c;从中赚取利润。交易者看到的买入卖出价可能与实际价格不同&…
阅读更多...
Android完整备份：备份Android手机数据的4种最佳方法

Android完整备份：备份Android手机数据的4种最佳方法

如今&#xff0c;人们每天都依赖手机&#xff0c;丢失数据对我们所有人来说都是一个大麻烦。由于生活是不可预测的&#xff0c;没有人知道什么时候他的数据可能会被意外删除或丢失。因此&#xff0c;仔细备份手机数据非常重要。大多数主要智能手机平台都具有将数据备份到计算机…
阅读更多...
在Win10安装MySQL环境以及更改相关配置---附带每一步截图

在Win10安装MySQL环境以及更改相关配置---附带每一步截图

下载MySQL数据库 MySQL官网链接 选择合适自己的版本&#xff0c;这里我选择5.7.17&#xff0c;选择安装包大的那一个&#xff0c;这个是离线安装&#xff0c;下载到本地后进行安装。 选择“No thanks&#xff0c;just start my download.”即进入下载状态。 安装 运行安…
阅读更多...
JavaSE——【方法的使用】（二）

JavaSE——【方法的使用】（二）

文章目录 前言一、方法重载二、递归总结 前言 在无尽的宇宙深处&#xff0c;一艘造型奇特的飞船如流星般划过黑暗。飞船内部&#xff0c;各种高科技设备闪烁着冷峻的光芒。一位年轻的宇航员正专注地操作着控制面板&#xff0c;面板上突然弹出JavaSE—方法的使用的续篇更新了&am…
阅读更多...
【Python Cookbook】S01E20 fnmatch 模块做字符串匹配

【Python Cookbook】S01E20 fnmatch 模块做字符串匹配

目录 问题解决方案讨论 问题 在不同的操作系统下&#xff0c;怎样做字符串匹配&#xff1f; 解决方案 fnmatch() 模块提供两个函数&#xff0c;fnmatch() 以及 fnmatchcase() 可以用来执行做这样的匹配。 from fnmatch import fnmatch, fnmatchcasematch_res fnmatch(foo.…
阅读更多...
MBR10100FCT-ASEMI肖特基二极管MBR10100FCT

MBR10100FCT-ASEMI肖特基二极管MBR10100FCT

编辑&#xff1a;ll MBR10100FCT-ASEMI肖特基二极管MBR10100FCT 型号&#xff1a;MBR10100FCT 品牌&#xff1a;ASEMI 封装&#xff1a;TO-220F 最大平均正向电流&#xff08;IF&#xff09;&#xff1a;10A 最大循环峰值反向电压&#xff08;VRRM&#xff09;&#xff1…
阅读更多...
Python实现定时任务的三种方案——schedule、APScheduler、Celery

Python实现定时任务的三种方案——schedule、APScheduler、Celery

schedule schedule是一个轻量级的Python库&#xff0c;用于定期执行任务&#xff0c;即定时任务调度。它提供了一种简单直观的方式来自定义任务执行的时间规则&#xff0c;而无需复杂的线程或进程管理知识。schedule适用于那些需要在后台定期执行某些功能的Python应用程序&…
阅读更多...
指令工程Prompt的演变：从必须技能到AI内置功能

指令工程Prompt的演变：从必须技能到AI内置功能

前言 随着人工智能&#xff08;AI&#xff09;技术的飞速发展&#xff0c;我们见证了许多领域的变革。在AI的早期&#xff0c;指令工程&#xff08;Prompt Engineering&#xff09;是一项关键技能&#xff0c;它允许我们更有效地与AI进行交互&#xff0c;指导AI完成特定的任务…
阅读更多...
C:pro_1

C:pro_1

涉及知识点：C语言、数据结构、文件IO 1前言 ①linux挂载U盘 为解决多张图片传输到6813传输慢的不足，采用linux挂载U盘。步骤为： ①查看U盘名字 fdisk -l ②建USB文件夹 mkdir /mnt/usb ③挂载u盘 mount /dev/sda /mnt/usb 进入/mnt/usb可以查看u盘的内容 ④…
阅读更多...
如何去掉IDEA中烦人的警告波浪线

如何去掉IDEA中烦人的警告波浪线

有时候想去掉idea中那些黄色的红色的warning波浪线&#xff0c;这些不是错误&#xff0c;并不影响执行&#xff0c;一直显示显得让人很烦躁&#xff0c;去"Editor" -> "Inspections"中一个个设置很麻烦。 可以通过设置代码检测级别来降低代码检查的严格…
阅读更多...
从零开始发布你的第一个npm插件包并在多项目中使用

从零开始发布你的第一个npm插件包并在多项目中使用

引言 在开源的世界里&#xff0c;每个人都有机会成为贡献者&#xff0c;甚至是创新的引领者。您是否有过这样的想法&#xff1a;开发一个解决特定问题的小工具&#xff0c;让她成为其他开发者手中的利器&#xff1f;今天&#xff0c;我们就来一场实战训练&#xff0c;学习如何将…
阅读更多...
交易者要敢于“自我隔离”，建立自己和市场的“防火墙”

交易者要敢于“自我隔离”，建立自己和市场的“防火墙”

交易技巧与知识是可学习的&#xff0c;市场经验也是可积累的&#xff0c;但更需要形成成熟的心理&#xff0c;并且快速付诸实际行动&#xff0c;而这种行动是一个漫长的实践&#xff0c;追求和感悟的过程。 作为交易员每天面临着大量的胜败&#xff0c;责任重大、压力巨大。理性…
阅读更多...
大模型学习之菜鸟的进阶道路

大模型学习之菜鸟的进阶道路

在我学习大模型之前&#xff0c;我一直是一个java哥&#xff0c;现在学习了大模型&#xff0c;我看视频学习&#xff0c;就只知道一个base llm&#xff0c;还有一个是instruction tuned llm&#xff0c;我理解了这些词汇的意义&#xff0c;然后进入了正式学习&#xff0c;那我们…
阅读更多...
【Qt】 new成功，但是没有进入到构造函数。

【Qt】 new成功，但是没有进入到构造函数。

NameTest工程中 nametest.cpp NameTest::NameTest() {pdata new privateAB; }NameTest::~NameTest() {if (pdata){privateAB *p (privateAB *)pData; //void *pdata nullptr;delete p;pdata nullptr;} }内部类&#xff1a; privateAB #include "private.h"#i…
阅读更多...
vs2015Professional英文版和中文版的安装教程（附安装包）

vs2015Professional英文版和中文版的安装教程（附安装包）

英文版 下载安装包 1、Visual Studio 2015 With Update 3 Community 32位64位英文社区版下载地址&#xff1a; http://download.microsoft.com/download/b/e/d/bedddfc4-55f4-4748-90a8-ffe38a40e89f/vs2015.3.com_enu.iso 镜像名称&#xff1a;en_visual_studio_community_…
阅读更多...
图片像素缩放，支持个性化自定义与精准比例调整，让图像处理更轻松便捷！

图片像素缩放，支持个性化自定义与精准比例调整，让图像处理更轻松便捷！

图片已经成为我们生活中不可或缺的一部分。无论是社交媒体的分享&#xff0c;还是工作文档的编辑&#xff0c;图片都扮演着至关重要的角色。然而&#xff0c;你是否曾经遇到过这样的问题&#xff1a;一张高清大图在上传时却受限于平台的大小要求&#xff0c;或者一张小图需要放…
阅读更多...
Python用于简化数据操作和分析工作库之DaPy使用详解

Python用于简化数据操作和分析工作库之DaPy使用详解

概要 在数据科学和机器学习领域，处理和分析数据是关键的一步。Python 的 DaPy 库提供了一组强大的工具，用于简化数据操作和分析工作。DaPy 旨在提供高效且直观的 API，使得数据处理变得更加便捷。本文将详细介绍 DaPy 库，包括其安装方法、主要特性、基本和高级功能，以及实…
阅读更多...
【MMdetection】2.自定义数据训练

【MMdetection】2.自定义数据训练

1.废话 因为MMdetection里面提供了非常多的模型和配置文件供我们选择，这样做对比实验非常方便。 在标准数据集上训练预定义的模型 — MMDetection 3.3.0 文档 官方文档在此。 openMMlab提供了各种经典网络和配置文件系统使得MMdetection的上手难度有一点，不熟悉官方常规操…
阅读更多...
AI绘画入门基础之描述关键词（提示词）需要遵循什么逻辑？

AI绘画入门基础之描述关键词（提示词）需要遵循什么逻辑？

简单来说总结为一句话&#xff1a;就是告诉AI&#xff0c;你要画什么东西&#xff0c;东西长什么样&#xff0c;用什么画法绘画。 1. 概念性与详细性&#xff1a; 使用这么多AI绘画工具创作图片以来&#xff0c;其实有时候根据一些中文概念词语也能生成一些不错的画风图片&a…
阅读更多...
最新文章

Copyright @ 2022~2023