【算法练习】leetcode算法题合集之二叉树篇

news2024/11/17 11:34:40

递归遍历基础篇

前序遍历，中序遍历，后序遍历是根据处理根节点的位置来命名的。

树的处理大多用到了递归，递归需要知道终止条件。

前序遍历（中左右）

144.二叉树的前序遍历

中左右，先处理根节点，再处理左子树，再处理右子树

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        preOrder(res, root);
        return res;
    }

    private void preOrder(List<Integer> res, TreeNode root) {
        if(root==null){
            return;
        }
        res.add(root.val);
        preOrder(res, root.left);
        preOrder(res, root.right);
    }
}

非递归版实现前序遍历

使用栈，当前节点处理完，先塞入右节点（后处理），再塞入左节点。

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        //右左
        stack.add(root);
        while (!stack.isEmpty()) {
            TreeNode pop = stack.pop();
            res.add(pop.val);
            if (pop.right != null) {
                stack.push(pop.right);
            }
            if (pop.left != null) {
                stack.push(pop.left);
            }

        }
        return res;
    }
}

中序遍历（左中右）

94.二叉树的中序遍历

递归方式

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        inOrder(res, root);
        return res;
    }

    private void inOrder(List<Integer> res, TreeNode root) {
        if (root == null) {
            return;
        }

        inOrder(res, root.left);
        res.add(root.val);
        inOrder(res, root.right);
    }
}

非递归，左中右，先找到最左节点，处理当前节点，处理右节点。把最左边的节点都压入栈中。

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while (cur != null || !stack.isEmpty()) {
            if (cur != null) {
                stack.push(cur);
                cur = cur.left;
            } else {
                TreeNode pop = stack.pop();
                res.add(pop.val);
                cur = pop.right;
            }
        }
        return res;
    }

后序遍历（左右中）

145.二叉树的后序遍历

递归方式

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        postOrder(res, root);
        return res;

    }


    public void postOrder(List<Integer> res, TreeNode root) {
        if (root == null) {
            return;
        }
        postOrder(res,root.left);
        postOrder(res,root.right);
        res.add(root.val);
    }
}

非递归方式，左右中的逆序是中右左，处理可以参考前序遍历，最后进行倒序。

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            TreeNode pop = stack.pop();
            res.add(pop.val);
            if(pop.left!=null){
                stack.push(pop.left);
            }
            if(pop.right!=null){
                stack.push(pop.right);
            }
        }
        Collections.reverse(res);
        return res;

    }

}

层序遍历

LeetCode199.二叉树的右视图

LeetCode199.二叉树的右视图

获取当前行的最后一个元素。

class Solution_LC199 {
    public List<Integer> rightSideView(TreeNode root) {

        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            while (size > 0) {
                size--;
                TreeNode node = queue.poll();
                if (size == 0) {
                    res.add(node.val);
                }
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
        }
        return res;

    }
}

LeetCode103.二叉树的锯齿形层序遍历

LeetCode103.二叉树的锯齿形层序遍历

对树进行判空

获取当前行的元素，需要获取队列的大小。

class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int index = 0;
        while (!queue.isEmpty()) {
            index++;
            LinkedList<Integer> list = new LinkedList<>();
            int size = queue.size();
            while (size > 0) {
                size--;
                TreeNode node = queue.poll();
                if (index % 2 == 0) {
                    list.addFirst(node.val);
                } else {
                    list.addLast(node.val);
                }

                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
            res.add(list);

        }
        return res;
    }

}

剑指 Offer II 044. 二叉树每层的最大值

剑指 Offer II 044. 二叉树每层的最大值

原理同上。

class Solution_JZ044 {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            int max = Integer.MIN_VALUE;
            while (size > 0) {
                size--;
                TreeNode node = queue.poll();
                if (node.val > max) {
                    max = node.val;
                }
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }

            }
            res.add(max);
        }
        return res;
    }
}

Leetcode101. 对称二叉树

Leetcode101. 对称二叉树

递归

比较最左边和最右边的元素。

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if (root == null) {
            return true;
        }
        return dfs(root.left, root.right);

    }

    private boolean dfs(TreeNode left, TreeNode right) {
        if (left == null && right == null) {
            return true;
        }
        if (left == null || right == null) {
            return false;
        }
        if (left.val != right.val) {
            return false;
        }
        return dfs(left.left, right.right) && dfs(right.left, left.right);
    }
}

