加班刷题-----递归模块（java）---简单题

2021-01-08 17:24:51 47 收藏 1
分类专栏： 算法 文章标签： 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37534947/article/details/112372095
版权

文章目录

一.剑指 Offer 10- I. 斐波那契数列----2021/1/8

在这里插入图片描述

解法1-----递归

class Solution {
    int constant = 1000000007;
    public int fib(int n) {
        if(n==0){
            return 0;
        }
        if(n==1){
            return 1;
        }
        return (fib(n-1)+fib(n-2))%constant ;
    }
}

或者

class Solution {
    int constant = 1000000007;
    public int fib(int n) {
        if(n==0){
            return 0;
        }
        if(n==1){
            return 1;
        }
        return (fib(n-1)%constant+fib(n-2)%constant)%constant ;
    }
}

证明： 要证（a+b）%c = （a%c+b%c）%c， 即证a+b与a%c+b%c对c同余，则有c能整除(a+b-a%c-b%c) 设a=mc+p，b=nc+q， 则(a+b-a%c-b%c)=(m+n)c+p+q-p-q=(m+n)c ，则证a+b与a%c+b%c对c同余，证毕。
注： 这道题，直接用递归的话，会很大可能超时，所以推荐下面的动态规划。

解法2----动态规划

class Solution {
    int constant = 1000000007;
    public int fib(int n) {
        if(n<=1){
            return n;
        }
        int[]arr = new int[n+1];
        arr[0] = 0;
        arr[1] = 1;
        for(int i = 2 ;i<=n;i++){
            arr[i] = arr[i-1] + arr[i-2];
            arr[i] = arr[i] % constant;
        }
        return arr[n];
    }
}

注： 这里需要的是每次得到一个值，要进行%取模操作，因为，如果最后取模，中间可能会溢出，而为什么中间不断取模不会影响最后取模的值，需要证明（a+b）%c = （a%c+b%c）%c，，证明见上面！
另外，java中科学计数法1e9+7默认是double，如果使用的话要注意强转类型。

二.938. 二叉搜索树的范围和----2021/1/9

在这里插入图片描述

