二叉树习题其一Java【力扣】【算法学习day.8】

news2024/10/25 2:47:16

前言

书接上篇文章介绍的链表基础知识—>二叉树理论，这篇文章我们将通过习题来掌握哈希表的使用。

###我做这类文档一个重要的目的还是给正在学习的大家提供方向（例如想要掌握基础用法，该刷哪些题？）我的解析也不会做的非常详细，只会提供思路和一些关键点，力扣上的大佬们的题解质量是非常非常高滴！！

共勉！

习题【力扣】

1.二叉树的前序遍历

ps:建议写之前把这篇文章啃完->二叉树的遍历

题目链接：144. 二叉树的前序遍历 - 力扣（LeetCode）

题面:

由于这些都是模版死东西，且上面给出了一个大佬的帖子链接方便理解，所以这题和下面两题就不分析了

递归实现代码：

/**
 * 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 List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        recursion(root,list);
        return list;
    }

    public void recursion(TreeNode node, List<Integer> list){
        if(node==null)return;
        list.add(node.val);
        recursion(node.left,list);
         recursion(node.right,list);
    }
}

迭代实现代码:

/**
 * 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 List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()&&root!=null){
           TreeNode node = stack.pop();
            list.add(node.val);
            if(node.right!=null)stack.push(node.right);
            if(node.left!=null)stack.push(node.left);
        }
        return list;
    }
}

2.二叉树的中序遍历

题目链接:94. 二叉树的中序遍历 - 力扣（LeetCode）

题面:

递归代码：

/**
 * 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 List<Integer> inorderTraversal(TreeNode root) {
         List<Integer> list = new ArrayList<>();
         recursion(root,list);
         return list;
    }

    public void recursion(TreeNode node,List<Integer> list){
        if(node==null)return;
        if(node.left!=null)recursion(node.left,list);
        list.add(node.val);
        if(node.right!=null)recursion(node.right,list);
    }

}

迭代代码:

/**
 * 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 List<Integer> inorderTraversal(TreeNode root) {
         List<Integer> list = new ArrayList<>();
         Stack<TreeNode> stack = new Stack<>();
         while(root!=null||!stack.isEmpty()){
            while(root!=null){
                stack.push(root);
                root = root.left;
            }
           TreeNode node = stack.pop();
           list.add(node.val);
           if(node.right!=null){
            root = node.right;
             }
         } 
         return list;
    }
}

 3.二叉树的后序遍历

题目链接：145. 二叉树的后序遍历 - 力扣（LeetCode）

题面:

 递归代码:

/**
 * 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 List<Integer> postorderTraversal(TreeNode root) {
         List<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        recursion(root,list);
        return list;
    }
    public void recursion(TreeNode node,List<Integer> list){
        if(node==null)return;
        if(node.left!=null)recursion(node.left,list);
        if(node.right!=null)recursion(node.right,list);
        list.add(node.val);
    }
}

迭代代码:

/**
 * 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 List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if(root==null)return list;
        Stack<TreeNode> stack1 = new Stack<>();
        Stack<TreeNode> stack2 = new Stack<>();
        stack1.push(root);
        while(!stack1.isEmpty()){
            TreeNode node = stack1.pop();
            stack2.push(node);
            if(node.left!=null)stack1.push(node.left);
             if(node.right!=null)stack1.push(node.right);
        }
        while(!stack2.isEmpty()){
            list.add(stack2.pop().val);
        }
        return list;
    }
}

4.翻转二叉树

题目链接:226. 翻转二叉树 - 力扣（LeetCode） 

题面:

基本分析:递归，交换两个子节点即可

代码:

/**
 * 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 TreeNode invertTree(TreeNode root) {
        Stack<Integer> stack = new Stack<>();
        recursion(root);
        return root;
    }
    public void recursion(TreeNode node){
       if(node==null)return;
       TreeNode flag = node.left;
       node.left = node.right;
       node.right = flag;
       recursion(node.left);
       recursion(node.right);
    }
}

5.N叉树的前序遍历

题目链接:589. N 叉树的前序遍历 - 力扣（LeetCode）

题面:

基本分析:和二叉树的前序遍历一样，只不过把左右节点遍历改成了循环遍历

/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
    public List<Integer> preorder(Node root) {
        List<Integer> list = new ArrayList<>();
        if(root==null)return list;
        Stack<Node> stack = new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            Node node = stack.pop();
            list.add(node.val);
            if(node.children!=null){
                 for (int i =node.children.size()-1; i>=0; i--) {
                   stack.push(node.children.get(i));
             }
            }
        }
        return list;
    }
}
    // public void recursion(Node node, List<Integer> list){
    //     if(node==null)return;
    //     list.add(node.val);
    //      for (int i =0; i<node.children.size(); i++) {
    //         recursion(node.children.get(i),list);
    //     }
    // }
    // }

6.N叉树的后序遍历

题目链接:590. N 叉树的后序遍历 - 力扣（LeetCode）

题面:

基本分析:和二叉树的后序遍历一样，只不过把左右节点遍历改成了循环遍历 

/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
}
*/