使用队列

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if (root == null || (root.left == null && root.right == null)) {
            return true;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root.left);
        queue.offer(root.right);
        while (!queue.isEmpty()) {
            TreeNode left = queue.poll();
            TreeNode right = queue.poll();
            if (left == null && right == null) {
                continue;
            }
            if (left == null || right == null) {
                return false;
            }
            if (left.val != right.val) {
                return false;
            }
            queue.offer(left.left);
            queue.offer(right.right);
            queue.offer(right.left);
            queue.offer(left.right);
        }
        return true;

    }
}

前序遍历

LeetCode257.二叉树的所有路径

LeetCode257: 二叉树的所有路径

结束条件：该节点是叶子节点，结果集添加path

如何添加连接字符->。

class Solution {
    List<String> res = new ArrayList<>();

    public List<String> binaryTreePaths(TreeNode root) {
        dfs(root, "");
        return res;
    }

    private void dfs(TreeNode root, String s) {
        if (root == null) {
            return;
        }
        s = s + root.val;
        if (root.left == null && root.right == null) {
            res.add(s);
        }else {
            dfs(root.left, s + "->");
            dfs(root.right, s + "->");
        }
    }
}

LeetCode129.求根到叶子节点数字之和

LeetCode 129.求根到叶子节点数字之和

按照上题的思路来，先把结果添加到集合里面。

class Solution {

    List<Integer> res = new ArrayList<>();

    public int sumNumbers(TreeNode root) {
        if (root == null) {
            return 0;
        }
        dfs(root, 0);
        int sum = 0;
        for (int i = 0; i < res.size(); i++) {
            sum += res.get(i);
        }
        return sum;

    }

    private void dfs(TreeNode root, int num) {
        if (root == null) {
            return;
        }
        num = num * 10 + root.val;
        if (root.left == null && root.right == null) {
            res.add(num);
        } else {
            dfs(root.left, num);
            dfs(root.right, num);
        }
    }
}

递归，当前节点的结果等于左子树操作+右子树操作

class Solution {
    List<Integer> res = new ArrayList<>();

    public int sumNumbers(TreeNode root) {
        if (root == null) {
            return 0;
        }
        return dfs2(root, 0);

    }

    private int dfs2(TreeNode root, int pre) {
        if (root == null) {
            return 0;
        }
        int sum = pre * 10 + root.val;
        if (root.left == null && root.right == null) {
            return sum;
        }
        return dfs2(root.right, sum) + dfs2(root.left, sum);
    }
}

LeetCode112.路径总和

112. 路径总和

不断累加值，判断是否和目标值相等

class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {

        return dfs(root, targetSum, 0);
    }

    private boolean dfs(TreeNode root, int targetSum, int pre) {
        if (root == null) {
            return false;
        }
        if (root.left == null && root.right == null) {
            return pre + root.val == targetSum;
        } else {
            return dfs(root.left, targetSum, pre + root.val) || dfs(root.right, targetSum, pre + root.val);
        }

    }
}

更新目标值

class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {

        if (root == null) {
            return false;
        }
        if (root.left == null && root.right == null) {
            return targetSum == root.val;
        }
        return hasPathSum(root.left, targetSum - root.val) || hasPathSum(root.right, targetSum - root.val);
    }
}

LeetCode113.路径总和II

113. 路径总和 II

用队列记录当前路径下的元素，方便回退。

class Solution {
    List<List<Integer>> res = new LinkedList<>();

    LinkedList<Integer> queue = new LinkedList<>();

    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        dfs(root,targetSum );
        return res;
    }

    private void dfs(TreeNode root, int targetSum) {
        if (root == null) {
            return;
        }
        targetSum -= root.val;
        queue.offer(root.val);
        if (root.left == null && root.right == null && targetSum == 0) {
            res.add(new ArrayList<>(queue));
        } else {
            dfs(root.left,  targetSum);
            dfs(root.right,  targetSum);
        }
        queue.pollLast();

    }
}

LeetCode437.路径总和 III（**）

LeetCode437. 路径总和 III

定义一个以某节点为开始节点获取路径总和为targetSum的方法。

不一定是叶子节点

用long代替int，因为有测试用例减溢出。

class Solution {
    public int pathSum(TreeNode root, int targetSum) {
        if (root == null) {
            return 0;
        }
        int res = rootSum(root, targetSum);
        return res + pathSum(root.left, targetSum) + pathSum(root.right, targetSum);
    }

