《LeetCode热题100》笔记题解思路技巧优化_Part_4

news2025/2/26 2:03:18

《LeetCode热题100》笔记&题解&思路&技巧&优化_Part_4

  • 😍😍😍 相知
  • 🙌🙌🙌 相识
  • 😢😢😢 开始刷题
    • 二叉树
      • 🟢1. 二叉树的中序遍历
      • 🟢2. 二叉树的最大深度
      • 🟢3. 翻转二叉树
      • 🟢4. 对称二叉树
      • 🟢5. 二叉树的直径
      • 🟡6. 二叉树的层序遍历
      • 🟢7. 将有序数组转换为二叉搜索树
      • 🟡8. 验证二叉 搜索树
      • 🟡9. 二叉搜索树中第K小的元素
      • 🟡10. 二叉树的右视图
      • 🟡11. 二叉树展开为链表
      • 🟡12. 从前序与中序遍历序列构造二叉树
      • 🟡13. 路径总和II
      • 🟡14. 二叉树的最近公共祖先
      • 🔴15. 二叉树中的最大路径和

在这里插入图片描述

😍😍😍 相知

刷题不要一上来就直接干，先看题，明白题说的什么意思，然后想一下用什么现成的算法和数据结构可以快速解决，如果还是无从下手，建议先去看视频，不要直接翻评论或官方代码实现，看完视频，自己在idea中模拟敲几遍代码，如果跑通了，先别急着上leetcode黏贴，而是再回顾一下要点，然后确定自己完全懂了后，在leetcode中手敲，注意是手敲下来！！！ 目前我就是采用的这种方法，虽然慢，但是可以维持一周忘不掉它，如果要想长期不忘，只能隔段时间就review一下了，就算是大牛，知道方法，长时间不碰，也不可能保证一次到位把代码敲完一遍过！！！

🙌🙌🙌 相识

刷LeetCode热题100的想法有几个原因：

  1. 流行度高：LeetCode是一个广受欢迎的在线刷题平台，拥有大量用户和活跃的讨论社区。因此，热门题目通常代表了大多数人认为重要的题目或者面试中常见的题目。

  2. 面试备战：LeetCode上的题目往往和面试题目有很大的重合度。刷LeetCode热题100可以帮助你熟悉常见的面试题型和解题思路，提高应对面试的能力。

  3. 广泛的覆盖：热题100覆盖了各种难度级别的题目，包括简单、中等和困难。通过解答这些题目，可以提高自己的算法和编程能力，并扩展自己的知识面。

  4. 反馈和讨论：由于热题100是根据用户的反馈和讨论度排名的，因此这些题目往往有大量的解题思路和讨论可以参考。你可以从其他人的解题过程中学习到很多知识和技巧。

😢😢😢 开始刷题

二叉树

🟢1. 二叉树的中序遍历

题目链接：https://leetcode.cn/problems/binary-tree-inorder-traversal/description/?envType=study-plan-v2&envId=top-100-liked

这个必会！包括前序遍历、后序遍历

方法1：通用迭代法

我们还可以采用通用的迭代法来完成前中后序遍历。具体思想如下：

  1. 我把所有元素按照我要处理的顺序依次入栈就行，入栈前要判断必须是非空节点，这样再出栈的时候就保证了遍历的顺序是满足我们前中后序要求的。
  2. 怎么实现依次入栈呢？只有每次弹出当前栈顶的中节点，再根据将这个中节点和它的左右孩子按顺序入栈，才能实现按要求依次入栈。
  3. 我们只处理‘中节点’，把每次弹出的‘中节点’的值加入数组中。注意这个中节点其实指代的是所有节点，因为所有的子节点都是他们自己子节点的中节点。
  4. 我们需要在处理中节点的前面加一个标识符null，一旦栈弹出来null，我们就可以知道下一个弹出的节点需要我们处理（存值），这也是之前为什么不允许空节点入栈的原因。
