代码随想录算法训练营Day13 | 递归遍历、迭代遍历、层序遍历

news2024/9/24 14:17:44

目录

递归遍历和迭代遍历：

144.二叉树的前序遍历

94.二叉树的中序遍历

145.二叉树的后序遍历

层序遍历：

102.二叉树的层序遍历

107.二叉树的层序遍历Ⅱ

199.二叉树的右视图

637.二叉树的层平均值

429.N叉树的层序遍历

515.在每个树行中找最大值

116.填充每个节点的下一个右侧节点指针

117.填充每个节点的下一个右侧节点指针Ⅱ

104.二叉树的最大深度

111.二叉树的最小深度

144.二叉树的前序遍历

题目

144. 二叉树的前序遍历 - 力扣（LeetCode）

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

示例1：

输入：root = [1,null,2,3]

输出：[1,2,3]

在这里插入图片描述

示例2：

输入：root = [1,2,3,4,5,null,8,null,null,6,7,9]

输出：[1,2,4,5,6,7,3,8,9]

在这里插入图片描述

示例3：

输入：root = []

输出：[]

示例4：

输入：root = [1]

输出：[1]

提示：

  • 树中节点数目在范围 [0, 100] 内
  • -100 <= Node.val <= 100

思路

代码随想录：二叉树的递归遍历

代码随想录：二叉树的迭代遍历

视频讲解：LeetCode：144.前序遍历，145.后序遍历，94.中序遍历

视频讲解：二叉树的遍历迭代法 | 前序与后序

分别使用递归法和迭代法解题。

迭代法使用栈实现，前序遍历实现如下：

  1. 初始化一个空栈，并将根节点压入栈中。
  2. 当栈不为空时，弹出栈顶节点，访问该节点，并依次将其右孩子和左孩子节点压入栈中（因为栈是后进先出，所以左孩子会先被处理）。
  3. 重复步骤2，直到栈为空。

二叉树前序遍历（迭代法）

题解

递归法：

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

    void preorder(List list, TreeNode root) {
        if (root == null)
            return;
        list.add(root.val);
        if (root.left != null)
            preorder(list, root.left);
        if (root.right != null)
            preorder(list, root.right);
    }
}

迭代法：

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Deque<TreeNode> deque = new ArrayDeque<>();
        if(root!=null){
            deque.push(root);
        }
        while(!deque.isEmpty()){
            TreeNode tmp = deque.pop();
            res.add(tmp.val);
            if(tmp.right!=null)
                deque.push(tmp.right);
            if(tmp.left!=null)
                deque.push(tmp.left);    
        }
        return res;
    }
}

94.二叉树的中序遍历

题目

94. 二叉树的中序遍历 - 力扣（LeetCode）

给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

示例1：

输入：root = [1,null,2,3]
输出：[1,3,2]

在这里插入图片描述

示例2：

输入：root = []
输出：[]

示例3：

输入：root = [1]
输出：[1]

提示：

  • 树中节点数目在范围 [0, 100] 内
  • -100 <= Node.val <= 100

思路

代码随想录：二叉树的递归遍历

代码随想录：二叉树的迭代遍历

视频讲解：LeetCode：144.前序遍历，145.后序遍历，94.中序遍历

视频讲解：二叉树的遍历迭代法 | 中序

同样使用栈来实现迭代法，步骤如下：

  1. 初始化一个空栈，将当前节点设为根节点。
  2. 当当前节点不为空时，将其压入栈中，并将当前节点设为其左孩子。
  3. 如果当前节点为空，弹出栈顶节点，访问该节点，然后将当前节点设为其右孩子。
  4. 重复上述步骤，直到栈为空并且当前节点也为空。

二叉树中序遍历（迭代法）

题解

递归法：

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

    void inorder(List list, TreeNode root) {
        if (root == null)
            return;
        if (root.left != null)
            inorder(list, root.left);
        list.add(root.val);    
        if (root.right != null)
            inorder(list, root.right);
    }
}

迭代法：

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

145.二叉树的后序遍历

题目

145. 二叉树的后序遍历 - 力扣（LeetCode）

给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。

示例1：

输入：root = [1,null,2,3]

输出：[3,2,1]

img

示例2：

输入：root = [1,2,3,4,5,null,8,null,null,6,7,9]

输出：[4,6,7,5,2,9,8,3,1]

在这里插入图片描述

示例3：

输入：root = []

输出：[]

示例4：

输入：root = [1]

输出：[1]