    private int rootSum(TreeNode root, long targetSum) {
        int ret = 0;
        if (root == null) {
            return 0;
        }
        if (targetSum == root.val) {
            ret++;
        }
        return ret + rootSum(root.left, targetSum - root.val) + rootSum(root.right, targetSum - root.val);
    }
}

中序遍历

LeetCode98.验证二叉搜索树

LeetCode98.验证二叉搜索树

左子树上的节点都小于根节点，右子树上的值都大于根节点。

递归。

class Solution {
    public boolean isValidBST(TreeNode root) {
        return isValidBST(root, Long.MAX_VALUE, Long.MIN_VALUE);
    }

    private boolean isValidBST(TreeNode root, long maxValue, long minValue) {
        if (root == null) {
            return true;
        }
        if (root.val >= maxValue || root.val <= minValue) {
            return false;
        }
        return isValidBST(root.left, root.val, minValue) && isValidBST(root.right, maxValue, root.val);
    }
}

中序遍历

中序遍历 ，先左再中后右，左<中<右

比较数组是否有序，用tmp来缓存最小元素。

class Solution {
    public boolean isValidBST(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        long tmp = Long.MIN_VALUE;
        TreeNode cur = root;
        while (!stack.isEmpty() || cur != null) {
            if (cur != null) {
                stack.push(cur);
                cur = cur.left;
            }else {
                cur = stack.pop();
                if (cur.val <= tmp) {
                    return false;
                }
                tmp = cur.val;
                cur = cur.right;
            }
        }
        return true;
    }
}

剑指 Offer 54. 二叉搜索树的第k大节点

剑指 Offer 54. 二叉搜索树的第k大节点.

第n大，就是数组中第n-k个元素。第2大的元素逆序在索引1的位置。

右中左，即中序遍历的数组的倒序。

class Solution_LCR174 {
    int res;
    int index = 0;

    public int findTargetNode(TreeNode root, int cnt) {
        dfs(root, cnt);
        return res;
    }

    private void dfs(TreeNode root, int cnt) {
        if (root == null) {
            return;
        }
        dfs(root.right, cnt);
        index++;
        if (index == cnt) {
            res = root.val;
        }
        dfs(root.left, cnt);
    }
}

Leetcode230. 二叉搜索树中第K小的元素

Leetcode230. 二叉搜索树中第K小的元素

同上，不需要倒序，更简单

class Solution {
    int k;
    int res;
    int index = 0;


    public int kthSmallest(TreeNode root, int k) {
        this.k = k;
        dfs(root);
        return res;

    }

    private void dfs(TreeNode root) {
        if (root == null) {
            return;
        }
        dfs(root.left);
        index++;
        if (index == k) {
            res = root.val;
        }
        dfs(root.right);
    }
}

剑指offer36: 二叉搜索树与双向链表(*)

剑指offer36: 二叉搜索树与双向链表

pre节点是前节点，获取最左边的节点为pre节点。不断更新pre节点。

核心还是中序遍历。

class Solution {
    Node pre = null, head = null;

    public Node treeToDoublyList(Node root) {
        if (root == null) return root;
        dfs(root);
        head.left = pre;
        pre.right = head;
        return head;
    }

    void dfs(Node root) {
        if (root == null) {
            return;
        }
        dfs(root.left);
        if (pre != null) {
            pre.right = root;
        } else {
            head = root;
        }
        root.left = pre;
        pre = root;
        dfs(root.right);
    }
}

Leetcode.538. 把二叉搜索树转换为累加树（*）

Leetcode.538. 把二叉搜索树转换为累加树.

理解题意，原先是二叉搜索树，当先不一定是二叉搜索树。当前节点为原有树的大于等于当前节点（当前节点和所有右子树节点）的和。

class Solution {
    int sum = 0;

    public TreeNode convertBST(TreeNode root) {
        if (root == null) {
            return null;
        }
        convertBST(root.right);
        sum += root.val;
        root.val = sum;
        convertBST(root.left);
        return root;
    }
}

后序遍历

Leetcode104. 二叉树的最大深度

Leetcode104. 二叉树的最大深度

方法一：递归（后续遍历，左右中）

方法二：层序遍历

class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        } else {
            return Math.max(maxDepth(root.right), maxDepth(root.left)) + 1;
        }
    }
}