/**
 * 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 sum = 0;
    public int rangeSumBST(TreeNode root, int low, int high) {
        if(root == null){
            return 0;
        }
        rangeSumBST(root.left,low,high);
        rangeSumBST(root.right,low,high);
        if(root.val>=low && root.val<=high){
            sum += root.val;
        }
        return sum;
    }
}

思路： 递归遍历–这里选取的是后序遍历，其实前序遍历、中序遍历等都可以，因为这里目标就是把所有的节点都要过一遍，然后比较是否符合条件，如果符合条件则进行累加即可，可以看到这里的返回sum，其实在递归过程的返回sum是没有意义的，但是最后一步的返回sum则是最终的值。
待： 可以看到这棵树是二叉搜索树，其每个节点的左子树必定小于该节点，而右子树必定大于根节点，所以应该会有简化的操作，这个之后如果有能力在补充。

三.剑指 Offer 10- II. 青蛙跳台阶问题----2021/1/9

在这里插入图片描述

解法1-----递归

class Solution {
    public final int num = 1000000007;
    public int numWays(int n) {
        if(n<=1)
            return 1;
        if(n==2){
            return 2;
        }
        return (numWays(n-1)+numWays(n-2))%num;
    }
}

解法2-----动态规划

class Solution {
    public final int num = 1000000007;
    public int numWays(int n) {
        int []dp = new int[n+1];
        if(n<=1)
            return 1;
        if(n==2){
            return 2;
        }
        dp[0] = dp[1] = 1;
        dp[2] = 2; 
        for(int i = 3;i<=n ; i++){
           dp[i] = dp[i-1] + dp[i-2];
           dp[i] = dp[i] % num;  
        }
        return dp[n];
    }
}

注： 这里递归和动态规划是和第一题一样的，就不多赘述，需要注意的是递归还是超时！！！

四.70. 爬楼梯----2021/1/9

在这里插入图片描述
注： 这道题和第三题一样，只是少了条件0，就不再多加赘述了。

五.563. 二叉树的坡度----2021/1/9

在这里插入图片描述

/**
 * 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 sum = 0;
    int calcTilt(TreeNode root){
        if(root == null){
            return 0;
        }
        int left = calcTilt(root.left);
        int right =calcTilt(root.right);
        int dif = Math.abs(left-right);
        sum += dif;
        return root.val + left + right;
    }
    public int findTilt(TreeNode root) {
        calcTilt(root);
        return sum;
    }
}

思路： 这道题可以借鉴一下上面的第二题，可以看出，对于每个节点要计算其左子树的和以及其右子树的和，所以这里也采用后序遍历，但是不同的是这里多出了一个变量就是要累计所有的差的绝对值作为最后的结果，所以这里需要引入一个函数，在这个函数中进行递归，其中分别返回左子树的和、右子树的和，然后加上本节点的和作为返回值，而针对每个左子树以及右子树，分别计算差值累加存储到全局变量sum中即可。

六.1137. 第 N 个泰波那契数----2021/1/10

在这里插入图片描述

class Solution {
    public int tribonacci(int n) {
        if(n == 0){
            return 0;
        }
        if(n == 1){
            return 1;
        }
        if(n == 2){
            return 1;
        }
        int[] dp= new int[n+1];
        dp[0] = 0;
        dp[1] = 1;
        dp[2] = 1;
        for(int i=3;i<=n;i++){
            dp[i] = dp[i-1] + dp[i-2] + dp[i-3];
        }
        return dp[n];
    }
}

注： 这里递归和动态规划是和第一题一样的，就不多赘述，只写了动态规划！

七.面试题 16.11. 跳水板----2021/1/10

在这里插入图片描述

class Solution{
    public  int index= 0;
    public  int[] divingBoard(int shorter, int longer, int k) {
        if(k==0){
            return new int[0];
        }
        int[] a = new int[k+1];
        for(int i=0;i<=k;i++){
            if(index == 0){
                a[index++] = longer*i + shorter*(k-i);
            }else{
                int next = longer*i + shorter*(k-i);
                if(next!=a[index-1]){
                    a[index++] = next;
                }
            }
        }
        int[] b= new int[index];
        for(int i =0;i<index;i++){
            b[i] = a[i];
        }
        return b;
    }
}

注： 这道题竟然在递归里，上面必须动态规划的我忍了，这道题明显找规律，循环一遍就可以了！！！！
思路： 因为从小到大排序，所以循环的时候索引以最长的为主，即longer从0-k个，对应的shorter从k-0个，但是需要注意的是就是k=0的时候；以及不要有重复，这里的重复主要是因为shorter和longer相等时导致的，所以有一个优化方案，就是单独处理一下longer和shorter相等的时候，这样可以避免我这个大难的多个数组！

八.110. 平衡二叉树----2021/1/10

在这里插入图片描述

/**
 * 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 max = 0;
    public boolean pl = true;
    public int difDepth(TreeNode root){
        if(pl ==false){
            return 0;
        }
        if(root == null){
            return 0;
        }
        int leftDepth = difDepth(root.left) + 1;
        int rightDepth = difDepth(root.right) + 1;
        max = Math.abs(leftDepth-rightDepth);
        if(max>1)
            pl = false;
        return Math.max(leftDepth,rightDepth);

    }

    public boolean isBalanced(TreeNode root) {
        if(root == null){
            return true;
        }
        difDepth(root);
        return pl;

    }
}

思路： 其实本质是求每个节点的左子树和右子树的高度，这里还是从递归出发，利用后序遍历，比较左子树和右子树的高度差，如果大于1，就直接返回一个全局变量false，然后在每次递归的时候判断这个变量，如果为false，什么都不用干，直接返回；否则，就返回左子树和右子树的最大值，作为该节点的高度/深度。 可以对比着第5题看！

九.104. 二叉树的最大深度—2021/1/10

在这里插入图片描述

/**
 * 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 maxresult = 0;
    public int maxDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        int left = maxDepth(root.left) + 1;
        int right = maxDepth(root.right) + 1;
        return left>right?left:right;
    }
}

思路： 如果理解了第八题，这道题就信手拈来了，只是单纯的求最大深度，其实第八题，已经求了，并且更复杂的加了一个判断平衡二叉树的条件。

十.面试题 17.12. BiNode–2021/1/10

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    TreeNode f;
    public void dfs(TreeNode root){
        if(root==null){
            return;
        }
        dfs(root.left);
        f.right = root;
        root.left = null;
        f = root;
        dfs(root.right);

    }
    public TreeNode convertBiNode(TreeNode root) {
        f  = new TreeNode(Integer.MIN_VALUE);
        //保持最初的节点
        TreeNode pre = f;
        dfs(root);
        return pre.right;
    }
}

思路： 这道题首先需要明白题意，看了大佬的讲解发现意思是：将树转化成链表； 具体为左指针指向空； 右指针指向下一个节点；然后链表顺序就是从小到大；因为是二叉搜索树 所以有几条特性！
所以这次利用的是中序遍历，保证了其从小到大排序，并且需要在原地址基础上修改，就要修改每个节点的left以及right，而val保持原来的即可，left默认修改为null，而right从根据中序遍历将所有的节点链接起来，其中利用一个节点f不断的往后链接，但是需要保存这个节点的开始位置，这里用的是pre！

十一.783. 二叉搜索树节点最小距离----2021/1/10

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int minValue = Integer.MAX_VALUE;
    public int last = 0;
    public void dfs(TreeNode root){
         if(root==null){
            return;
        }
        dfs(root.left);
        if(last!=0)
            minValue = Math.min(minValue,root.val-last);
        last = root.val;
        dfs(root.right);
    }
    public int minDiffInBST(TreeNode root) {

        dfs(root);
        return minValue;
       
    }
};

思路： 刚开始以为是相邻节点，最后发现是任意节点，然后借鉴了题解中思路，因为是二叉搜索树，所以利用中序遍历+递归，因为中序遍历后是从小到大排序的，所以只需要比较每个节点和之前的节点的差值即可，因为这样是相邻的。

十二.21. 合并两个有序链表----2021/1/10

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if(l1 == null)
            return l2;
        if(l2 == null)
            return l1;
        if(l1.val<=l2.val){
            l1.next = mergeTwoLists(l1.next,l2);
            return l1;
        }else{
            l2.next = mergeTwoLists(l1,l2.next);
            return l2;
        }
    }
}

思路： 其实这道题本身来说，是比较容易理解的，但是通过代码来写的话感觉就费事了，这是参考大佬写的，就是每次选出最小的，其他的继续递归，这里需要注意的是返回值，不断递归，直到最后一步返回最后的节点，然后不断的往回走，直到最初的节点，中间利用next链接其了所有节点。

十三.897. 递增顺序查找树–2021/1/10

在这里插入图片描述

/**
 * 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 f;
    public void dfs(TreeNode root){
        if(root==null){
            return;
        }
        dfs(root.left);
        f.right = root;
        root.left = null;
        f = root;
        dfs(root.right);

    }
    public TreeNode increasingBST(TreeNode root) {
        TreeNode pre = new TreeNode(0);
        f = new TreeNode(0);
        pre = f;
        dfs(root);
        return pre.right;
    }
}

注： 和第十题一样，就不加赘述了！

十四.面试题 08.06. 汉诺塔问题–2021/1/11

在这里插入图片描述
注： 在讲这道题之前，先说一下汉诺塔问题；（设三个柱子分别是A、B、C）

在这里插入图片描述
要把最左面（A）全部移动到最右面©，分为三步骤：
1）先把上面两个从A移到B
2）把第三个从A移到C
3）把B的两个从B移到C
而步骤1）和步骤3）就是递归，又可以分为三个步骤，这里以步骤1）–把上面两个从A移到B为例：
1）先把上面的一个从A移到C
2）把第二个（也就是最后一个）从A移到B
3）把C的那一个移到B
步骤3）和其类似，从上面可以看出移动三个木块，其实需要两次移动两个木块来完成，当然中途也需要不是递归的一步，所以推导公式：step(n) = 2*step（n-1） + 1，其中step（n）表示移动n个木块的步骤；接下来就是找最终的终止条件：就是只有一个木块的时候，这个明显的就是直接移动即可！所以代码可以如下，声明一个变量step，统计所有的步数。
补充： 其实上面在移动的时候，如A–C需要借助B，这时候从代码中就是变量参数的顺序，如（String a，String b，String c）就是从A借住B移动到C；然后还有的是为什么递归中移动两个不会影响移动三个木块，因为在移动两个的时候，第三个木块是最大的，放在下面，所以就等于没有一样，不起作用。
代码：

package com.leetcode;

public class hnooi {
    private  static int step = 0;
    private static  void hnooi(Integer n,String a,String b, String c){

        if(n==1) {
            System.out.println(a + "移动到" + c);
            step++;
        }
        else {
            hnooi(n - 1, a, c, b);
            System.out.println(a + "移动到" + c);
            step++;
            hnooi(n - 1, b, a, c);
        }
    }
    public static void main(String[] args) {
        hnooi(3,"塔A","塔B","塔C");
        System.out.println("步数:" + step);
    }
}

参考视频：https://www.bilibili.com/video/BV1Hk4y1k7KL?from=search&seid=3869671113360747464
图片来源：https://www.zhihu.com/question/24385418

在有了前面的基础，然后看这道题,直接套上面的模板了，思路看上面即可，这里最后处理的结果就是C=A，所以你可以直接取巧，但是这就考的不是算法了！！！

class Solution {
    void move(int n,List<Integer> A, List<Integer> B, List<Integer> C){
         if(n==1){
            C.add(A.remove(A.size()-1));
        }else{
            move(n-1,A,C,B);
            C.add(A.remove(A.size()-1));
            move(n-1,B,A,C);
        }
    }
    public void hanota(List<Integer> A, List<Integer> B, List<Integer> C) {
       move(A.size(),A,B,C);
    }
}
已标记关键词 清除标记
在Java项目中打印错误日志的正确姿势，排查问题更方便，非常实用！
Java知音
03-05 1383
作者：琴水玉cnblogs.com/lovesqcc/p/4319594.html在程序中打错误日志的主要目标是为更好地排查问题和解决问题提供重要线索和指导。但是在实际中打的错误日志内容...
表情包
插入表情
还能输入1000个字符
相关推荐
程序员Java 面试题：百度前200页都在这里了
weixin_34248487的博客
11-13 964
基本概念操作系统中 heap 和 stack 的区别什么是基于注解的切面实现什么是 对象/关系 映射集成模块什么是 Java 的反射机制什么是 ACIDBS与CS的联系与区别Cookie 和 Session的区别fail-fast 与 fail-safe 机制有什么区别get 和 post请求的区别Interface 与 abstract 类的区别IOC的优点是什么IO 和 NIO的区别，NIO优...
LeetCode刷题笔记（Java版）----70、爬楼梯（递归，非递归等实现）
SOARING
04-28 446
70、爬楼梯 描述：假设你正在爬楼梯。需要n阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？ 注意：给定n是一个正整数。 解法1：采用递归实现，不过在力扣中提交超时了。 思路：找到程序的出口，即f(n) = f(n-1)+f(n-2)。但是递归中有很多重复的计算，还需要优化。 解释，比如有5阶楼梯，需要我们求爬到5阶能有多少种次数？因为...
加班刷题-----递归模块（java）---中等题
qq_37534947的博客
01-11 60
文章目录待 待
面试刷题12-4
wwxy1995的博客
12-04 672
真正学习Java是从4月份开始学的，算下来学Java时间真的少！前面很多东西做了对找Java工作也没有用，有个明确的计划真的很重要啊。正式准备面试知识是从6月份开始准备的，当时就是找别人的Java面经，自己不会的题记下来然后弄懂（后面面试中发现不仅要弄懂而且还要进行扩展），因为白天要去实习所以只能每晚把题记在本子上带去办公室，其实记在本子上感觉也是挺好的方式。刷面经一直从6月刷到7月底，两个月的时...
加班刷题-----回溯模块（java）---简单题
qq_37534947的博客
01-30 14
文章目录一.1688. 比赛中的配对次数----2021/1/30二.401. 二进制手表----2021/1/30 一.1688. 比赛中的配对次数----2021/1/30 class Solution { int count = 0; public int numberOfMatches(int n) { dfs(n); return count; } public void dfs(int n){ if(n==1)
加班刷题-----dfs模块（java）---中等题
qq_37534947的博客
02-17 17
文章目录dfs和回溯的理解层次遍历的理解+实现（java）前序遍历、后序遍历、中序遍历、遍历一：面试题 04.04. 检查平衡性----2021/2/16二：872. 叶子相似的树----2021/2/16三：257. 二叉树的所有路径----2021/2/16四：剑指 Offer 55 - I. 二叉树的深度----2021/2/16五：108. 将有序数组转换为二叉搜索树----2021/2/16六：112. 路径总和----2021/2/17七：剑指 Offer 55 - II. 平衡二叉树---20
加班刷题-----回溯模块（java）---中等题
qq_37534947的博客
01-31 23
文章目录一：357. 计算各个位数不同的数字个数----2021/1/31 一：357. 计算各个位数不同的数字个数----2021/1/31 class Solution { int count = 1; int sum; Set<Integer> set = new HashSet<Integer>(); public int countNumbersWithUniqueDigits(int n) { if(n==0)
面试题刷题演练9-12
wwxy1995的博客
09-12 6009
2019.6.11 10点 星耀实习计划现场一面（50分钟） web项目 说说epoll与select不同 select基于轮询机制，epoll基于通知机制，直接通知发生IO事件的fd，select需要在内核去和用户去不断拷贝fd_set, epoll采用共享内存机制，不需要，epoll内核数据结构用的是红黑树，效率更高。 能说说红黑树吗 高度平衡的二分搜索树，有两种节点，一种节点是红色...
LeetCode刷题——树（递归）
qq_39181839的博客
12-14 61
对于树，经常用的算法有递归，回溯，BFS，DFS等。下面是一些用递归算法来解的题： 104，二叉树的最大深度，easy 110，平衡二叉树，easy 543，二叉树的直径，easy 226，翻转二叉树，easy 617，合并二叉树，easy 112，路径总和，easy 113，路径总和Ⅱ，midium 572，另一个树的子树，easy 101，对称二叉树，easy 111，二叉树的最小深度，easy 404，左叶子之和，easy 687，最长同值路径，medium 671，二叉树中第二小的节点，easy 1
面试刷题9-17
wwxy1995的博客
09-17 568
一面：代码复盘，由于ac了三道，每道题都让讲思考过程，为啥要这么写。然后出了一道leetcode原题分糖果，5分钟写完，聊会项目，结束。 Leetcode 135较难的题目 二面：聊项目，问基础，进程线程，链表插入复杂度等等，然后手撕一道leetcode原题，和等于k的最长子序列，10分钟写完，结束。 进程线程问题 Leetcode 325 从two sum改遍过来，略有难度 三面：上来...
凭借这份Java全栈知识+1500道大厂面试真题，在11月即将结束之际把各大互联网公司面了个遍！
weixin_50205273的博客
11-20 192
这篇文章给大家分享一下我遇到的一些质量较高的面试经历，具体经过就不多说了，就把面试题打出来供各位读者老哥参考如有不全的地方，各位海涵。 猿辅导 八皇后问题 求二叉树的最长距离(任意两个节点的路径 中最长的) lru算法的实现 设计一个数据结构 满足 put 和 getMedium(中位数)两个方法. (时间复杂度分析, getMedium 在常数,n,log n 时间复杂度返回如何实现) rabbitmq 脑裂问题,rabbitmq 延迟队列实现, rabbitmq高可用策略(因
腾讯2020年Java实习生面试，15天后已拿offer，已经不想吃饭了
weixin_47345084的博客
08-06 216
近期收到很多小伙伴发来的面试题，因为有很多大小厂的面试题，所以我这也大概整理总结了一下，把那些比较典型有特色且面试内容比较广泛对大家都有用处的面试题汇总了一下。以下便是汇总好的几个大厂的面试题。 腾讯面试 记录了第二次腾讯后台开发社招面试流程，虽然面试流程因人而异，但就我个人感受而言，腾讯的面试从考察内容方面来讲，还是有一定的共通性，这一点，可以从网上众多的面经可以看出。 腾讯第一面 晚八点半，电话面，开始项目介绍，技术难点、实现细节。大概说了20分钟左右，我讲的内容面试官似乎没有理解，可能是项目架构比较复
请不要在Java项目中乱打印日志了，这才是正确姿势，非常实用！
欢迎关注公众号：【码农突围】，回复9999，可以获取一份LeetCode刷题笔记
12-31 45
点击上方“码农突围”，马上关注 这里是码农充电第一站，回复“666”，获取一份专属大礼包 真爱，请设置“星标”或点个“在看” 作者：琴水玉来源：cnblogs.com/lovesqcc/...
2017JAVA面试题附答案
前往JAVA架构的路上
08-25 19万+
声明，本人能力有限，只是列出来参考，不对之处欢迎指正。 JAVA基础 JAVA中的几种基本类型，各占用多少字节？ 下图单位是bit,非字节 1B=8bit String能被继承吗？为什么？ 不可以，因为String类有final修饰符，而final修饰的类是不能被继承的，实现细节不允许改变。平常我们定义的String str=”a”;其实和String str=n...
三年开发经验，抖音离职后，拿到Airbnb、快手、小红书、猿辅导等多家公司的offer
K-night的专栏
05-07 4万+
前言 我这篇文章并不是简单的描述一些面试中的题，或者总结一些Android的知识，而是想记录我整个的想法和准备的过程，以及一些心得体会，让大家更加全面的去看待工作、跳槽和生活（从我的角度，当然肯定有不合理的地方，大家借鉴就好） 在字节跳动的两年时间中见证了抖音从百万日活到2.5亿、团队从10人到100多人的过程，技术上不同时期的选型以及迭代、沉淀和更替。项目上经历了一个工程到模块化再到组件化最后插...
2021最全面、最详细web前端面试题及答案总结
HanXiaoXi_yeal的博客
02-01 928
2021最全面、最详细web前端面试题及答案总结 总结不易，希望可以帮助到即将面试或还在学习中的web前端小伙伴，祝面试顺利，拿高薪！ 本章是HTML考点的⾮重难点，因此我们采⽤简略回答的⽅式进⾏撰写，所以不会有太多详细的解释。我们约定，每个问题后我们标记『✨ 』的为⾼频⾯试题 doctype的作⽤是什么？✨ DOCTYPE是html5标准⽹⻚声明，且必须声明在HTML⽂档的第⼀⾏。来告知浏览器的解析器⽤什么⽂档标准解析这个 ⽂档，不同的渲染模式会影响到浏览器对于 CSS 代码甚⾄ JavaScript
面试题汇总2（吐血整理）
GFDGFHSDS的博客
10-18 8209
2021届校招算法岗知识点总结： 机器学习基础 统计学习 方法（LR，SVM，EM，最大篇，集成学习等），值得反复看好几遍，每一遍都会加深理解；尤其是学习理论：贝叶斯决策理论/假设空间概念/经验风险，结构风险/各类损失函数之间的区别与联系/极大似然估计，最大后验估计，贝叶斯估计的区别与联系。 ·树模型系列论文深入理解，gbdt，xgboost，lightgbm； ·深度学习基础：过拟合解决方法，dropout，bn，In等；学习器，各种optimizer原理及对比；BP原理；各种激活函数等，最好用numpy
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页