提示：

  • 树中节点的数目在范围 [0, 100] 内
  • -100 <= Node.val <= 100

思路

代码随想录：二叉树的递归遍历

代码随想录：二叉树的迭代遍历

视频讲解：LeetCode：144.前序遍历，145.后序遍历，94.中序遍历

视频讲解：二叉树的遍历迭代法 | 前序与后序

迭代法：

具体步骤如下所示：

  1. 初始化一个空栈，将根节点入栈，使用一个变量 prev 初始化为 null，用来追踪上一个已访问的节点。
  2. 当栈不为空时，查看栈顶节点 cur。
  3. 若栈顶节点 cur 没有左孩子和右孩子，或 prev 是其左孩子或右孩子（即左右子树都已被访问过），则弹出 cur，并添加到结果中，然后将 prev 设为 cur。
  4. 若不满足条件3，按顺序将其右孩子和左孩子压入栈，确保左孩子先被访问。
  5. 重复步骤2-4，直到栈为空

题解

递归法：

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

    void postorder(List list, TreeNode root) {
        if (root == null)
            return;
        if (root.left != null)
            postorder(list, root.left);
        if (root.right != null)
            postorder(list, root.right);
        list.add(root.val);
    }
}

迭代法：

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Deque<TreeNode> deque = new ArrayDeque<>();
        TreeNode cur = root;
        TreeNode prev = null;
        while (!deque.isEmpty() || cur != null) {
            while (cur != null) {
                deque.push(cur);
                cur = cur.left;
            }
            cur = deque.peek();
            if (cur.right == null || cur.right == prev) {
                res.add(cur.val);
                deque.pop();
                prev = cur;
                cur = null;
            } else {
                cur = cur.right;
            }
        }
        return res;
    }
}

102.二叉树的层序遍历

题目

102. 二叉树的层序遍历 - 力扣（LeetCode）

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。（即逐层地，从左到右访问所有节点）。

示例1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

在这里插入图片描述

示例2：

输入：root = [1]
输出：[[1]]

示例3：

输入：root = []
输出：[]

提示：

  • 树中节点数目在范围 [0, 2000] 内
  • -1000 <= Node.val <= 1000

思路

代码随想录：102.二叉树的层序遍历

视频讲解：LeetCode：102.二叉树的层序遍历

层序遍历二叉树，就是从左到右一层一层的去遍历二叉树，需要借用队列来实现，队列先进先出，符合一层一层遍历的逻辑。

使用队列实现二叉树广度优先遍历过程如下：

102二叉树的层序遍历

初始化：

  • 创建一个空队列 queue，并将根节点 root 入队。
  • 如果 root 为 null，直接返回空列表。

主循环：

  • 当队列不为空时，执行以下操作：
    • 从队列中取出队首节点 node 并将其值添加到结果列表。
    • 若 node 有左孩子，将左孩子入队。
    • 若 node 有右孩子，将右孩子入队。

重复上述过程，直到队列为空。

题解

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        Deque<TreeNode> deque = new ArrayDeque<>();
        if (root == null)
            return res;
        deque.push(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            List<Integer> list = new ArrayList<>();
            while (size-- > 0) {
                TreeNode node = deque.poll();
                list.add(node.val);
                if (node.left != null)
                    deque.offer(node.left);
                if (node.right != null)
                    deque.offer(node.right);
            }
            res.add(list);
        }
        return res;
    }
}

107.二叉树的层序遍历 Ⅱ

题目

107. 二叉树的层序遍历 II - 力扣（LeetCode）

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

示例1：

输入：root = [3,9,20,null,null,15,7]
输出：[[15,7],[9,20],[3]]

img

思路

代码随想录：107.二叉树的层序遍历Ⅱ

思路如102. 二叉树的层序遍历 - 力扣（LeetCode），最后使用 Collections.reverse()翻转即可。

题解

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        Deque<TreeNode> deque = new ArrayDeque<>();
        if (root == null)
            return res;
        deque.push(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            List<Integer> list = new ArrayList<>();
            while (size-- > 0) {
                TreeNode node = deque.poll();
                list.add(node.val);
                if (node.left != null)
                    deque.offer(node.left);
                if (node.right != null)
                    deque.offer(node.right);
            }
            res.add(list);
        }
        Collections.reverse(res);
        return res;
    }
}

199.二叉树的右视图

题目

199. 二叉树的右视图 - 力扣（LeetCode）

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例1：

