牛客top100 -自刷打卡day2+3 - 二叉树

最新推荐文章于 2024-06-21 22:23:19 发布
最新推荐文章于 2024-06-21 22:23:19 发布
阅读量292 收藏
点赞数 1
分类专栏： 刷题个人打卡 文章标签： java 算法 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50546235/article/details/129690754
版权

牛客top100 -自刷打卡day2+3 - 二叉树

二叉树

BM23二叉树的前序遍历

二叉树的前序遍历_牛客题霸_牛客网 (nowcoder.com)

  • 递归, 秒
import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型一维数组
     */
    List<Integer> list = new ArrayList<>();
    
    public void preorder(TreeNode root){
        if(root == null) {
            return ;
        }
        list.add(root.val);
        preorder(root.left);
        preorder(root.right);
        
    }
    public int[] preorderTraversal (TreeNode root) {
        // write code here
        if(root == null) return new int[0];
        preorder(root);
        int[] res = new int[list.size()];
        
        for(int i = 0; i < list.size(); i++) {
            res[i] = list.get(i);
        }
        return res;
    }
}
  • 非递归

BM24二叉树的中序遍历

二叉树的中序遍历_牛客题霸_牛客网 (nowcoder.com)

  • 递归
import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型一维数组
     */
    ArrayList<Integer> list = new ArrayList<>();
    
    public void inorderHelp(TreeNode root){
        if(root == null) return ;
        inorderHelp(root.left);
        list.add(root.val);
        inorderHelp(root.right);
    }
    public int[] inorderTraversal (TreeNode root) {
        // write code here
        if(root == null) return new int[0];
        inorderHelp(root);
        int[] res = new int[list.size()];
        for(int i = 0; i < res.length; i++) {
            res[i] = list.get(i);
        }
        return res;
    }
}
  • 非递归
import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型一维数组
     */
    public int[] inorderTraversal (TreeNode root) {
        // write code here
        if(root == null) return new int[0];
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while(cur != null || !stack.empty()){
            while(cur != null) {
                stack.push(cur);
                cur = cur.left;
            }
            TreeNode top = stack.pop();
            list.add(top.val);
            cur = top.right;
        }
        int []res = new int[list.size()];
        for(int i = 0; i < res.length; i++) {
            res[i] = list.get(i);
        }
        return res
;
    }
}

BM25二叉树的后序遍历

二叉树的后序遍历_牛客题霸_牛客网 (nowcoder.com)

  • 非递归
import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型一维数组
     */
    public int[] postorderTraversal (TreeNode root) {
        // write code here
        if(root == null) return new int[0];
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> list = new ArrayList<>();
        TreeNode cur = root;
        TreeNode pre = null;
        while(cur != null || !stack.empty()) {
            while(cur != null) {
                stack.push(cur);
                cur = cur.left;
            }
            TreeNode top = stack.peek();
            if(top.right == null || top.right == pre){
                stack.pop();
                list.add(top.val);
                pre = top;
            }else{
                cur = top.right;
            }
        }
        int []res = new int[list.size()];
        for(int i = 0; i < res.length; i++) {
            res[i] = list.get(i);
        }
        return res;
    }
}

BM26求二叉树的层序遍历

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     *
     * @param root TreeNode类
     * @return int整型ArrayList<ArrayList<>>
     */
    public ArrayList<ArrayList<Integer>> levelOrder (TreeNode root) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();

        if(root == null) return res;
        // write code here
        Queue<TreeNode> q = new LinkedList<>();
        TreeNode cur = root;
        q.offer(cur);
        while (!q.isEmpty()) {
            ArrayList<Integer> list = new ArrayList<>();
            int size = q.size();
            for(int i = 0; i < size; i++){
                TreeNode top = q.poll();
                list.add(top.val);
                if(top.left != null) q.offer(top.left);
                if(top.right != null) q.offer(top.right);
            }
            res.add(list);
        }
        return res;


    }
}

BM27按之字形顺序打印二叉树