class Solution {
    public List<Integer> postorder(Node root) {
        List<Integer> list = new ArrayList<>();
        if (root == null)return list;
        Stack<Node> stack1 = new Stack<>();
        // recursion(root,list);
        Stack<Node> stack2 = new Stack<>();
        stack1.push(root);
        while (!stack1.isEmpty()) {
            System.out.println(1);
            Node node = stack1.pop();
            stack2.push(node);
            for (int i = 0; i<node.children.size(); i++) {
                stack1.push(node.children.get(i));
            }
        }
        while(!stack2.isEmpty())list.add(stack2.pop().val);
        return list;

    }

    // public void recursion(Node node,List<Integer> list){
    // if(node==null)return;
    // if(node.children.size()!=0){
    // for(int i = 0;i<node.children.size();i++){
    // recursion(node.children.get(i),list);
    // }
    // }
    // list.add(node.val);
    // }
}

7.对称二叉树

题目链接:101. 对称二叉树 - 力扣（LeetCode）

题面:

基本分析:就是变样的中序遍历二叉树，遍历过程中注意下一层的节点顺序和比较

代码:

/**
 * 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 boolean isSymmetric(TreeNode root) {
        if(root.left==null&&root.right==null)return true;
       return resursion(root.left,root.right);
    }
    public boolean resursion(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;
       boolean bool1 =  resursion(left.left,right.right);
       boolean bool2 =  resursion(left.right,right.left);
       return bool1&&bool2;
    }
}

8. 相同的树

题面链接:100. 相同的树 - 力扣（LeetCode）

题面: 

基本分析：相较于第七题，只不过是改成两个树了

代码:

/**
 * 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 boolean isSameTree(TreeNode p, TreeNode q) {
        if(p==null&&q==null)return true;
        if(p==null||q==null)return false;
        if(p.val!=q.val)return false;
        return recursion(p.left,q.left)&&recursion(p.right,q.right);
    }
    public boolean recursion(TreeNode left,TreeNode right){
        if(left==null&&right==null) return true;
        if(left==null||right==null) return false;
        boolean bool1 = recursion(left.left,right.left)||false;
        boolean bool2 = recursion(left.right,right.right)||false;
        // if(left.val!=right.val)return false;
        // if(left.val==right.val)return true;
        return bool1&&bool2&&left.val==right.val;
    }
}

9.另一棵树的子树

题目链接:572. 另一棵树的子树 - 力扣（LeetCode）

题面：

基本分析：我写了两个递归函数，一个用来找相同的根节点，一个用来判断以此延伸下去是否是同一个树，看我的可能你能更好理解，但是我会在下面贴上大佬的代码

代码:

/**
 * 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 boolean isSubtree(TreeNode root, TreeNode subRoot) {
        if(root==null&&subRoot==null){
            return true;
        }
        if(root==null||subRoot==null){
            return false;
        }
        if(root.val!=subRoot.val&&(root.left==null&&root.right==null)){
            return false;
        }
        if(root.val==subRoot.val&&(root.left==null&&root.right==null)){
            return true;
        }
        return recursion1(root,subRoot)||false;
    }
    public boolean recursion1(TreeNode node,TreeNode subRoot){
        if(node==null){
            return false;
        }
        if(node.val==subRoot.val){
            boolean bool1 =  recursion2(node.left,subRoot.left);
            boolean bool2 =  recursion2(node.right,subRoot.right);
            if(bool1&&bool2){
                return true;
            }
        }
        return recursion1(node.left, subRoot)||recursion1(node.right, subRoot);
    }

    public boolean recursion2(TreeNode node1,TreeNode node2){
        if(node1==null&&node2==null){
            return true;
        }
        if(node1==null||node2==null){
            return false;
        }
        boolean bool1 =  recursion2(node1.left,node2.left);
        boolean bool2 =  recursion2(node1.right,node2.right);
        return bool1&&bool2&&node1.val==node2.val;
    }
}
// /**
//  * 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 boolean isSubtree(TreeNode s, TreeNode t) {
        if (t == null) return true;   // t 为 null 一定都是 true
        if (s == null) return false;  // 这里 t 一定不为 null, 只要 s 为 null，肯定是 false
        return isSubtree(s.left, t) || isSubtree(s.right, t) || isSameTree(s,t);
    }

    /**
     * 判断两棵树是否相同
     */
    public boolean isSameTree(TreeNode s, TreeNode t){
        if (s == null && t == null) return true;
        if (s == null || t == null) return false;
        if (s.val != t.val) return false;
        return isSameTree(s.left, t.left) && isSameTree(s.right, t.right);
    }
}

