LeetCode——二叉树（Java）

news2024/11/27 10:32:18

二叉树

  • 简介
  • [简单] 144. 二叉树的前序遍历、94. 二叉树的中序遍历、145. 二叉树的后序遍历
  • 二叉树层序遍历
    • [中等] 102. 二叉树的层序遍历
    • [中等] 107. 二叉树的层序遍历 II
    • [中等] 199. 二叉树的右视图
    • [简单] 637. 二叉树的层平均值
    • [中等] 429. N 叉树的层序遍历
    • [中等] 515. 在每个树行中找最大值
    • [中等] 116. 填充每个节点的下一个右侧节点指针、[中等]117. 填充每个节点的下一个右侧节点指针 II
    • [简单] 104. 二叉树的最大深度
    • [简单] 111. 二叉树的最小深度
  • [简单] 226. 翻转二叉树
  • [简单] 101. 对称二叉树
  • [简单] 100. 相同的树
  • [简单] 572. 另一棵树的子树
  • [简单] 222. 完全二叉树的节点个数
  • [简单] 110. 平衡二叉树
  • [简单] 257. 二叉树的所有路径
  • [简单] 404. 左叶子之和
  • [中等] 513. 找树左下角的值

简介

记录一下自己刷题的历程以及代码。写题过程中参考了 代码随想录的刷题路线。会附上一些个人的思路，如果有错误，可以在评论区提醒一下。
涉及：二叉树前中后序遍历、层序遍历、队列Queue、头插法、递归、ArrayList、LinkedList、递归、StringBuilder

[简单] 144. 二叉树的前序遍历、94. 二叉树的中序遍历、145. 二叉树的后序遍历

144. 二叉树的前序遍历
94. 二叉树的中序遍历
145. 二叉树的后序遍历

前中后序遍历可以公用一套递归思路，都是比较经典的模板：

//先序遍历
递归访问(){
    对节点做操作
    递归访问(左子树)
    递归访问(右子树)
}

//中序遍历
递归访问(){
    递归访问(左子树)
    对节点做操作
    递归访问(右子树)
}

//后序遍历
递归访问(){
    递归访问(左子树)
    递归访问(右子树)
    对节点做操作
}
  1. 二叉树的前序遍历
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> answer = new ArrayList<>();
        preorder(root, answer);
        return answer;
    }

    public void preorder(TreeNode root, List<Integer> answer){
        if(root == null) return;
        answer.add(root.val);
        preorder(root.left,answer);
        preorder(root.right,answer);
        return;
    }
}
  1. 二叉树的中序遍历
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> answer = new ArrayList<>();
        inorder(root, answer);
        return answer;
    }

    public void inorder(TreeNode root, List<Integer> answer){
        if(root == null) return;
        inorder(root.left,answer);
        answer.add(root.val);
        inorder(root.right,answer);
        return;
    }
}
  1. 二叉树的后序遍历
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> answer = new ArrayList<>();
        postorder(root, answer);
        return answer;
    }

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

二叉树层序遍历

[中等] 102. 二叉树的层序遍历

原题链接

经典的BFS
用队列保存树节点，每次统计队列的size()，也就是第n层节点数量。
处理这一层的节点，将其子节点全部加入队列，循环往复到队列为空。

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> ans = new ArrayList<List<Integer>>();
        Queue<TreeNode> queue = new ArrayDeque<>();
        if(root == null) return ans;
        queue.add(root);
        while(!queue.isEmpty()){
            List<Integer> nums = new ArrayList<Integer>();
            int k = queue.size();
            while(k-- > 0) {
                TreeNode temp = queue.remove();
                nums.add(temp.val);
                if (temp.left != null) queue.add(temp.left);
                if (temp.right != null) queue.add(temp.right);
            }
            ans.add(nums);
        }
        return ans;
    }
}

[中等] 107. 二叉树的层序遍历 II

原题链接

方法①：
与102的最基本的层序遍历相似的逻辑，使用递归的方法把每次ans.add(nums);操作顺序进行了倒序。

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> ans = new ArrayList<List<Integer>>();
        Queue<TreeNode> queue = new ArrayDeque<>();
        if(root == null) return ans;
        queue.add(root);
        recursion(queue, ans);
        return ans;
    }

    public void recursion(Queue<TreeNode> queue, List<List<Integer>> ans){
        if(!queue.isEmpty()){
            List<Integer> nums = new ArrayList<Integer>();
            int k = queue.size();
            while(k-- > 0) {
                TreeNode temp = queue.remove();
                nums.add(temp.val);
                if (temp.left != null) queue.add(temp.left);
                if (temp.right != null) queue.add(temp.right);
            }
            recursion(queue, ans);
            ans.add(nums);
        }
        return;
    }
}