按之字形顺序打印二叉树_牛客题霸_牛客网 (nowcoder.com)

  • Collections.reverse, 逆序输出
import java.util.ArrayList;
import java.util.*;
/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
        if (pRoot == null) return res;
        Queue<TreeNode> queue = new LinkedList<>();
        TreeNode cur = pRoot;
        queue.offer(cur);
        boolean iflag = true;
        while (!queue.isEmpty()) {
            ArrayList<Integer> list = new ArrayList<>();
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode top = queue.poll();
                list.add(top.val);
                if (top.left != null) queue.offer(top.left);
                if (top.right != null) queue.offer(top.right);
            }
            if (iflag) res.add(list);
            else {
                Collections.reverse(list);
                res.add(list);

            }
            iflag = !iflag;
        }
        return res;
    }

}

BM28二叉树的最大深度

二叉树的最大深度

  • 秒
import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param root TreeNode类 
     * @return int整型
     */
    public int maxDepth (TreeNode root) {
        // write code here
        if(root == null) return 0;
        if(root.left == null && root.right == null) {
            return 1;
        }
        int left = maxDepth(root.left);
        int right = maxDepth(root.right);
        return left > right ? left + 1 : right + 1;
    }
}

BM29二叉树中和为某一值的路径(一)

二叉树中和为某一值的路径(一)

  • 注意要结束条件, 当节点的左节点和右节点都为空且此时的sum为0的时候, 这时候就表明找到了
import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param root TreeNode类 
     * @param sum int整型 
     * @return bool布尔型
     */
    public boolean hasPathSum (TreeNode root, int sum) {
        // write code here
        if(root == null) return false;
        return dfs(root, sum);
    }
    public boolean dfs(TreeNode root, int sum) {
        if(root == null) {
            return false;
        }
        if(root.left == null && root.right == null && sum - root.val == 0) return true;
        return dfs(root.left, sum - root.val) || dfs(root.right, sum - root.val);


    }
}

BM30二叉搜索树与双向链表

二叉搜索树与双向链表

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    public TreeNode head = null;
    public TreeNode pre = null;
    public TreeNode Convert(TreeNode pRootOfTree) {
        if(pRootOfTree == null) {
            return null;
        }
        Convert(pRootOfTree.left);
        if(pre == null){
            head = pRootOfTree;
            pre = pRootOfTree;
        }else{
            pre.right = pRootOfTree;
            pRootOfTree.left = pre;
            pre = pRootOfTree;
        }
        Convert(pRootOfTree.right);
        return head;
    }
}

BM31对称的二叉树

对称的二叉树

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    boolean isSame(TreeNode root1, TreeNode root2) {
        if(root1 == null && root2 == null) return true;
        if(root1 == null || root2 == null) return false;
        if (root1.val != root2.val) {
            return false;
        }
        return isSame(root1.left, root2.right) && isSame(root1.right, root2.left);
    }
    boolean isSymmetrical(TreeNode pRoot) {
        if (pRoot == null) return true;
        return isSame(pRoot, pRoot);
    }
}

思路简单33.53%

视频题解

BM32合并二叉树

合并二叉树

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param t1 TreeNode类 
     * @param t2 TreeNode类 
     * @return TreeNode类
     */
    public TreeNode mergeTrees (TreeNode t1, TreeNode t2) {
        // write code here
        if(t1 == null) return t2;
        if(t2 == null) return t1;
        TreeNode head = new TreeNode(-1);
        if(t1 != null && t2 != null) {
            head.val = t1.val + t2.val;
        }
        
        head.left = mergeTrees(t1.left, t2.left);
        head.right = mergeTrees(t1.right, t2.right);
        return head;
    }
}

思路简单72.89%

视频题解

BM33二叉树的镜像

二叉树的镜像

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param pRoot TreeNode类
     * @return TreeNode类
     */
    public TreeNode Mirror (TreeNode pRoot) {
        // write code here
        if (pRoot == null) return null;
        TreeNode left = Mirror(pRoot.left);
        TreeNode right = Mirror(pRoot.right);
        //交换
        pRoot.left = right;
        pRoot.right = left;
        return pRoot;
    }
}