10. 二叉树的最大深度

题目链接:104. 二叉树的最大深度 - 力扣（LeetCode）

题面:

基本分析:维护一个max，用来记录最大值 

/**
 * 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) {
        if(root==null)return 0;
       return recursion(root,1,1);
    }
    public int recursion(TreeNode node,int count,int max){
        if(node==null)return max;
        max = Math.max(recursion(node.left,count+1,max),max);
        max = Math.max(recursion(node.right,count+1,max),max);
        max = Math.max(count,max);
        return max;
    }
}

11.二叉树的最小深度

题目链接:111. 二叉树的最小深度 - 力扣（LeetCode）

题面：

基本分析： 维护一个min，在递归到下一层无子节点时就更新min。

代码：

/**
 * 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) {
        if(root==null){
            return 0;
        }
        return recursion(root,1,Integer.MAX_VALUE);
    }

     public int recursion(TreeNode node,int count,int min){
       if(node.left!=null){
        min = Math.min(min,recursion(node.left,count+1,min));
       } 
       if(node.right!=null){
        min = Math.min(min,recursion(node.right,count+1,min));
       }
        if(node.left==null&&node.right==null){
           return min = count;
        }
        return min;
     }
}

后言

上面是二叉树的部分习题，下一篇会讲解二叉树的其他相关力扣习题，希望有所帮助，一同进步，共勉！ 

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

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

相关文章

PHP多功能图片编辑器

PHP多功能图片编辑器

PHP多功能图片编辑器 前言效果图功能说明平台支持情况部分源码领取源码下期更新 前言 PHP多功能图片编辑器 工具箱网站源码无需数据库上传即用&#xff0c;测试了一下还可以&#xff0c;免费分享自行研究。 效果图 功能说明 ✓ 无需上传&#xff0c;使用浏览器自身进行转换 …
阅读更多...
049_python基于Python的热门微博数据可视化分析

049_python基于Python的热门微博数据可视化分析

目录 系统展示 开发背景 代码实现 项目案例 获取源码 博主介绍&#xff1a;CodeMentor毕业设计领航者、全网关注者30W群落&#xff0c;InfoQ特邀专栏作家、技术博客领航者、InfoQ新星培育计划导师、Web开发领域杰出贡献者&#xff0c;博客领航之星、开发者头条/腾讯云/AW…
阅读更多...
多模态大语言模型（MLLM）-Deepseek Janus

多模态大语言模型（MLLM）-Deepseek Janus

论文链接&#xff1a;https://arxiv.org/abs/2410.13848 代码链接&#xff1a;https://github.com/deepseek-ai/Janus 本次解读Janus: Decoupling Visual Encoding for Unified Multimodal Understanding and Generation 前言 Deepseek出品&#xff0c;必属精品。 创新点 传…
阅读更多...
如何在Java应用中发送短信

如何在Java应用中发送短信

很多业务场景里&#xff0c;我们都需要发送短信&#xff0c;比如登陆验证码、告警、营销通知、节日祝福等等。 这篇文章&#xff0c;我们聊聊 Java 应用中如何优雅的发送短信。 1 客户端/服务端两种模式 Java 应用中发送短信通常需要使用短信服务提供商提供的短信 API 。 我…
阅读更多...
多ip访问多网站

多ip访问多网站

多IP访问多网站 1.预配操作 [rootlocalhost ~]# mount /dev/sr0 /mnt mount: /mnt: WARNING: source write-protected, mounted read-only. [rootlocalhost ~]# systemctl stop firewalld ----------关闭防火墙 [rootlocalhost ~]# setenforce 0 -------关闭selinux2.安装n…
阅读更多...
技术人员的自我修炼：在变化中成长

技术人员的自我修炼：在变化中成长

引言 在技术的海洋中&#xff0c;我们每个人都是一名探索者&#xff0c;不断学习、适应、成长。作为一名技术人员&#xff0c;我们不仅要面对自身技能的提升和心态的调整&#xff0c;还要应对外部环境的不断变化。本文将探讨技术人员如何在内部修炼和外部适应中找到平衡&#…
阅读更多...
UE5 喷射背包

UE5 喷射背包

首选创建一个输入操作 然后在输入映射中添加&#xff0c;shift是向上飞&#xff0c;ctrl是向下飞 进入人物蓝图中编写逻辑&#xff0c;变量HaveJatpack默认true&#xff0c;Thrust为0 最后
阅读更多...
【C语言】编译和链接（编译环境和运行环境）

【C语言】编译和链接（编译环境和运行环境）

文章目录 一、翻译环境和运行环境二、翻译环境1.编译预处理编译汇编 2.链接 四、运行环境 一、翻译环境和运行环境 在 ANSI C 的任何⼀种实现中&#xff0c;存在两个不同的环境&#xff0c;如下&#xff1a; 翻译环境&#xff1a;在翻译环境中&#xff0c;会通过编译和链接两个…
阅读更多...
鸿蒙软件开发中常见的如何快速自动生成二维码？QRCode组件

鸿蒙软件开发中常见的如何快速自动生成二维码？QRCode组件

QRCode 用于显示单个二维码的组件。 说明&#xff1a; 该组件从API Version 7开始支持。后续版本如有新增内容&#xff0c;则采用上角标单独标记该内容的起始版本。 二维码组件的像素点数量与内容有关&#xff0c;当组件尺寸过小时&#xff0c;可能出现无法展示内容的情况&…
阅读更多...
在 Controller 层对系统作防御性编程

在 Controller 层对系统作防御性编程

简介 Web 开发中无论是 MVC 还是 DDD 架构 Controller 层都是系统的门面&#xff0c;既对外的接口&#xff0c;对内的接口&#xff0c;一般情况下任何错误必须组织在 Controller 层 如何作 在 Controller 层中的接口使用 try-catch Slf4j RestController("/") Re…
阅读更多...
MobileNetV2实现实时口罩检测tensorflow

MobileNetV2实现实时口罩检测tensorflow

项目源码获取方式见文章末尾&#xff01; 回复暗号&#xff1a;13&#xff0c;免费获取600多个深度学习项目资料&#xff0c;快来加入社群一起学习吧。 **《------往期经典推荐------》**项目名称 1.【Informer模型复现项目实战】 2.【卫星图像道路检测DeepLabV3Plus模型】 3.【…
阅读更多...
[LeetCode] 230. 二叉搜索树中第K小的元素

[LeetCode] 230. 二叉搜索树中第K小的元素

题目描述&#xff1a; 给定一个二叉搜索树的根节点 root &#xff0c;和一个整数 k &#xff0c;请你设计一个算法查找其中第 k 小的元素&#xff08;从 1 开始计数&#xff09;。 示例 1&#xff1a; 输入&#xff1a;root [3,1,4,null,2], k 1 输出&#xff1a;1示例 2&am…
阅读更多...
《计算机视觉》—— 基于 dlib 库的方法将两张人脸图片进行换脸

《计算机视觉》—— 基于 dlib 库的方法将两张人脸图片进行换脸

声明&#xff1a;此篇文章所用的明星照片只为用于演示代码的效果&#xff0c;无诋毁她人肖像之意 一、案例实现的思想 此案例的核心是基于人脸68个关键点检测模型来实现的&#xff0c;人脸68个关键带点检测后的效果如下&#xff1a; 通过对上图中红色区域的转换&#xff0c;…
阅读更多...
项目管理必备：如何快速创建项目交付时间表

项目管理必备：如何快速创建项目交付时间表

“不做准备&#xff0c;就准备失败”。项目的成功很大程度上取决于前期规划的充分性和质量。 项目交付时间表是项目管理中一个重要的工具&#xff0c;通过将项目分解为可管理的区块来组织工作。该方法使管理者可以创建分步的工作路径&#xff0c;并展示项目的宏观视图&#xff…
阅读更多...
诺贝尔颁给AI啦，没想到高性能计算CHPC也发力了！

诺贝尔颁给AI啦，没想到高性能计算CHPC也发力了！

诺贝尔化学奖垂青 AlphaFold 3 2020 年 12 月&#xff0c;AlphaFold 2 发布。相较于之前实验成本高、耗时长、蛋白质结构解析困难的传统方法&#xff0c;AlphaFold 2 可以通过深度学习技术&#xff0c;仅需几小时就能准确地预测蛋白质的三维结构&#xff0c;极大地加速了生物…
阅读更多...
基于Multisim的水位测量电路设计与仿真

基于Multisim的水位测量电路设计与仿真

1.利用LED指示灯显示水位&#xff08;最低水位、1/4、1/2、3/4、最高水位&#xff09;。 2.达到最高水位时&#xff0c;自动报警。
阅读更多...
uiautomatorviewer安卓9以上正常使用及问题处理

uiautomatorviewer安卓9以上正常使用及问题处理

一、安卓9以上使用uiautomatorviewer问题现象 打开Unexpected error while obtaining UI hierarchy 问题详情 Unexpected error while obtaining UI hierarchy java.lang.reflect.InvocationTargetException 二、问题处理 需要的是替换对应D:\software\android-sdk-windows…
阅读更多...
AI自动生成PPT哪个软件好？智能生成PPT不再熬夜做课件

AI自动生成PPT哪个软件好？智能生成PPT不再熬夜做课件

大概这世上&#xff0c;都是职场牛马对“PPT”这三个字母的头痛反应最大吧&#xff01; 是的&#xff0c;就连各个年级段的老师也是很头痛——愁着怎样能在排版整齐的情况下&#xff0c;将必考知识点都呈现在PPT每一张幻灯片页面里...... 近期打听到用人工智能生成ppt课件&am…
阅读更多...
域渗透相关内网 或 域AD环境搭建 域环境收集方式方法命令 查看 检测域控主机或者域内主机是否安装杀软方式

域渗透相关内网 或 域AD环境搭建 域环境收集方式方法命令 查看 检测域控主机或者域内主机是否安装杀软方式

目录 域基础知识点知道这些就可以了 域 域的优点以及作用 域控 活动目录 活动目录主要功能 域环境搭建操作步骤: 域环境信息收集 信息收集工具 服务端客户端启动方式 CS操作部分 进行信息收集 信息收集操作 域基础知识点知道这些就可以了 域 域模型就是针对大…
阅读更多...
MySQL——数据库

MySQL——数据库

什么是数据库 数据库&#xff08;DB , DataBase&#xff09;概念&#xff1a;数据仓库&#xff0c;软件&#xff0c;安装在操作系统&#xff08;window&#xff0c;linux&#xff0c;max&#xff0c;...&#xff09;之上学习数据库最重要的就是学习SQL语句存储500万以下的数据…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023