LeetCode226. 翻转二叉树

LeetCode226. 翻转二叉树

要暂存左边的树

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root == null) {
            return null;
        }

        TreeNode left = invertTree(root.left);
        TreeNode right = invertTree(root.right);

        root.right = left;
        root.left = right;
        return root;
    }
}

Leetcode110. 判断是否是平衡二叉树

Leetcode110. 判断是否平衡二叉树

求深度的扩展

class Solution {
    public boolean isBalanced(TreeNode root) {
        if (root == null) {
            return true;
        }
        return Math.abs(getDepth(root.left) - getDepth(root.right)) <= 1 & isBalanced(root.left)
                && isBalanced(root.right);
    }

    private int getDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        return 1 + Math.max(getDepth(root.right), getDepth(root.left));
    }
}

LeetCode543.二叉树的直径

LeetCode543.二叉树的直径

结果最大的数据不一定是根节点。

每一个节点的对应的直径等于左子树的深度+右子树的深度。

class Solution {
    int ans;

    public int diameterOfBinaryTree(TreeNode root) {
        if (root == null) {
            return 0;
        }
        depth(root);
        return ans;
    }

    private int depth(TreeNode root) {

        if (root == null) {
            return 0;
        }
        int left = depth(root.left);
        int right = depth(root.right);
        ans = Math.max(ans, right + left);
        return 1 + Math.max(left, right);
    }
}

LeetCode124.二叉树中的最大路径和

LeetCode124.二叉树中的最大路径和

计算以某节点为起点，最长的路径。路径和=左最大路径+右最大路径+当前节点的值。

如果该路径大于0，则选；否则不选。

class Solution {
    int ans = Integer.MIN_VALUE;

    public int maxPathSum(TreeNode root) {
        maxGain(root);
        return ans;
    }

    public int maxGain(TreeNode node) {
        if (node == null) {
            return 0;
        }
        int left = Math.max(maxGain(node.left), 0);
        int right = Math.max(maxGain(node.right), 0);
        ans = Math.max(ans, node.val + left + right);
        return node.val + Math.max(left, right);
    }
}

Leetcode236. 二叉树的最近公共祖先（**）

Leetcode236. 二叉树的最近公共祖先

左子树能找到，两个节点都在左边；左右子树都找到，返回root；左右子树都找不到，返回

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null || p == root || q == root) {
            return root;
        }
        TreeNode leftNode = lowestCommonAncestor(root.left, p, q);
        TreeNode rightNode = lowestCommonAncestor(root.right, p, q);
        if (leftNode == null && rightNode == null) {
            return null;
        }
        if (leftNode == null) {
            return rightNode;
        }
        if (rightNode == null) {
            return leftNode;
        }
        return root;

    }
}

二叉搜索树

Leetcode235. 二叉搜索树的最近公共祖先

Leetcode235. 二叉搜索树的最近公共祖先

遍历树的元素

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

剑指offer33: 验证二叉搜索树的后序遍历序列

验证二叉搜索树的后序遍历序列

后续遍历是左右中的结构，最后一个元素是root

序列中第一个元素大于root元素，该元素及以后是右子树的序列。

最后一个元素是根元素，不是右子树的一部分。

class Solution {
    public boolean verifyTreeOrder(int[] postorder) {
        // 左右中
        return dfs(postorder, 0, postorder.length - 1);

    }

    private boolean dfs(int[] postorder, int left, int right) {
        if (left >= right) {
            return true;
        }
        int tmp = left;
        int root = postorder[right];
        while (tmp < right && postorder[tmp] < root) {
            tmp++;
        }
        int mid = tmp;
        while (tmp < right) {
            if (postorder[tmp] < root) {
                return false;
            }
            tmp++;
        }
        return dfs(postorder, left, mid - 1) && dfs(postorder, mid, right - 1);

    }
}

二叉树的修改构造

LeetCode105.从前序和中序遍历构造二叉树

LeetCode105.从前序和中序遍历构造二叉树

前序 中左右 中序 左中右

分割中序遍历的序列，获取到左子树的长度和右子树的长度。

对数组的操作，要么是拷贝数组，要么是指定索引。

class Solution {
    Map<Integer, Integer> map = new HashMap<>();

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        
        for (int i = 0; i < inorder.length; i++) {
            map.put(inorder[i], i);
        }