思路简单67.58%

BM34判断是不是二叉搜索树

判断是不是二叉搜索树

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return bool布尔型
     */
    private boolean BST(TreeNode root, int left, int right){
        if(root == null) return true;
        // write code here
        if(root.val<=left||root.val>=right){
            return false;
        }
        return BST(root.left, left, root.val) && BST(root.right, root.val, right);
        
    }
    public boolean isValidBST (TreeNode root) {
        return BST(root, Integer.MIN_VALUE,  Integer.MAX_VALUE);
    }
}

思路中等33.42%

BM35判断是不是完全二叉树

判断是不是完全二叉树

思路中等39.10%

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param root TreeNode类
     * @return bool布尔型
     */
    public boolean isCompleteTree (TreeNode root) {
        // write code here
        if (root == null) return false;
        Queue<TreeNode> q = new LinkedList<>();
        q.offer(root);
        while (!q.isEmpty()) {
            TreeNode c = q.poll();
            if (c != null) {
                q.offer(c.left);
                q.offer(c.right);
            } else {
                break;
            }
        }
        //遍历第二次
        while (!q.isEmpty()) {
            TreeNode node = q.peek();
            if (node == null) {
                q.poll();
            } else {
                return false;
            }
        }
        return true;
    }
}

BM36判断是不是平衡二叉树

判断是不是平衡二叉树

public class Solution {
    public int depth(TreeNode root){
        if(root == null) {
            return 0;
        }
        int lh = depth(root.left) + 1;
        int rh = depth(root.right) + 1;
        return lh > rh ? lh : rh;
    }
    public boolean IsBalanced_SolutionHelp(TreeNode root){
        int left = depth(root.left);
        int right = depth(root.right);
        if(Math.abs(left - right) <= 1){
            return IsBalanced_Solution(root.left) && IsBalanced_Solution(root.right);
        }
        return false;

    }
    public boolean IsBalanced_Solution(TreeNode root) {
        if(root == null) {
            return true;
        }
        return IsBalanced_SolutionHelp(root);
    }
}

BM37二叉搜索树的最近公共祖先

二叉搜索树的最近公共祖先

思路简单49.56%

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @param p int整型 
     * @param q int整型 
     * @return int整型
     */
    public int lowestCommonAncestor (TreeNode root, int p, int q) {
        // write code here
        if(root == null) return -1;
        if((p >= root.val && q <= root.val) || (p <= root.val && q >= root.val)){
            return root.val;
        }else if(p <= root.val && q <= root.val){
            return lowestCommonAncestor(root.left, p, q);
        }else{
            return lowestCommonAncestor(root.right, p, q);
        }
    }
}

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @param p int整型 
     * @param q int整型 
     * @return int整型
     */
    public int lowestCommonAncestor (TreeNode root, int p, int q) {
        // write code here
        if(root == null) return -1;
        if(root.val == p){
            return p;
        }
        if(root.val == q){
            return q;
        }
        int left = lowestCommonAncestor(root.left, p, q);
        int right = lowestCommonAncestor(root.right, p, q);
        if(left != -1 && right != -1){
            return root.val;
        }else if (left != -1){
            return left;
        }else if(right != -1){
            return right;
        }

        return -1;
    }
}

BM38在二叉树中找到两个节点的最近公共祖先

在二叉树中找到两个节点的最近公共祖先

思路中等45.26%

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param root TreeNode类 
     * @param o1 int整型 
     * @param o2 int整型 
     * @return int整型
     */
    public int lowestCommonAncestor (TreeNode root, int o1, int o2) {
        // write code here
        if(root == null) return -1;
        if(root.val == o1){
            return o1;
        }
        if(root.val == o2){
            return o2;
        }
        int left = lowestCommonAncestor(root.left, o1, o2);
        int right = lowestCommonAncestor(root.right, o1, o2);
        if(left != -1 && right != -1){
            return root.val;
        }else if (left != -1){
            return left;
        }else if(right != -1){
            return right;
        }
 
        return -1;
    }
   
}