输入: [1,2,3,null,5,null,4]
输出: [1,3,4]

在这里插入图片描述

示例2：

输入: [1,2,3,4]
输出: [1,3,4]

思路

代码随想录：199.二叉树的右视图

在普通层序遍历的基础上，将入队顺序改为右孩子先入，再添加一个结果判断条件，只有在保证该元素是这一层最右边的元素时，才将其添加到结果列表。

题解

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Deque<TreeNode> deque = new ArrayDeque<>();
        if (root == null)
            return res;
        deque.offer(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = deque.poll();
                if (node.right != null)
                    deque.offer(node.right);
                if (node.left != null)
                    deque.offer(node.left);
                if (i == 0) {
                    res.add(node.val);
                }
            }
        }
        return res;
    }
}

637.二叉树的层平均值

题目

637. 二叉树的层平均值 - 力扣（LeetCode）

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

思路

代码随想录：637.二叉树的层平均值

层序遍历后求每一层平均值。

题解

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> res = new ArrayList<>();
        Deque<TreeNode> deque = new ArrayDeque<>();
        if (root == null)
            return res;
        deque.offer(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            double sum = 0.0;
            for (int i = 0; i < size; i++) {
                TreeNode node = deque.poll();
                if (node.left != null)
                    deque.offer(node.left);
                if (node.right != null)
                    deque.offer(node.right);
                sum += node.val;
            }
            res.add(sum / size);
        }
        return res;
    }
}

429.N叉树的层序遍历

题目

429. N 叉树的层序遍历 - 力扣（LeetCode）

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

示例1：

输入：root = [1,null,3,2,4,null,5,6]
输出：[[1],[3,2,4],[5,6]]

在这里插入图片描述

示例2：

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]

img

提示：

  • 树的高度不会超过 1000
  • 树的节点总数在 [0, 104] 之间

思路

代码随想录：429.N叉树的层序遍历

层序遍历时一个节点有多个孩子。

题解

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> res = new ArrayList<>();
        Deque<Node> deque = new ArrayDeque<>();
        if (root == null)
            return res;
        deque.offer(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                Node node = deque.poll();
                list.add(node.val);
                List<Node> children = node.children;
                //对列表使用增强for循环
                for (Node child : children) {
                    if (child != null)
                        deque.offer(child);
                }
            }
            res.add(list);
        }
        return res;
    }
}

515. 在每个树行中找最大值

题目

515. 在每个树行中找最大值 - 力扣（LeetCode）

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

示例1：

输入: root = [1,3,2,5,3,null,9]
输出: [1,3,9]

在这里插入图片描述

示例2：

输入: root = [1,2,3]
输出: [1,3]

提示：

  • 二叉树的节点个数的范围是 [0,104]
  • -231 <= Node.val <= 231 - 1

思路

代码随想录：515.在每个树行中找最大值

层序遍历，注意定义max时可以设置为 Integer.MIN_VALUE。

题解

class Solution {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Deque<TreeNode> deque = new ArrayDeque<>();
        if (root == null)
            return res;
        deque.offer(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            int max = Integer.MIN_VALUE;
            for (int i = 0; i < size; i++) {
                TreeNode node = deque.poll();
			   max = Math.max(max, node.val);
                if (node.left != null)
                    deque.offer(node.left);
                if (node.right != null)
                    deque.offer(node.right);
            }
            res.add(max);
        }
        return res;
    }
}

116. 填充每个节点的下一个右侧节点指针

题目

116. 填充每个节点的下一个右侧节点指针 - 力扣（LeetCode）

给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

示例1：