        return buildTree(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1);

    }

    private TreeNode buildTree(int[] preorder, int preLeft, int preRight, int[] inorder, int inLeft, int inRight) {
        if (preRight < preLeft || inRight < inLeft) {
            return null;
        }
        int rootIndex = map.get(preorder[preLeft]);
        TreeNode root = new TreeNode(preorder[preLeft]);
        int leftLength = rootIndex - inLeft;


        root.left = buildTree(preorder, preLeft + 1, preLeft + leftLength, inorder, inLeft, rootIndex);
        root.right = buildTree(preorder, preLeft + leftLength + 1, preRight, inorder, rootIndex + 1, inRight);
        return root;
    }
}

Leetcode 297.二叉树的序列化与反序列化

Leetcode 297.二叉树的序列化与反序列化

使用先序遍历来构成数组，数组转换成树。

public class Codec {

    public String serialize(TreeNode root) {

        return rserialize(root, "");
    }

    private String rserialize(TreeNode root, String s) {
        if (root == null) {
            s += "NONE,";

        } else {
            s += root.val + ",";
            s = rserialize(root.left, s);
            s = rserialize(root.right, s);
        }
        return s;
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        String[] dataList = data.split(",");
        return rdeserialize(new ArrayList(Arrays.asList(dataList)));
    }

    private TreeNode rdeserialize(List<String> dataList) {
        if (dataList.get(0).equals("NONE")) {
            dataList.remove(0);
            return null;
        }
        TreeNode root = new TreeNode(Integer.valueOf(dataList.get(0)));
        dataList.remove(0);
        root.left = rdeserialize(dataList);
        root.right = rdeserialize(dataList);
        return root;

    }
}

二叉树的递归思维

LeetCode572.另一个树的子树

LeetCode572.另一个树的子树

简化成两棵树是否相等

class Solution {
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        if (root == null) {
            return false;
        }
        return isSameTree(root, subRoot) || isSubtree(root.left, subRoot) || isSubtree(root.right, subRoot);

    }

    public boolean isSameTree(TreeNode s, TreeNode t) {
        if (s == null && t == null) {
            return true;
        }
        if (s == null || t == null || s.val != t.val) {
            return false;
        }
        return isSameTree(s.left, t.left) && isSameTree(s.right, t.right);
    }
}

其他

LeetCode114. 二叉树展开为链表

比较简单的方法就是先序遍历元素。

class Solution {
    List<TreeNode> list = new ArrayList<>();

    public void flatten(TreeNode root) {

        dfs(root);
        for (int i = 1; i < list.size(); i++) {
            TreeNode prev = list.get(i - 1), cur = list.get(i);
            prev.left = null;
            prev.right = cur;
        }
    }

    private void dfs(TreeNode root) {
        if (root == null) {
            return;
        }
        list.add(root);
        dfs(root.left);
        dfs(root.right);

    }
}

把右节点放在左节点的最右节点的右边，把左节点放在右边，这样顺序是正确的。

class Solution {

    public void flatten(TreeNode root) {

        TreeNode cur = root;
        while (cur != null) {
            TreeNode left = cur.left;
            if (left != null) {
                TreeNode tmp = left;
                while (tmp.right != null) {
                    tmp = tmp.right;
                }
                tmp.right = cur.right;
                cur.left = null;
                cur.right = left;

            }
            cur = cur.right;
        }
    }
}

在这里插入图片描述

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

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

相关文章

简单易懂的PyTorch激活函数大全详解

简单易懂的PyTorch激活函数大全详解

目录 torch.nn子模块Non-linear Activations nn.ELU 主要特点与注意事项 使用方法与技巧 示例代码 图示 nn.Hardshrink Hardshrink函数定义 参数 形状 示例代码 图示 nn.Hardsigmoid Hardsigmoid函数定义 参数 形状 示例代码 图示 nn.Hardtanh HardTanh函数…
阅读更多...
湖南大学-数据库系统-2018期末考试解析

湖南大学-数据库系统-2018期末考试解析

【写在前面】 这是2018年的卷子&#xff0c;复习备考的时候做了并与同学校对了答案。答案仅供参考。这张难度不大&#xff0c;同样的&#xff0c;跟前几张差不了太多。但是从这一年开始&#xff0c;选择题变成了15道&#xff0c;越来越贴切近几年的考试了。 一、单选题&#xf…
阅读更多...
基于SpringBoot摄影跟拍预定管理系统(系统+数据库+文档)