方法②：
使用LinkedList，用头插法的方式构造返回值。（LinkedList底层为链表，头插法比较方便，ArrayList底层是连续存储，头插法复杂度为O(n)）

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> ans = new LinkedList<>();
        Queue<TreeNode> queue = new ArrayDeque<>();
        if(root == null) return ans;
        queue.add(root);
        while(!queue.isEmpty()){
            List<Integer> nums = new ArrayList<Integer>();
            int k = queue.size();
            while(k-- > 0) {
                TreeNode temp = queue.remove();
                nums.add(temp.val);
                if (temp.left != null) queue.add(temp.left);
                if (temp.right != null) queue.add(temp.right);
            }
            ans.add(0, nums);
        }
        return ans;
    }

}

[中等] 199. 二叉树的右视图

原题链接

与102的最基本的层序遍历相似的逻辑，构建返回值时每次只把当前层最右边的数加入ans即可。

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> ans = new ArrayList<Integer>();
        Queue<TreeNode> queue = new ArrayDeque<>();
        if(root == null) return ans;
        queue.add(root);
        while(!queue.isEmpty()){
            List<Integer> nums = new ArrayList<Integer>();
            int k = queue.size();
            while(k-- > 0) {
                TreeNode temp = queue.remove();
                nums.add(temp.val);
                if (temp.left != null) queue.add(temp.left);
                if (temp.right != null) queue.add(temp.right);
            }
            ans.add((nums.get(nums.size()-1)));
        }
        return ans;
    }
}

[简单] 637. 二叉树的层平均值

原题链接

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        Queue<TreeNode> queue = new ArrayDeque<>();
        List<Double> ans = new ArrayList<>();
        if(root == null) return ans;
        queue.add(root);
        while(!queue.isEmpty()){
            double num = 0;
            int k = queue.size();
            int i = k;
            while(k-- > 0){
                TreeNode temp = queue.remove();
                num += temp.val;
                if(temp.left != null) queue.add(temp.left);
                if(temp.right != null) queue.add(temp.right);
            }
            ans.add(num / i);
        }
        return ans;
    }
}

[中等] 429. N 叉树的层序遍历

原题链接

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> ans = new ArrayList<List<Integer>>();
        Queue<Node> queue = new ArrayDeque<>();
        if(root == null) return ans;
        queue.add(root);
        while(!queue.isEmpty()){
            List<Integer> nums = new ArrayList<Integer>();
            int k = queue.size();
            while(k-- > 0) {
                Node temp = queue.remove();
                nums.add(temp.val);
                for(int i = 0; i < temp.children.size(); i++) {
                    queue.add(temp.children.get(i));
                }
            }
            ans.add(nums);
        }
        return ans;
    }
}

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

原题链接

class Solution {
    public List<Integer> largestValues(TreeNode root) {
       List<Integer> ans = new ArrayList<>();
        Queue<TreeNode> queue = new ArrayDeque<>();
        if(root == null) return ans;
        queue.add(root);
        while(!queue.isEmpty()){
            int max = queue.peek().val;
            int k = queue.size();
            while(k-- > 0) {
                TreeNode temp = queue.remove();
                max = max > temp.val ? max : temp.val;
                if(temp.left != null) queue.add(temp.left);
                if(temp.right != null) queue.add(temp.right);
            }
            ans.add(max);
        }
        return ans;
    }
}

[中等] 116. 填充每个节点的下一个右侧节点指针、[中等]117. 填充每个节点的下一个右侧节点指针 II

[中等] 116. 填充每个节点的下一个右侧节点指针
[中等]117. 填充每个节点的下一个右侧节点指针 II
方法①：
正常的层序遍历，每层除了最后一个节点之外都对next赋值

class Solution {
    public Node connect(Node root) {
       List<Integer> ans = new ArrayList<>();
        Queue<Node> queue = new ArrayDeque<>();
        if(root == null) return root;
        queue.add(root);
        while(!queue.isEmpty()){
            int k = queue.size();
            while(k-- > 0) {
                Node temp = queue.remove();
                if(k > 0) {
                    temp.next = queue.peek();
                }
                if(temp.left != null) queue.add(temp.left);
                if(temp.right != null) queue.add(temp.right);
            }
            
        }
        return root;
    }
}