输入：root = [1,2,3,4,5,6,7]
输出：[1,#,2,3,#,4,5,6,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。

img

提示：

  • 树中节点的数量在 [0, 212 - 1] 范围内
  • -1000 <= node.val <= 1000

思路

代码随想录：116.填充每个节点的下一个右侧节点指针

常见的层序遍历。

题解

class Solution {
    public Node connect(Node root) {
        Deque<Node> deque = new ArrayDeque<>();
        if (root == null)
            return root;
        deque.offer(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            for (int i = 0; i < size; i++) {
                Node node = deque.poll();
                if (i < size - 1)
                    node.next = deque.peek();
                if (node.left != null)
                    deque.offer(node.left);
                if (node.right != null)
                    deque.offer(node.right);
            }
        }
        return root;
    }
}

117. 填充每个节点的下一个右侧节点指针 Ⅱ

题目

117. 填充每个节点的下一个右侧节点指针 II - 力扣（LeetCode）

给定一个二叉树：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL 。

初始状态下，所有 next 指针都被设置为 NULL 。

示例1：

输入：root = [1,2,3,4,5,null,7]
输出：[1,#,2,3,#,4,5,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化输出按层序遍历顺序（由 next 指针连接），'#' 表示每层的末尾。

在这里插入图片描述

提示：

  • 树中的节点数在范围 [0, 6000] 内
  • -100 <= Node.val <= 100

思路

代码随想录：117.填充每个节点的下一个右侧节点指针Ⅱ

完全一致：116. 填充每个节点的下一个右侧节点指针 - 力扣（LeetCode）

题解

class Solution {
    public Node connect(Node root) {
        Deque<Node> deque = new ArrayDeque<>();
        if (root == null)
            return root;
        deque.offer(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            for (int i = 0; i < size; i++) {
                Node node = deque.poll();
                if (i < size - 1)
                    node.next = deque.peek();
                if (node.left != null)
                    deque.offer(node.left);
                if (node.right != null)
                    deque.offer(node.right);
            }
        }
        return root;
    }
}

104.二叉树的最大深度

题目

104. 二叉树的最大深度 - 力扣（LeetCode）

给定一个二叉树 root ，返回其最大深度。

二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

示例1：

输入：root = [3,9,20,null,null,15,7]
输出：3

在这里插入图片描述

思路

代码随想录：104.二叉树的最大深度

此题除了层序遍历之外，还可以使用递归法。

树的深度等于左子树深度和右子树深度中的最大值+1。

  • 递归终止条件：当前节点为空

  • 找出返回值：节点为空时说明子树高度为 0，返回 0，节点不为空时则分别求左右子树的高度，取两者中的最大值加 1 表示当前节点的高度，返回该数值

题解

层序遍历：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 * int val;
 * TreeNode left;
 * TreeNode right;
 * TreeNode() {}
 * TreeNode(int val) { this.val = val; }
 * TreeNode(int val, TreeNode left, TreeNode right) {
 * this.val = val;
 * this.left = left;
 * this.right = right;
 * }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        int res = 0;
        Deque<TreeNode> deque = new ArrayDeque<>();
        if (root == null)
            return res;
        deque.offer(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = deque.poll();
                if (node.left != null)
                    deque.offer(node.left);
                if (node.right != null)
                    deque.offer(node.right);
            }
            res++;
        }
        return res;
    }
}

递归法：

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

111.二叉树的最小深度

题目

111. 二叉树的最小深度 - 力扣（LeetCode）

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明： 叶子节点是指没有子节点的节点。

示例1：

输入：root = [3,9,20,null,null,15,7]
输出：2

img

提示：

  • 树中节点数的范围在 [0, 105] 内
  • -1000 <= Node.val <= 1000

思路

代码随想录：111.二叉树的最小深度

层序遍历，当左右孩子都为空时才能说明遍历到最低点。

题解

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 * int val;
 * TreeNode left;
 * TreeNode right;
 * TreeNode() {}
 * TreeNode(int val) { this.val = val; }
 * TreeNode(int val, TreeNode left, TreeNode right) {
 * this.val = val;
 * this.left = left;
 * this.right = right;
 * }
 * }
 */
class Solution {
    public int minDepth(TreeNode root) {
        int res = 0;
        Deque<TreeNode> deque = new ArrayDeque<>();
        if (root == null)
            return res;
        deque.offer(root);
        res++;
        while (!deque.isEmpty()) {
            int size = deque.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = deque.poll();
                if (node.left == null && node.right == null)
                    return res;
                if (node.left != null)
                    deque.offer(node.left);
                if (node.right != null)
                    deque.offer(node.right);
            }
            res++;
        }
        return res;
    }
}

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

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

相关文章

计算机组成体系与组成结构错题解析【软考】

计算机组成体系与组成结构错题解析【软考】

目录 前言进制转换码制补码 CPU的组成输入/输出技术中断相关概念输入/输出技术的三种方式比较周期相关知识 主存编址计算流水线技术层次化存储体系可靠性 前言 本文专门用来记录本人在做软考中有关计算机上组成体系与组成结构的错题&#xff0c;我始终认为教学相长是最快提高的…
阅读更多...
0-1开发自己的obsidian plugin DAY 2

0-1开发自己的obsidian plugin DAY 2