/**
 * 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<>();
        if(root==null)return list;
        Stack<TreeNode> stack = new Stack<>();
        stack.add(root);
        while(!stack.isEmpty()){
            TreeNode temp = stack.peek();
            if(temp!=null){
                stack.pop();
                if(temp.right!=null) stack.push(temp.right);
                stack.push(temp);
                stack.push(null);
                if(temp.left!=null) stack.push(temp.left);
            }
            else{
                stack.pop();
                list.add(stack.pop().val);
            }
        }
        return list;
    }
}

方法2：递归

前中后序都是可以使用递归来实现的，这种方式也最为简单，只用改变加入数组时的不同顺序就可以达到不同的遍历效果。以前序为例给出代码：

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

🟢2. 二叉树的最大深度

题目链接：https://leetcode.cn/problems/maximum-depth-of-binary-tree/?envType=study-plan-v2&envId=top-100-liked

可以利用层序遍历 一共多少层就是多深

/**
 * 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;
        int depth = 0;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        queue.add(null);
        while(!queue.isEmpty()){
            TreeNode temp = queue.peek();
            if(temp!=null){
                queue.poll();
                if(temp.left!=null)queue.add(temp.left);
                if(temp.right!=null)queue.add(temp.right);
            }
            else{
                queue.poll();
                depth++;
                if(!queue.isEmpty())queue.add(null);
            }
        }
        return depth;
    }
}

递归
Math.max（左边最深的+1，右边最深的+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) {
        if(root==null)return 0;
        int depth = 0;
        int left = maxDepth(root.left);
        int right = maxDepth(root.right);
        return Math.max(left,right)+1;
    }
}

🟢3. 翻转二叉树

题目链接：https://leetcode.cn/problems/invert-binary-tree/?envType=study-plan-v2&envId=top-100-liked

在这里插入图片描述

/**
 * 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) {
        if(root == null) return  root;
        TreeNode left = root.left;
        root.left = invertTree(root.right);
        root.right  = invertTree(left);
        return root;

    }
}

🟢4. 对称二叉树

题目链接：https://leetcode.cn/problems/symmetric-tree/?envType=study-plan-v2&envId=top-100-liked

/**
 * 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) {
        return check(root, root);
    }

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

/**
 * 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==null) return true;
        if(root.left==null&&root.right==null) return true;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root.left);queue.add(root.right);
        while(!queue.isEmpty()){
            TreeNode lefttree = queue.poll();
            TreeNode righttree = queue.poll();
            if(lefttree==null&&righttree==null) continue;
            if(lefttree==null&&righttree!=null)return false;
            if(lefttree!=null&&righttree==null)return false;
            if(lefttree.val!=righttree.val)return false;
            
            queue.add(lefttree.left);
            queue.add(righttree.right);
            queue.add(righttree.left);
            queue.add(lefttree.right);


            
        }
        return true;
    }
}

🟢5. 二叉树的直径

题目链接：https://leetcode.cn/problems/diameter-of-binary-tree/?envType=study-plan-v2&envId=top-100-liked

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

🟡6. 二叉树的层序遍历

题目链接：https://leetcode.cn/problems/binary-tree-level-order-traversal/?envType=study-plan-v2&envId=top-100-liked

/**
 * 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<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList();
        if(root==null)return result;
        Queue<TreeNode> queue = new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            int a = queue.size();
            List<Integer> list = new ArrayList();
            for(int i = 0;i<a;i++){
                TreeNode temp  = queue.peek();
                list.add(temp.val);
                queue.poll();
                if(temp.left!=null)queue.offer(temp.left);
                if(temp.right!=null)queue.offer(temp.right);
            }
            result.add(list);
        }
        return result;
    }
}

🟢7. 将有序数组转换为二叉搜索树

题目链接：https://leetcode.cn/problems/convert-sorted-array-to-binary-search-tree/description/?envType=study-plan-v2&envId=top-100-liked

/**
 * 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 sortedArrayToBST(int[] nums) {
        if(nums.length==0)return new TreeNode();
        TreeNode result = sorted(nums,0,nums.length-1);
        return result;
    }
    public TreeNode sorted(int[] nums,int a,int b){
        if(b<a)return null;
        int mid = (b-a)/2+a;
        TreeNode result = new TreeNode(nums[mid]);
        result.left = sorted(nums,a,mid-1);
        result.right= sorted(nums,mid+1,b);
        return result;
    }
}

🟡8. 验证二叉 搜索树

题目链接：https://leetcode.cn/problems/validate-binary-search-tree/description/?envType=study-plan-v2&envId=top-100-liked

要知道中序遍历下，输出的二叉搜索树节点的数值是有序序列。

有了这个特性，验证二叉搜索树，就相当于变成了判断一个序列是不是递增的了。

/**
 * 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 {
    List<Integer> list = new ArrayList<>();
    private void traversal(TreeNode root){
        if(root==null)return;
        traversal(root.left);
        list.add(root.val);
        traversal(root.right);
    }
    public boolean isValidBST(TreeNode root) {
        traversal(root);
        for (int i = 1; i < list.size(); i++) {
            // 注意要小于等于，搜索树里不能有相同元素
            if (list.get(i) <= list.get(i-1)) return false;
        }
        return true;
    }
}

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

题目链接：https://leetcode.cn/problems/kth-smallest-element-in-a-bst/description/?envType=study-plan-v2&envId=top-100-liked

/**
 * 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 {
    List<Integer> list = new ArrayList<>();
    private void traversal(TreeNode root){
        if(root==null)return;
        traversal(root.left);
        list.add(root.val);
        traversal(root.right);
    }
    public int kthSmallest(TreeNode root, int k) {
        traversal(root);
        return list.get(k-1);
    }
}

🟡10. 二叉树的右视图

题目链接：https://leetcode.cn/problems/binary-tree-right-side-view/description/?envType=study-plan-v2&envId=top-100-liked

/**
 * 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> rightSideView(TreeNode root) {
        if(root==null)return new ArrayList();
        List<Integer> list = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        int temp = 0;
        queue.add(root);
        queue.add(null);
        while(!queue.isEmpty()){
            TreeNode tree= queue.poll(); 
            if(tree!=null){
                if(tree.left!=null) queue.add(tree.left);
                if(tree.right!=null) queue.add(tree.right);
                temp = tree.val;
            }
            else{
                list.add(temp);
                if(!queue.isEmpty())queue.add(null);
            }
            
        }
        return list;
    }
}

🟡11. 二叉树展开为链表

题目链接：https://leetcode.cn/problems/flatten-binary-tree-to-linked-list/description/?envType=study-plan-v2&envId=top-100-liked

/**
 * 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 void flatten(TreeNode root) {
        if(root==null)return;
        TreeNode result = root;
        while(root.left!=null||root.right!=null){
            TreeNode right = root.right;
            TreeNode left = root.left;
            if(left!=null){
                TreeNode temp = left;
                while(left.right!=null){
                    left = left.right;
                }
                left.right = right;
                root.left = null;
                root.right = temp;
            }else{
               root =  root.right;
            }
        }
        root =  result;
    }
}

🟡12. 从前序与中序遍历序列构造二叉树

题目链接：https://leetcode.cn/problems/construct-binary-tree-from-preorder-and-inorder-traversal/?envType=study-plan-v2&envId=top-100-liked

/**
 * 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 buildTree(int[] preorder, int[] inorder) {
        if(preorder.length==0)return new TreeNode();
        TreeNode result = new TreeNode (preorder[0]);
        int mid = 0;
        for(int i = 0;i<inorder.length;i++){
            if(inorder[i]==preorder[0]){
                mid = i;
                break;
            }
        }
        result.left = solve(preorder,inorder,0,mid-1,1);
        result.right = solve(preorder,inorder,mid+1,inorder.length-1,mid+1);
        return result;
    }
    public TreeNode solve(int [] preorder,int [] inorder,int l,int r,int ll){
        if(ll>=preorder.length)return null;
        if(r<l)return null;
        TreeNode result = new TreeNode (preorder[ll]);
        int mid = l;
        for(int i = l;i<=r;i++){
            if(inorder[i]==preorder[ll]){
                mid = i;
                break;
            }
        }
        result.left = solve(preorder,inorder,l,mid-1,ll+1);
        result.right = solve(preorder,inorder,mid+1,r,ll+mid-l+1);
        return result;
    }
}

🟡13. 路径总和II

题目链接：https://leetcode.cn/problems/path-sum-iii/description/?envType=study-plan-v2&envId=top-100-liked

class Solution {
    public int pathSum(TreeNode root, int targetSum) {
        if (root == null) {
            return 0;
        }

        long ret = rootSum(root, targetSum);
        ret += pathSum(root.left, targetSum);
        ret += pathSum(root.right, targetSum);
        return (int)ret;
    }

    public long rootSum(TreeNode root, long targetSum) {
        long ret = 0;

        if (root == null) {
            return 0;
        }
        int val = root.val;
        if (val == targetSum) {
            ret++;
        } 

        ret += rootSum(root.left, targetSum - val);
        ret += rootSum(root.right, targetSum - val);
        return ret;
    }
}

🟡14. 二叉树的最近公共祖先

题目链接：https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree/description/?envType=study-plan-v2&envId=top-100-liked

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

🔴15. 二叉树中的最大路径和

题目链接：https://leetcode.cn/problems/binary-tree-maximum-path-sum/description/?envType=study-plan-v2&envId=top-100-liked

/**
 * 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 {
    int max = Integer.MIN_VALUE;
    public int maxPathSum(TreeNode root) {
        dfs(root);
        return max;
    }
    public int dfs(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftMax = Math.max(0, dfs(root.left));
        int rightMax = Math.max(0, dfs(root.right));
        max = Math.max(max, (root.val + leftMax + rightMax));
        return root.val + Math.max(leftMax, rightMax);
    }
}

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

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

相关文章

如何在idea中配置tomcat服务器，然后部署一个项目

如何在idea中配置tomcat服务器，然后部署一个项目

文章目录 前言第一步 先新建一个空项目第二步 添加框架支持第三步 添加配置及如何部署最后一步 运行及检查有没有问题总结 前言 本章学习的是在idea中配置tomcat服务器&#xff0c;然后部署一个项目 如果没有下载Tomcat服务器的可以在上一个博客观看下载及手动部署&#xff0c;…
阅读更多...
纯 CSS 实现文字换行环绕效果

纯 CSS 实现文字换行环绕效果

实现效果 实现代码 <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8" /><meta name"viewport" content"widthdevice-width, initial-scale1.0" /><title>Document</title><…
阅读更多...
SwiftUI的Alert使用方式

SwiftUI的Alert使用方式

SwiftUI的Alert使用方式 记录一下SwiftUI的Alert使用方式&#xff0c;比较简单直接上代码 import SwiftUIstruct AlertBootCamp: View {State var showAlert falsevar body: some View {Button {showAlert.toggle()} label: {Text("alert show")}/// 单按钮 // …
阅读更多...
Acwing-基础算法课笔记之动态规划（计数类DP）

Acwing-基础算法课笔记之动态规划（计数类DP）

Acwing-基础算法课笔记之动态规划&#xff08;计数类DP&#xff09; 一、整数划分1、定义2、完全背包的做法代码示例&#xff08;1&#xff09;过程模拟&#xff08;2&#xff09;代码示例 3、计数类DP的做法&#xff08;1&#xff09;过程模拟&#xff08;2&#xff09;闫氏DP…
阅读更多...
文件包含漏洞（input、filter、zip）

文件包含漏洞（input、filter、zip）

一、PHP://INPUT php://input可以访问请求的原始数据的只读流&#xff0c;将post请求的数据当作php代码执行。当传入的参数作为文件名打开时&#xff0c;可以将参数设为php://input,同时post想设置的文件内容&#xff0c;php执行时会将post内容当作文件内容。从而导致任意代码…
阅读更多...
Gogs 创建新的仓库并提交代码

Gogs 创建新的仓库并提交代码

Gogs 创建新的仓库并提交代码 1. 登录2. 仓库 -> 我的仓库3. 创建新的仓库4. 仓库5. Copy6. 公开代码​7. 提交成功 Gogs - gitReferences Gogs 是一款极易搭建的自助 Git 服务。 1. 登录 2. 仓库 -> 我的仓库 3. 创建新的仓库 4. 仓库 5. Copy 6. 公开代码 strongfo…
阅读更多...
【MySQL】表的约束（2）

【MySQL】表的约束（2）

【MySQL】表的约束&#xff08;2&#xff09; 目录 【MySQL】表的约束&#xff08;2&#xff09;自增长唯一键外键综合案例-阅读 作者&#xff1a;爱写代码的刚子 时间&#xff1a;2024.3.13 前言&#xff1a;本篇博客主要是介绍表的约束下部分内容(自增长&#xff0c;唯一键&a…
阅读更多...
计算机考研｜怎么备考「科软」？

计算机考研｜怎么备考「科软」？

学好408和考研数学就可以了 大家对于科软已经回到了理性的区间&#xff0c;很难再出现刚开始的300分上科软的现象&#xff0c;也不会再出现388分炸穿地心的现象。 如果大家想报考科软&#xff0c;我觉得一定要认真对待复习&#xff0c;不要抱有抄底的心态去复习。 众所周知&am…
阅读更多...
QtCreate cmake 和qmake 使用调用动态库流程

QtCreate cmake 和qmake 使用调用动态库流程

链接&#xff1a; QtCreate cmake 和qmake 使用调用静态库流程-CSDN博客 重点&#xff1a; 1.流程和静态库一样。 2.只是在include下放置所需的dll。 3.cmakelist.txt中的文件路径并未变化。
阅读更多...
Selenium抓取youtube视频推荐

Selenium抓取youtube视频推荐

Youtube作为一个全球最大的视频资源平台&#xff0c;对于视频资源有很好的规整处理。所以当我们想要抓取一些视频资源时&#xff0c;它本身提供的API能力不符合时&#xff0c;我们需要使用Selenium去抓取视频。 以下是根据一条视频链接去抓取推荐列表的功能&#xff1a; asyn…
阅读更多...
不锈钢多功能电工剥线钳分线绕线剪线剥线钳剥线压线扒皮钳子

不锈钢多功能电工剥线钳分线绕线剪线剥线钳剥线压线扒皮钳子

品牌&#xff1a;银隆 型号&#xff1a;089B绿色 材质&#xff1a;镍铬钢&#xff08;不锈钢&#xff09; 颜色分类&#xff1a;089B灰色,089B红色,089B绿色,089B黑色,089B橙色 功能齐集一身&#xff0c;一钳多用&#xff0c;多功能剥线钳。剥线&#xff0c;剪线&#xff…
阅读更多...
前端三件套 | 综合练习：模拟抽奖活动，实现一个简单的随机抽取并显示三名获胜者

前端三件套 | 综合练习：模拟抽奖活动，实现一个简单的随机抽取并显示三名获胜者

随机运行结果如下&#xff1a; 参考代码如下&#xff1a; <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-width, initial-scale1.0"><tit…
阅读更多...
分数相加减（C语言）

分数相加减（C语言）

一、流程图&#xff1b; 二、源代码&#xff1b; # define _CRT_SECURE_NO_WARNINGS # include <stdio.h>int main() {//初始化变量值&#xff1b;int fenmu 2;int result 1;int fuhao 1;//执行循环&#xff1b;while (fenmu < 100){//运算&#xff1b;fuhao (-1…
阅读更多...
深度学习1650ti在win10安装pytorch复盘

深度学习1650ti在win10安装pytorch复盘

深度学习1650ti在win10安装pytorch复盘 前言1. 安装anaconda2. 检查更新显卡驱动3. 根据pytorch选择CUDA版本4. 安装CUDA5. 安装cuDNN6. conda安装pytorch结语 前言 建议有条件的&#xff0c;可以在安装过程中&#xff0c;开启梯子。例如cuDNN安装时登录 or 注册&#xff0c;会…
阅读更多...
Redis应用与原理（一）

Redis应用与原理（一）

更好的阅读体验 \huge{\color{red}{更好的阅读体验}} 更好的阅读体验 缓存发展史 缓存经典场景 在没有引入缓存前&#xff0c;为了应对大量流量&#xff0c;一般采用&#xff1a; LVS 代理Nginx 做负载均衡搭建 Tomcat 集群 这种方式下&#xff0c;随着访问量的增大&#xf…
阅读更多...
Python 蜂窝六边形分析

Python 蜂窝六边形分析

在本文中，我们将使用 Wildland Fire Interagency Geospatial Services (WFIGS) 2022 数据集，并仅关注新墨西哥州的 Hermits Peak / Calf Canyon 火灾。这场野火是该州历史上规模最大的野火，烧毁面积超过 30 万英亩。大火位于陶斯和圣达菲之间，烧毁了桑格雷德克里斯托山脉的…
阅读更多...
继承 ResponseEntityExceptionHandler

继承 ResponseEntityExceptionHandler

目录 作用概述 示例-HttpRequestMethodNotSupportedException 示例-自定义异常处理 总示例 使用了ResponseEntityExceptionHandler后&#xff0c;为什么发生了异常后返回体为空 方法执行顺序 作用概述 这是一个方便的基类&#xff0c;用于希望通过 ExceptionHandler 方法…
阅读更多...
centos7修改ssh登录错误限制和端口修改

centos7修改ssh登录错误限制和端口修改

前几天登录服务器的时候发现有错误登录信息15w多条&#xff0c;该服务器映射了外网&#xff0c;估计是被爆破了。为了防止再有人进行爆破&#xff0c;修改一下ssh的限制登录顺便把默认端口改掉 编辑ssh配置文件 vim /etc/ssh/sshd_config去掉注释 按需修改次数 MaxAuthTries 6…
阅读更多...
云服务器2核4G5M配置代表什么意思？

云服务器2核4G5M配置代表什么意思？

腾讯云服务器2核4G5M带宽配置是代表什么&#xff1f;代表2核CPU、4G内存、5M公网带宽&#xff0c;这是一款轻量应用服务器&#xff0c;系统盘为60GB SSD云硬盘&#xff0c;活动页面 txybk.com/go/txy 活动打开如下图&#xff1a; 腾讯云2核4G5M服务器 如上图所示&#xff0c;这…
阅读更多...
EDA事件驱动架构/BASE理论/幂等性理论

EDA事件驱动架构/BASE理论/幂等性理论

EDA事件驱动架构&#xff1a;Event Driven Architecture 消息组件&#xff1a;不仅仅是削峰填谷 而且可以做事件驱动架构 EDA驱动的特定&#xff1a;异步处理、跨平台/语言通信、应用解耦、可靠投递、最终一致性 BASE理论&#xff1a; 基本可用 Basically Available 软状态 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023