方法②：
使用next链接来对同层次节点做遍历，可以省去队列的开销
注意Node引用需要申请在方法外，不能做参数传递，java中都是值传递

class Solution {
    Node last = null, nextStart = null;
    public Node connect(Node root) {
        List<Integer> ans = new ArrayList<>();
        if(root == null) return root;

        Node p = root;
        while(p!=null){
            if(p.left != null){
                handle(p.left);
            }
            if(p.right != null){
                handle(p.right);
            }
            p = p.next;
            if(p == null && nextStart != null){
                p = nextStart;
                nextStart = null;
                last = null;
            }
        }
        return root;
    }

    public void handle(Node p){
        if(nextStart == null){
            nextStart = p;
        }
        if(last != null){
            last.next = p;
        }
        last = p;
    }

}

[简单] 104. 二叉树的最大深度

原题链接

方法①：层序遍历

class Solution {
    public int maxDepth(TreeNode root) {
        int depth = 0;
        if(root == null) return depth;
        Queue<TreeNode> queue = new ArrayDeque<>();
        queue.add(root);
        while(!queue.isEmpty()){
            depth++;
            int k = queue.size();
            while(k-- > 0) {
                TreeNode temp = queue.remove();
                if (temp.left != null) queue.add(temp.left);
                if (temp.right != null) queue.add(temp.right);
            }
        }
        return depth;
    }
}

方法②：递归
树的高度就是 其子树的最大高度 + 1，用在多叉树上也是一样的思路

class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null) return 0;
        int leftDepth = maxDepth(root.left);
        int rightDepth = maxDepth(root.right);
        return (leftDepth > rightDepth ? leftDepth : rightDepth) + 1;
    }
}

[简单] 111. 二叉树的最小深度

原题链接
方法①：层序遍历找左右子树皆空的点即可

class Solution {
    public int minDepth(TreeNode root) {
        int depth = 0;
        if(root == null) return depth;
        Queue<TreeNode> queue = new ArrayDeque<>();
        queue.add(root);
        while(!queue.isEmpty()){
            depth++;
            int k = queue.size();
            while(k-- > 0) {
                TreeNode temp = queue.remove();
                if(temp.left == null && temp.right == null) return depth;
                if (temp.left != null) queue.add(temp.left);
                if (temp.right != null) queue.add(temp.right);
            }
        }
        return depth;
    }
}

方法②：递归求解
用递归求解记住需要的是到叶子节点的深度
如果非叶子节点，假设只有单边左子树，右子数应当是找不到叶子节点也就是距离无穷大，可以设置一个Integer.MAX_VALUE做为返回值，这样通过比较，递归的上一层就会获得左子树找到叶子节点的最小距离 + 1

class Solution {
    public int minDepth(TreeNode root) {
        if(root == null) return 0;
        if(root.left == null && root.right == null) return 1;
        int leftMin = Integer.MAX_VALUE;
        int rightMin = Integer.MAX_VALUE;
        if(root.left != null) leftMin = minDepth(root.left);
        if(root.right != null) rightMin = minDepth(root.right);
        return (leftMin < rightMin ? leftMin : rightMin) + 1;
    }
}

[简单] 226. 翻转二叉树

原题链接

前序遍历的基础上每一次遍历节点做翻转操作。
切记前序、后续、层次遍历都可以，但是不可以是中序遍历，因为中序遍历是左 中 右 的顺序，递归调整左子树之后，处理当前节点会把左右子树对调，这样进入右子数递归时其实还是对原先的左子树做操作。

class Solution {
    public TreeNode invertTree(TreeNode root) {
        preorder(root);
        return root;
    }

    public void preorder(TreeNode root){
        if(root == null) return;
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
        preorder(root.left);
        preorder(root.right);
        return;
    }
}

[简单] 101. 对称二叉树

原题链接

经典的递归思路，对左右子树做反方向的递归即可，在左子树上做前序遍历，每次递归left的左节点时就去递归right的右节点，递归left的右节点时则递归right的左节点。

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

    public boolean recursion(TreeNode left, TreeNode right){
        if(left == null && right == null)
            return true;
        else if(left != null && right != null) {
            if (left.val != right.val)
                return false;
            if (recursion(left.left, right.right) && recursion(left.right, right.left))
                return true;
        }
        return false;
    }
}

[简单] 100. 相同的树

原题链接

两棵树同频做前序遍历即可，其他遍历方式也是ok的。