BM39序列化二叉树

序列化二叉树

思路较难25.04%

  • …过了

BM40重建二叉树

重建二叉树

思路中等27.70%

import java.util.*;
/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public int preIndex = 0;
    public TreeNode reConstructBinaryTree(int [] pre,int [] vin) {
        return buildTreeChild(pre, vin, 0, vin.length - 1); 
    }
    public TreeNode buildTreeChild(int[] pre, int[] vin, int begin, int end){
        if(begin > end) return null;
        TreeNode root = new TreeNode(pre[preIndex]);
        //找到中序遍历中节点位置
        int rootIndex = findInoederIndex(vin, begin, end, root.val);
        preIndex++;
        root.left = buildTreeChild(pre, vin, begin, rootIndex - 1);
        root.right = buildTreeChild(pre, vin, rootIndex + 1, end);
        return root;
    }
    public int findInoederIndex(int[] inorder, int begin, int end, int val){
        for(int i = begin; i <= end; i++) {
            if(inorder[i] == val){
                return i;
            }
        }
        return -1;
    }
}

BM41输出二叉树的右视图

输出二叉树的右视图

思路中等56.99%

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 求二叉树的右视图
     * @param xianxu int整型一维数组 先序遍历
     * @param zhongxu int整型一维数组 中序遍历
     * @return int整型一维数组
     */
    private HashMap<Integer, Integer> ans = new HashMap<>();
    private HashMap<Integer, Integer> map = new HashMap<>();
    public int[] solve (int[] xianxu, int[] zhongxu) {
        // write code here
        for (int i = 0; i < zhongxu.length; i++) {
            map.put(zhongxu[i], i);
        }
        build(xianxu, zhongxu, 0, xianxu.length - 1, 0);
        int[] tmp = new int[ans.size()];
        for (int i = 0; i < ans.size(); i++) {
            tmp[i] = ans.get(i);
        }
        return tmp;
    }
    //pIndex表示先序遍历的顺序i
    public int pIndex = 0;
    //index表示层级
    public void build(int[] xianxu, int[] zhongxu, int left, int right, int index) {
        if (left > right) {
            return ;
        }
        //找到在中序遍历中pIndex对应的值的下标
        int pindex = map.get(xianxu[pIndex++]);
        //左子树
        build(xianxu, zhongxu, left, pindex - 1, index + 1);
        //右子树
        build(xianxu, zhongxu, pindex + 1, right, index + 1);
        ans.put(index, zhongxu[pindex]);
    }
}
Gv_ee
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
牛客SQL刷题 Day-07
12-14
3、创建一个actor表，包含如下列信息 4、对于表actor批量插入如下数据 5、对于表actor批量插入如下数据,如果数据已经存在，请忽略，不使用replace操作 总结 1、获取select * from employees对应的执行计划 答案： ...
牛客简历助手-crx插件
04-02
*导入简历模板*若你在牛客网上已经编辑过个人简历，可选择一键将其信息导入到简历助手中。*高频词提示*经过大数据分析，我们将个网申简历系统中高频出现的信息备以高频词提示，助你快速有针对性地填写简历。*一键闪...
华为OD机试真题 - ABR 车路协同场 (D卷,100分)
han_xue_feng的博客
06-20 832
投了五六十家了，boss上没人回我。是这样的，之前拿到了小红书增长运营的offer，约定好了入职时间。求救，马上毕业了，帮选一下国家图书馆，一个月到手只有5k，不提供住宿，三餐自助，给户口，事业编制（这。后端软开岗1. 经纬恒润，北京，总包(N+7)w，公积金10%2. 小米，北京，总包(N+6)w，公。从开学开始看JavaGuide和小林Coding，东西太多，只看了一遍，面对网上各种分享的面经也是一。#正在实习的你，在做dirty work吗#实习第17天，感觉每天干的活很繁琐很基础，实习最重要的是。
刷穿剑指offer-Day04-第一章结束，聊聊算法学习
清风Python
08-20 218
昨日回顾 昨天我们介绍了求余和快速幂的相关知识，并且讲解了力扣50.实现pow的题目，主要是想让大家在理解了快速幂的实现，毕竟这是一道高频的面试考题。 但如果在算法机试或者平时开发时，还是使用内置的pow更为便捷，没必要重造轮子。 关于书中的题目 这章节今天就结束了，大家会说剑指offer中第三、第五题还没有讲。在这里需要解释下，虽然说的是刷穿剑指offer，但更多的是希望通过剑指offer这本书...
剑指offer打卡day03：二叉搜索树与双向链表 & 扑克牌顺子
COOLGWAYNE_TECH_BLOG
01-02 151
题1：二叉搜索树与双向链表 题目描述 输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。 说明：本题目包含复杂数据结构TreeNode，点此查看相关信息 解析： 双向链表： 在没有特指的情况下说链表一般指代“单向链表”，只能进行单项遍历，万一不行其中有一个链接断裂，那么后面的链表数据就无法复原了。 双向链表（Double LinkedList）在一个节点有两个指针变量，一个指向后面节点，一个指向前面的节点，可以双向通行。 优缺点： 优
牛客网在线编程题库——个人练习打卡记录（暂时停止）
Terio的博客
03-07 732
牛客网在线编程题库 个人学习记录，持续更新… 算法篇 Day1、 重建二叉树 ** 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。** 示例： 输入 [1,2,3,4,5,6,7],[3,2,4,1,6,5,7] 输出 {1,2,5,3,4,6,7} 题解 JAVA /** * Definition for bin
华为OD机试统一考试D卷C卷 - 单行道汽车通行时间/
每天多一点干货
05-30 1157
电子五所oc了，base广州，元材板块-前端(后端)开发面试问的内容主要针对简历上的实习和项目，比如。uu们，我目前研一快结束了，本科是二本，硕士西电，本硕都是电子信息，我想做嵌入式linux软件方向，1.自我介绍，2.介绍实习公司，介绍实习内容，问实习收获，3.问研究生导师方向，偏数学理论，觉得这样。#牛客在线求职答疑中心# 对于40波系统，OAU的输入共有8波，假设8波功率相同，输入的总功率为-7。#牛客在线求职答疑中心# 对于40波系统，OAU的输入共有8波，假设8波功率相同，输入的总功率为-7。
阿里灵犀互娱25转正实习-服务端/测开/产品/策划等
han_xue_feng的博客
05-30 668
我是江苏人，天津研二在读，项目经历都是用FPGA搭硬件系统，FPGA开发居多，模拟电路设计篇少。#23届二战失败# #23届找工作求助阵地# 今年有没有参加一些招24届同时还招23届的校招哇，想问。挺搞笑的，本人机械下面的工业设计工程专业，学校是985，转码选手，把java那些全看完了，现在发现自。本人双非本，211硕，目前研二下，之前一直在学校老老实实搞论文，然后现在正在写小论文还没投，导致我找。#我的求职思考# 有没有链接这两个公司的大佬，求推荐 #来聊聊你目前的求职进展# #如果可以选，你。
牛客的代码leetcode代码区别-niuke-c-:牛客-c-
06-30
牛客的代码leetcode代码区别 niuke-c-
leetcode题库-algorithm:剑指Offer+LeetCodeTop-100-Liked-Questions+CyC2018Lee
06-29
leetcode题库 希望各位能理解我的思路，从这...牛客和 LeetCode 的剑指 Offer 在输入输出，测试用例，甚至题目的要求上都会不同，建议都刷一下。 有各种问题或者有更好的解法希望各位能提 Issues 给我，我会尽力解决。
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 624
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Day43
m0_67496588的博客
06-20 705
JSON，Ajax
Geoserver源码解读三 GeoServerBasePage
Yuanben_wuxin的博客
06-19 953
GeoServerBasePage 登录
Javase.认识异常
最新发布
Joseit的博客
06-21 1135
在Java开发中，异常处理是确保程序稳定性和可靠性的关键环节。这篇blog深入解析了Java异常的概念、体系、处理策略及自定义异常类。它介绍了异常的基本概念与分类，详细阐述了异常抛出、捕获与处理的最佳实践，包括防御式编程策略、try-catch结构的使用、以及finally块在资源清理中的作用。此外，还涵盖了自定义异常类以满足特定业务需求的重要性。通过学习本blog，读者可以深入理解Java异常处理机制，提升代码质量。
高通Android 12/13 Launcher3修改RecentView与屏幕方向保持一致
qq_15950325的博客
06-18 357
最近同事遇到一个需求说，recentview应用预览与屏幕方向不一致，问题，于是加了一些日志，实现此需求。3、最后展示RecentView与屏幕方向保持一致。2、源码修改diff如下所示。源码修改路径汇总如下。
Java SE入门及基础（55）& Stream流及常用API
m0_63181360的博客
06-19 488
通过外部迭代，你的应用程序既可以确定要迭代的集合，又可以确定迭代的方式。它可以更轻松地利用并行计算的优势，这涉及将问题分为子问题，同时解决这些问题，然后将解决方案的结果组合到子问题中。）会产生非流结果，例如原始值（如双精度值），集合，或者在forEach的情况下根本没有任何值。它们处理流中的元素：聚合操作从流中而不是直接从集合中处理元素。流将一个基本数据类型的数组转换为包装类型的数组，再将包装类型的数组转换基本数据类型数组。筛选器操作返回一个新流，该流包含与筛选条件（此操作的参数）匹配的元素。
c# 学习笔记 PropertyChangedEventHandler、 =＞、DependencyObject、DataContext
汤圆
06-19 719
在C#中，和常常与接口一起使用，这是实现数据绑定和通知机制的关键部分，尤其在WPF (Windows Presentation Foundation) 或其他支持数据绑定的UI框架中。
java-System 概述 2
weixin_41247813的博客
06-18 813
模块化和高内聚性是设计优良系统的重要原则。`System`类通过`setSecurityManager`和`getSecurityManager`方法允许设置和获取当前的安全管理器（Security Manager）。`System`类中的许多方法（例如`currentTimeMillis`和`arraycopy`）都是通过类似的机制实现的。- **使用`arraycopy`进行数组拷贝**：与手动循环相比，`System.arraycopy`方法在性能上更优，因为它是本地实现的，直接操作内存。
python牛客84二叉树和为某一值的路径3
09-17
题目要求：给定一个二叉树和一个整数target，找出所有从根节点到叶子节点路径之和等于target的路径。 解题思路：可以使用深度优先搜索（DFS）的方法来解决该问题。首先定义一个辅助函数来进行递归搜索，该辅助函数的参数包括当前节点、当前路径、当前路径的和以及目标和。在搜索过程中，需要维护一个数组来保存当前节点到根节点的路径。搜索过程如下： 1. 如果当前节点为空，则返回。 2. 将当前节点的值添加到当前路径中。 3. 将当前节点的值累加到当前路径的和中。 4. 如果当前节点是叶子节点，且当前路径的和等于目标和，则将当前路径添加到结果中。 5. 递归地搜索当前节点的左子树和右子树，并传递更新后的当前路径和当前路径的和。 最后，在主函数中调用辅助函数，并返回结果即可。 以下是题目的完整代码实现： ```python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right def pathSum(root, target): def dfs(node, path, path_sum, target, res): if not node: return path.append(node.val) path_sum += node.val if not node.left and not node.right: # 当前节点是叶子节点 if path_sum == target: res.append(path[:]) # 注意需要复制一份path，否则会出现问题 dfs(node.left, path, path_sum, target, res) dfs(node.right, path, path_sum, target, res) path.pop() # 回溯到父节点，去掉当前节点 path_sum -= node.val res = [] dfs(root, [], 0, target, res) return res ``` 这样就能找出所有满足路径和等于目标和的路径了。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值