今天上午解决了三个问题 1. typescript长得丑/一片飘红/格式检查太严格 在vscode的settings里搜索下面这个然后false掉&#xff1a; "typescript.validate.enable": false 就不会一片飘红了&#xff08;其他下载第三方插件如TSLint和typescript hero的方法都不好使&…
阅读更多...
众数信科 AI智能体政务服务解决方案——寻知智能审查系统

众数信科 AI智能体政务服务解决方案——寻知智能审查系统

政务服务解决方案 寻知智能审查方案 融合检察院起诉文书审查要求 能智能识别文书格式、内容缺失等错误 标记出不符合数百项监督提示点的内容 给出法律依据&#xff0c;正确率95% 3分钟助检察官完成起诉书审查 众数信科AI智能体 产品亮点 分析、理解行业知识和校验规则 A…
阅读更多...
828华为云征文 | 云服务器Flexus X实例，基于宝塔搭建Typecho博客平台

828华为云征文 | 云服务器Flexus X实例，基于宝塔搭建Typecho博客平台

828华为云征文 | 云服务器Flexus X实例&#xff0c;基于宝塔搭建Typecho博客平台 宝塔面板配置 华为云 Flexus X 实例购买 Flexus云服务器X实例-华为云 (huaweicloud.com) 1、下载宝塔面板&#xff0c;大约需要1~2分钟左右 yum install -y wget && wget -O install.sh…
阅读更多...
NVIDIA发布端到端自动驾驶框架Hydra-MDP

NVIDIA发布端到端自动驾驶框架Hydra-MDP

自动驾驶是目前人工智能领域的一个主要分支&#xff0c;目前特斯拉的FSD确实是为数不多的大模型框架。与其说特斯拉是一个造车公司&#xff0c;不如说是一个人工智能大数据公司。特斯拉每天靠行驶在道路上的汽车搜集的道路数据不胜其数&#xff0c;而拥有海量的数据是人工智能领…
阅读更多...
【MWORKS专业工具箱系列教程】控制系列工具箱第三期：控制系统连接与化简

【MWORKS专业工具箱系列教程】控制系列工具箱第三期：控制系统连接与化简

本工具箱教程以控制系统模型创建、分析与设计流程为主线&#xff0c;通过大量示例介绍MWORKS控制系统工具箱的功能和具体使用。共计10篇文章&#xff0c;上一篇主要介绍了控制系统模型转换。 同元软控&#xff1a;【MWORKS专业工具箱系列教程】控制系列工具箱第二期&#xff1…
阅读更多...
脚本注入网页:XSS

脚本注入网页:XSS

跨站脚本攻击&#xff08;Cross-Site Scripting&#xff0c;简称 XSS&#xff09;是一种常见的网络安全漏洞。它是指攻击者在网页中注入恶意脚本代码&#xff0c;当用户访问该网页时&#xff0c;恶意脚本会在用户的浏览器中执行&#xff0c;从而导致一系列安全问题。这些问题可…
阅读更多...
深入浅出热门AI大模型，新手到专家的必备指南《实战AI大模型》

深入浅出热门AI大模型，新手到专家的必备指南《实战AI大模型》

今天&#xff0c;人工智能技术的快速发展和广泛应用已经引起了大众的关注和兴趣&#xff0c;它不仅成为技术发展的核心驱动力&#xff0c;更是推动着社会生活的全方位变革。特别是作为AI重要分支的深度学习&#xff0c;通过不断刷新的表现力已引领并定义了一场科技革命。大型深…
阅读更多...
CTF夺旗赛经验总结及落地实践，零基础入门到精通，收藏这一篇就够了

CTF夺旗赛经验总结及落地实践，零基础入门到精通，收藏这一篇就够了

文章来源&#xff1a;绿盟科技博客。 中国是科技人才资源最多的国家之一&#xff0c;但也是人才流失比较严重的国家。世界各国已经把加强人才建设作为抢占网络空间制高点的战略举措。在此背景下&#xff0c;国内外各类CTF比赛越来越多&#xff0c;那么怎样一方面才能准备好比赛…
阅读更多...
MySQL之基本查询（一）（insert || select）

MySQL之基本查询（一）（insert || select）

目录 一、表的增删查改 二、表的增加insert 三、表的读取select where 条件子句 结果排序 筛选分页结果 一、表的增删查改 我们平时在使用数据库的时候&#xff0c;最重要的就是需要对数据库进行各种操作。而我们对数据库的操作一般来说也就是四个操作&#xff0c;CRUD :…
阅读更多...
鸿萌数据恢复：NAND 内存协议，SDR 与 DDR 之间的区别