class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        return recursion(p, q);
    }

    public boolean recursion(TreeNode p, TreeNode q){
        if(p == null && q == null)
            return true;
        else if(p != null && q != null) {
            if (p.val != q.val)
                return false;
            if (recursion(p.left, q.left) && recursion(p.right, q.right))
                return true;
        }
        return false;
    }
}

[简单] 572. 另一棵树的子树

原题链接

两层递归
①preorder：对root 的前序遍历，找到与subRoot相同值的节点，作为比较的起点②cmprecursion：对root的节点以及subRoot的根节点 做 同频前序遍历对比

class Solution {
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        if(subRoot == null) return true;
        if(root == null) return true;
        return preorder(root, subRoot);
    }

    public boolean preorder(TreeNode p, TreeNode q){
        if(p == null) return false;
        if(p.val == q.val && cmprecursion(p, q))
            return true;
        if(preorder(p.left, q) || preorder(p.right, q)) 
            return true;
        return false;
    }

    public boolean cmprecursion(TreeNode p, TreeNode q){
        if(p == null && q == null) 
            return true;
        else if(p != null && q != null){
            if(p.val != q.val) 
                return false;
            if(cmprecursion(p.left, q.left) && cmprecursion(p.right, q.right))
                return true;
        }
        return false;
    }
}

[简单] 222. 完全二叉树的节点个数

原题链接

递归

class Solution {
    public int countNodes(TreeNode root) {
        if(root == null) return 0;
        return countNodes(root.left) + countNodes(root.right) + 1;
    }
}

[简单] 110. 平衡二叉树

原题链接

递归，后序遍历
用-2标记 以当前节点为根节点的子树非平衡二叉树，在递归中一旦出现-2就层层传递到root，用来标识存在子树为非平衡二叉树

class Solution {
    public boolean isBalanced(TreeNode root) {
        if(countDepth(root) == -2) return false;
        return true;
    }

    public int countDepth(TreeNode p){
        if(p == null) return 0;
        int leftDepth = countDepth(p.left);
        int rightDepth = countDepth(p.right);
        int flag = leftDepth - rightDepth;
        if(leftDepth == -2 || rightDepth == -2 || flag > 1 || flag < -1) return -2;
        else return (leftDepth > rightDepth ? leftDepth : rightDepth) + 1;
    }
}

[简单] 257. 二叉树的所有路径

原题链接

思路就是DFS深度优先遍历找到每一条路径，效率差异主要体现在对字符串拼接的处理上，使用StringBuilder会更高效一些。
在这里插入图片描述

class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> ans = new ArrayList<>();
        if(root == null) return ans;
        DFS(root, ans, "");
        return ans;
    }

    public void DFS(TreeNode p, List<String> ans, String string){
        StringBuilder sb = new StringBuilder(string);
        sb.append(p.val);
        if(p.left == null && p.right == null){
            ans.add(sb.toString());
            return;
        }
        sb.append("->");
        if(p.left != null)
            DFS(p.left, ans, sb.toString());
        if(p.right != null)
            DFS(p.right, ans, sb.toString());
    }
}

[简单] 404. 左叶子之和

原题链接

在前序遍历的基础上更改，用一个布尔类型标记当前节点是否是某个节点的左孩子

class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        int sum = preorder(root, false, 0);
        return sum;
    }

    public int preorder(TreeNode root, boolean isLChild, int sum) {
        if (root == null) return sum;
        if (root.left == null && root.right == null && isLChild){
            return sum + root.val;
        }
        return preorder(root.left, true, sum) + preorder(root.right, false, sum);
    }
}

[中等] 513. 找树左下角的值

原题链接

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

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

相关文章

微信小程序开发系列（十七）·事件传参·mark-自定义数据

微信小程序开发系列（十七）·事件传参·mark-自定义数据

目录 步骤一&#xff1a;按钮的创建 步骤二&#xff1a;按钮属性配置 步骤三&#xff1a;添加点击事件 步骤四&#xff1a;参数传递 步骤五&#xff1a;打印数据 步骤六&#xff1a;获取数据 步骤七&#xff1a;父进程验证 总结&#xff1a;data-*自定义数据和mark-自定…
阅读更多...
Doris实战——金融壹账通指标中台的应用实践

Doris实战——金融壹账通指标中台的应用实践

目录 前言 一、业务痛点 二、早期架构挑战 三、架构升级 四、一体化指标数据平台 4.1 构建指标体系 4.2 构建指标平台功能 五、Doris指标应用实践 六、未来规划 原文大佬的这篇指标中台的应用实践有借鉴意义&#xff0c;这里摘抄下来用作学习和知识沉淀。 前言 在搭建…
阅读更多...
python+django_vue旅游酒店预订出行订票系统pycharm项目lw