基于SpringBoot摄影跟拍预定管理系统(系统+数据库+文档)

&#x1f345;点赞收藏关注 → 私信领取本源代码、数据库&#x1f345; 本人在Java毕业设计领域有多年的经验&#xff0c;陆续会更新更多优质的Java实战项目 希望你能有所收获&#xff0c;少走一些弯路。&#x1f345;关注我不迷路&#x1f345;摘 要 首先,一开始便是清楚的论…
阅读更多...
虚拟机安装KALI

虚拟机安装KALI

阅读更多...
揭秘证券公司网站部署的SSL证书品牌

揭秘证券公司网站部署的SSL证书品牌

近日&#xff0c;有多家证券公司因网络安全问题被点名&#xff0c;由此&#xff0c;建立完善的网络安全管理制度、采用适当的安全策略和工具&#xff0c;以营造安全的网络环境&#xff0c;更好的保护用户隐私和业务安全就显得尤为重要。SSL证书作为保护传输数据安全的重要工具&…
阅读更多...
pve多台物理机虚拟化 pve虚拟机优势

pve多台物理机虚拟化 pve虚拟机优势

Proxmox VE是一个运行虚拟机和容器的平台。基于Debian Linux&#xff0c;完全开源。为了获得最大的灵活性&#xff0c;实现了两种虚拟化技术——基于内核的虚拟机(KVM)和基于容器的虚拟化(LXC)。一个主要的设计目标是使管理尽可能容易。运行在单个节点上使用Proxmox VE&#xf…
阅读更多...
acwing 并查集

acwing 并查集

目录 并查集的路径压缩两种方法法一法二 AcWing 240. 食物链AcWing 837. 连通块中点的数量示例并查集自写并查集 并查集的路径压缩两种方法 法一 沿着路径查询过程中&#xff0c;将非根节点的值都更新为最后查到的根节点 int find(int x) {if (p[x] ! x) p[x] find(p[x]);r…
阅读更多...
LitJson-Json字符串转对像时:整型与字符串或字符串转:整型进的类型不一致的处理

LitJson-Json字符串转对像时:整型与字符串或字符串转:整型进的类型不一致的处理

目录 问题描述上代码测试代码各位看官&#xff0c;打赏个1元吧 Json数据格式是大家在游戏开中常量用的一种数据格式&#xff0c;某种程度上可以说是必备的。对unity开发来说&#xff0c;LitJson这个json库应该是被使用最多的json库了。 问题描述 今天说要的其中的这个api: Jso…
阅读更多...
【docker】centos7安装harbor

【docker】centos7安装harbor

目录 零、前提一、下载离线包二、安装三、访问四、开机自启 零、前提 1.前提是已经安装了docker和docker-compose 一、下载离线包 1. csdn资源&#xff1a;harbor-offline-installer-v2.10.0.tgz 2. 百度云盘&#xff08;提取码&#xff1a;ap3t&#xff09;&#xff1a;harbo…
阅读更多...
YOLOv8 Ultralytics：使用Ultralytics框架进行姿势估计

YOLOv8 Ultralytics：使用Ultralytics框架进行姿势估计

YOLOv8 Ultralytics&#xff1a;使用Ultralytics框架进行姿势估计 前言相关介绍前提条件实验环境安装环境项目地址LinuxWindows 使用Ultralytics框架进行姿势估计参考文献 前言 由于本人水平有限&#xff0c;难免出现错漏&#xff0c;敬请批评改正。更多精彩内容&#xff0c;可…
阅读更多...
*5.1 Global Memory Bandwidth

*5.1 Global Memory Bandwidth

并行程序的执行速度可能因计算硬件的资源限制而有很大差异。虽然管理并行代码和硬件资源约束之间的交互对于在几乎所有并行编程模型中实现高性能很重要&#xff0c;但这是一种实用技能&#xff0c;最好通过为高性能设计的并行编程模型中的实践练习来学习。在本章中&#xff0c;…
阅读更多...
探索大模型时代下的文档识别与分析【GPT4-V带来的挑战与机遇】

探索大模型时代下的文档识别与分析【GPT4-V带来的挑战与机遇】