鸿萌数据恢复：NAND 内存协议，SDR 与 DDR 之间的区别

天津鸿萌科贸发展有限公司从事数据安全服务二十余年&#xff0c;致力于为各领域客户提供专业的数据恢复、数据备份解决方案与服务&#xff0c;并针对企业面临的数据安全风险&#xff0c;提供专业的相关数据安全培训。 从事 NAND 数据恢复的人都知道&#xff0c;读取 NAND 需要使…
阅读更多...
企业有了ELT就不需要ETL了？别被忽悠了

企业有了ELT就不需要ETL了？别被忽悠了

最近几年,ELT(Extract, Load, Transform)这个词在数据圈里挺火。有些人甚至说,有了ELT,ETL(Extract, Transform, Load)就该退出历史舞台了。作为一个干了十多年ETL的老兵,我觉得有必要说道说道。 先说说这两个概念。ETL是先把数据抽取出来,经过处理转换后再加载到目标系统。EL…
阅读更多...
人工智能代表——无人驾驶：萝卜快跑

人工智能代表——无人驾驶：萝卜快跑

人工智能如何改变我们的出行&#xff1a;以“萝卜快跑”无人驾驶为例 随着科技的飞速发展&#xff0c;人工智能&#xff08;AI&#xff09;正以前所未有的方式渗透并改变着我们的日常生活&#xff0c;其中出行方式的变革尤为显著。在众多AI驱动的出行创新中&#xff0c;“萝卜…
阅读更多...
OpenMV学习第一步安装IDE_2024.09.20

OpenMV学习第一步安装IDE_2024.09.20

用360浏览器访问星瞳科技官网&#xff0c;一直提示访问不了。后面换了IE浏览器就可以访问。第一个坑。
阅读更多...
2. 程序结构

2. 程序结构

在本章中&#xff0c;我们将开始做一些真正称得上编程的事情。我们将扩展对 JavaScript 语言的掌握&#xff0c;不再局限于目前所见的名词和句子片段&#xff0c;而是能够表达有意义的散文。 表达式和语句 在第 1 章中&#xff0c;我们创建了值&#xff0c;并应用运算符来获取…
阅读更多...
【Python报错已解决】NameError: name ‘F‘ is not defined

【Python报错已解决】NameError: name ‘F‘ is not defined

&#x1f3ac; 鸽芷咕&#xff1a;个人主页 &#x1f525; 个人专栏: 《C干货基地》《粉丝福利》 ⛺️生活的理想&#xff0c;就是为了理想的生活! 专栏介绍 在软件开发和日常使用中&#xff0c;BUG是不可避免的。本专栏致力于为广大开发者和技术爱好者提供一个关于BUG解决的经…
阅读更多...
《百家姓》中排名第八却是中国人口第一大姓-王姓

《百家姓》中排名第八却是中国人口第一大姓-王姓

王姓在《百家姓》中虽然排名第八&#xff0c;但根据近年来的统计数据和实际人口分布&#xff0c;王姓已成为中国第一大姓。以下是对王姓作为“百家姓之首”的详细解析&#xff1a; 一、人口数量与分布 人口数量&#xff1a;截至当前时间&#xff08;2024年&#xff09;&#x…
阅读更多...
打破网络安全域限制：跨区域文件传输的创新解决方案

打破网络安全域限制：跨区域文件传输的创新解决方案

随着经济的快速发展&#xff0c;很多企业在异地都会建立分支机构&#xff0c;比如跨国企业在国外建设分公司&#xff0c;金融机构全国各地都有多级分支机构和网点&#xff0c;集团型企业会设立多家子公司等等。 跨网络安全域文件交换&#xff0c;是大型企业会存在的跨区域文件传…
阅读更多...
项目记录点

项目记录点

MES项目点 一、项目局域网访问地址创建 host: 0.0.0.0,二、select下拉表单内容 1、默认值设置为undefined&#xff0c;placeholder才生效 <a-col :sm"24" :md"12" :xl"6"><a-form-itemname"opeCodeList":rules"[{requ…
阅读更多...
Pinia从安装到使用

Pinia从安装到使用

什么是Pinia 添加Pinia到vue项目 使用Pinia实现计数器案例 counter.js import {defineStore} from "pinia"; import {ref} from "vue";export const useCounterStore defineStore(coutner,()>{//定义数据&#xff08;state&#xff09;const count r…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023