python+django_vue旅游酒店预订出行订票系统pycharm项目lw

a.由于对管理信息方面的内容了解尚浅且没有足够的经验&#xff0c;因而很难对数据庞大的线上旅行信息管理系统建立完善的数据库。 b.线上旅行信息管理系统拥有很大的信息量&#xff0c;其中包括数据库的前期开发和后期更新&#xff0c;因此对数据库的安全性&#xff0c;一致性和…
阅读更多...
CVE-2020-8835：eBPF verifier 整数截断导致的越界读写

CVE-2020-8835：eBPF verifier 整数截断导致的越界读写

文章目录 前言漏洞分析do_check 函数 漏洞利用漏洞触发越界读实现地址泄漏越界写实现任意读越界写实现任意写 exp 即效果演示参考 前言 影响版本&#xff1a;v5.4.7 ~ v5.5.0 以及更新的版本&#xff0c;如 5.6 编译选项&#xff1a;CONFIG_BPF_SYSCALL&#xff0c;config 所有…
阅读更多...
Vue基础入门（4）- Vuex的使用

Vue基础入门（4）- Vuex的使用

Vue基础入门&#xff08;4&#xff09;- Vuex的使用 Vuex 主要内容&#xff1a;Store以及其中的state、mutations、actions、getters、modules属性 介绍&#xff1a;Vuex 是一个 Vue 的 状态管理工具&#xff0c;状态就是数据。 大白话&#xff1a;Vuex 是一个插件&#xff…
阅读更多...
网站维护页面404源码

网站维护页面404源码

网站维护页面404源码&#xff0c;源码由HTMLCSSJS组成&#xff0c;记事本打开源码文件可以进行内容文字之类的修改&#xff0c;双击html文件可以本地运行效果&#xff0c;也可以上传到服务器里面&#xff0c;重定向这个界面 下载地址 https://www.qqmu.com/2407.html
阅读更多...
【排序算法】深入理解归并排序算法：从原理到实现

【排序算法】深入理解归并排序算法：从原理到实现

目录 1. 引言 2. 归并排序算法原理 3. 归并排序的时间复杂度分析 4. 归并排序的应用场景 5. 归并排序的优缺点分析 5.1 优点&#xff1a; 5.2 缺点&#xff1a; 6. Java、JavaScript 和 Python 实现归并排序算法 6.1 Java 实现&#xff1a; 6.2 JavaScript 实现&…
阅读更多...
MySQL 元数据锁及问题排查（Metadata Locks MDL）

MySQL 元数据锁及问题排查（Metadata Locks MDL）

"元数据"是用来描述数据对象定义的&#xff0c;而元数据锁&#xff08;Metadata Lock MDL&#xff09;即是加在这些定义上。通常我们认为非锁定一致性读&#xff08;简单select&#xff09;是不加锁的&#xff0c;这个是基于表内数据层面&#xff0c;其依然会对表的元…
阅读更多...
如何解决代理ip服务器连接问题

如何解决代理ip服务器连接问题

在当今的数字化时代&#xff0c;互联网连接已成为生活和工作中不可或缺的一部分。然而&#xff0c;在尝试访问互联网资源时&#xff0c;用户有时会遇到“代理服务器可能有问题&#xff0c;或地址不正确(你尚未连接)”的错误提示。这种情况通常表明计算机的网络设置存在问题&…
阅读更多...
OWASP Top 10 网络安全10大漏洞——A01：2021-访问控制中断

OWASP Top 10 网络安全10大漏洞——A01：2021-访问控制中断

10大Web应用程序安全风险 2021年top10中有三个新类别、四个类别的命名和范围变化&#xff0c;以及一些合并。 A01&#xff1a;2021-访问控制中断 从第五位上升到top1&#xff0c;94%的应用程序都经过了某种形式的访问控制破坏测试&#xff0c;平均发生率为 3.81%且在贡献的…
阅读更多...
CSS标准文档流与脱离文档流，分享一点面试小经验

CSS标准文档流与脱离文档流，分享一点面试小经验

大厂面试真题整理 CSS&#xff1a; 1&#xff0c;盒模型 2&#xff0c;如何让一个盒子水平垂直居中&#xff1f; 3&#xff0c;css 优先级确定 4&#xff0c;解释下浮动和它的工作原理&#xff0c;清除浮动的方法&#xff1f; 5&#xff0c;CSS隐藏元素的几种方法 6&#xff0…
阅读更多...
MapReduce内存参数自动推断