中国图象图形学学会青年科学家会议是由中国图象图形学学会青年工作委员会发起的学术会议。本会议面向国际学术前沿与国家战略需求&#xff0c;致力于支持图象图形领域的优秀青年学者&#xff0c;为青年学者们提供学术交流与研讨的平台&#xff0c;促进学者之间的交流与合作。会…
阅读更多...
FreeRTOS学习总结（二）FreeRTOS任务创建和删除API函数

FreeRTOS学习总结（二）FreeRTOS任务创建和删除API函数

实现动态创建任务流程 任务控制块结构体成员介绍 typedef struct tskTaskControlBlock {volatile StackType_t * pxTopOfStack; /* 任务栈栈顶&#xff0c;必须为TCB第一个成员 */ListItem_t xStateListItem; /* 任务状态列表项 */ Li…
阅读更多...
Mobile Aloha 【软硬件原理+代码解析】

Mobile Aloha 【软硬件原理+代码解析】

1. Mobile ALOHA Hardware2. Imitation Learning3. Co-training with Static ALOHA Data4. Task Setting5. Experiments5.1 ACT5.2 对比ACT、Diffusion Policy和VINN 6. Software Code Analyze Mobile ALOHA: 利用低成本全身远程操作系统学习复杂的双手移动操作技能 [译] 硬件代…
阅读更多...
SAP BAPI_OUTB_DELIVERY_CONFIRM_DEC 交货单过账提示 VL602 为交货的发货已经计帐

SAP BAPI_OUTB_DELIVERY_CONFIRM_DEC 交货单过账提示 VL602 为交货的发货已经计帐

原因 如果尝试从交货处理的初始屏幕过账交货的货物移动&#xff0c;并且已为交货执行此步骤&#xff0c;则系统会正确发出消息 VL602&#xff08;“已针对交货过账发货”&#xff09;和/或 VL636&#xff08;“已过账此入库交货的收货”&#xff09;。 之后&#xff0c;无法再…
阅读更多...
前端入门教程：学完即可单独完成前端项目

前端入门教程：学完即可单独完成前端项目

目录 目录 1.HTML: 1.1概念 1.2结构 1.3常见的标签使用分类&#xff1a; 2.CSS: 2.1概念 2.2样式实践&#xff1a; 以下的举例都来自于博客&#xff1a; 2.3css选择器&#xff1a; 什么是css选择器&#xff1a; 举例如下&#xff1a; 2.4Demo 3.JavaScript&#…
阅读更多...
什么台灯最好学生晚上用？学生晚上用的护眼台灯推荐

什么台灯最好学生晚上用？学生晚上用的护眼台灯推荐

随着人们对健康生活的追求日益增加&#xff0c;越来越多的人开始关注眼睛健康问题。而台灯作为人们日常生活和工作中常用的照明设备之一&#xff0c;护眼台灯的出现成为了人们关注的焦点。那么&#xff0c;作为课业负担比较重的学生群体&#xff0c;有什么护眼台灯是适合他们晚…
阅读更多...
echarts - xAxis.type设置time时该如何使用formatter的分级模板

echarts - xAxis.type设置time时该如何使用formatter的分级模板

echarts 文档中描述了x轴的多种类型 一、type: ‘value’ ‘value’ 数值轴&#xff0c;适用于连续数据。 此时x轴数据是从零开始&#xff0c;有数据大小的区分。 【注意】 因为xAxis.data是为category服务的&#xff0c;所以xAxis.data里面设置的数据无效。 二、type: ‘ca…
阅读更多...
2023回顾

2023回顾

今年遇到最大的问题&#xff1a; 屏幕无故卡死&#xff0c;原因各种各样&#xff0c;至今虽说已排查了大部分的原因&#xff0c;也规避掉了一些可能问题&#xff0c;但随着新功能的添加&#xff0c;还是有可能不小心引入。 期间的解决方案也发布在Qt 屏幕偶发性失灵_qt 虚拟键盘…
阅读更多...
Springboot+RocketMQ通过事务消息优雅的实现订单支付功能

Springboot+RocketMQ通过事务消息优雅的实现订单支付功能

目录 1. 事务消息 1.1 RocketMQ事务消息的原理 1.2 RocketMQ订单支付功能设计 1. 事务消息 RocketMQ的事务消息&#xff0c;是指发送消息事件和其他事件需要同时成功或同时失败。比如银行转账&#xff0c; A银行的某账户要转一万元到B银行的某账户。A银行发送“B银行账户增加…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023