MapReduce内存参数自动推断

MapReduce内存参数自动推断。在Hadoop 2.0中&#xff0c;为MapReduce作业设置内存参数非常繁琐&#xff0c;涉及到两个参数&#xff1a;mapreduce.{map,reduce}.memory.mb和mapreduce.{map,reduce}.java.opts&#xff0c;一旦设置不合理&#xff0c;则会使得内存资源浪费严重&a…
阅读更多...
【2024】使用Vuetifi搭建vue3+Ts项目，并使用tailwind.css

【2024】使用Vuetifi搭建vue3+Ts项目，并使用tailwind.css

目录 使用Vuetifi搭建项目使用tailwind.css 只要跟着官方文档来就不会出错。 使用Vuetifi搭建项目 npm create vuetifyyarn create vuetifypnpm create vuetifybun create vuetify在终端运行一个就行&#xff0c;之后就可以选配置了。 使用tailwind.css 先运行&#xff1a; …
阅读更多...
【力扣经典面试题】14. 最长公共前缀

【力扣经典面试题】14. 最长公共前缀

目录 一、题目描述 二、解题思路 三、解题步骤 四、代码实现&#xff08;C版详细注释&#xff09; 五、总结 欢迎点赞关注哦&#xff01;创作不易&#xff0c;你的支持是我的不竭动力&#xff0c;更多精彩等你哦。 一、题目描述 编写一个函数来查找字符串数组中的最长公共前缀。…
阅读更多...
Mysql80服务无法启动请输入Net helpMsg3534以获得更多的帮助

Mysql80服务无法启动请输入Net helpMsg3534以获得更多的帮助

起因&情景&#xff1a; 朋友正在操作数据库&#xff0c;然后电脑突然死机&#xff0c;再重启电脑后启动数据库服务报&#xff1a; 然后朋友尝试各种操作都没有办法正常启动&#xff0c; 一、网上解决方案&#xff1a;&#xff08;先别操作&#xff09; 1 删掉&#xff1a…
阅读更多...
Docker的安装跟基础使用一篇文章包会

Docker的安装跟基础使用一篇文章包会

目录 国内源安装新版本 1、清理环境 2、配置docker yum源 3、安装启动 4、启动Docker服务 5、修改docker数据存放位置 6、配置加速器 现在我们已经完成了docker的安装和初始配置。以下为基本测试使用 自带源安装的版本太低 docker官方源安装的话速度太慢了 所以本篇文…
阅读更多...
RocketMQ—如何解决消息堆积问题

RocketMQ—如何解决消息堆积问题

RocketMQ—如何保证消息不丢失 生产者发送到MQ的消息&#xff0c;会放到broker的硬盘内&#xff0c;这便是消息的持久化。消息会有两种持久化策略&#xff1a; 同步刷盘&#xff1a;消息过来就会进入磁盘&#xff0c;再向生产者发送写成功&#xff0c;这会很安全&#xff0c;…
阅读更多...
【数据结构】顺序表+链表

【数据结构】顺序表+链表

目录 1.顺序表 1.1初始化顺序表 1.2销毁顺序表 1.3检查容量并扩容 1.4把某个元素插入到下标为pos的位置 1.5头插和尾插 1.6删除下标为pos的元素 1.7头删和尾删 2.顺序表的问题及思考 3.链表 3.1链表的访问 3.2链表的增删查改 1.顺序表 顺序表的本质其实就是一个数组…
阅读更多...
Java | vscode如何使用命令行运行Java程序

Java | vscode如何使用命令行运行Java程序

1.在vscode中新建一个终端 2.在终端中输入命令 输入格式&#xff1a; javac <源文件>此命令执行后&#xff0c;在文件夹中会生成一个与原java程序同名的.class文件。然后输入如下命令&#xff1a; java <源文件名称>这样java程序就运行成功了。&#x1f607;
阅读更多...
【LeetCode每日一题】【BFS模版与例题】【二维数组】1293. 网格中的最短路径

【LeetCode每日一题】【BFS模版与例题】【二维数组】1293. 网格中的最短路径

BFS基本模版与案例可以参考&#xff1a; 【LeetCode每日一题】【BFS模版与例题】863.二叉树中所有距离为 K 的结点 【LeetCode每日一题】【BFS模版与例题】【二维数组】130被围绕的区域 && 994 腐烂的橘子 思路&#xff1a; 特殊情况&#xff1a; 最短的路径是向下再向…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023