[剑指offer]大可日常打卡-树

想发故障诊断论文?手把手教你用CWRU数据集复现第一个Baseline模型 本文提供了一份基于CWRU轴承数据集的故障诊断Baseline模型实战指南,手把手教你从数据准备到模型构建的全流程。通过详细的Python代码示例和学术级实验设计,帮助初学者快速复现第一个故障诊断模型,为发表高质量论文奠定基础。 阅读详情

8.二叉树的下一个节点

    给定一个二叉树和其中的一个结点,请找出中序遍历顺序的下一个结点并且返回。注意,树中的结点不仅包含左右子结点,同时包含指向父结点的指针。

思路:中序遍历,左根右,

    如果一个节点右孩子不为空的话,那么返回他的右子树的最左节点;

    如果右孩子为空,可能有两种情况,(1)该节点是父节点的左节点,那么返回父节点即可,(2)该节点是父节点的右节点,那么把p指向它的父节点,一直往上指,直到p是p父节点的左孩子,返回p的父节点,p的父节点变成null了,说明该节点是最后一个节点,返回null。

    思路正确,第一次提交代码如下,但是超时了。

/*
public class TreeLinkNode {
    int val;
    TreeLinkNode left = null;
    TreeLinkNode right = null;
    TreeLinkNode next = null;

    TreeLinkNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public TreeLinkNode GetNext(TreeLinkNode pNode)
    {
        if(pNode==null){
            return pNode;
        }
        if(pNode.right!=null){
            pNode=pNode.right;
            while(pNode.left!=null){
                pNode=pNode.left;
            }
            return pNode;
        }
        
        
        if(pNode==pNode.next.left){
            return pNode.next;
        }else{
            TreeLinkNode p=pNode;
            while(p.next!=null){
                p=pNode.next;
                if(p==p.next.left){
                    return p;
                }
            }
            return null;
        }
    }
}

    调整完以后,如下,第二个过程之前写的太复杂了!所以超时!

/*
public class TreeLinkNode {
    int val;
    TreeLinkNode left = null;
    TreeLinkNode right = null;
    TreeLinkNode next = null;

    TreeLinkNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public TreeLinkNode GetNext(TreeLinkNode pNode)
    {
        if(pNode==null){
            return null;
        }
        if(pNode.right!=null){
            pNode=pNode.right;
            while(pNode.left!=null){
                pNode=pNode.left;
            }
            return pNode;
        }
        
        while(pNode.next!=null){
            if(pNode==pNode.next.left){
                return pNode.next; 
            }
            pNode=pNode.next;
            
        }
        return null;
        
    }
}

27.二叉树的镜像

    操作给定的二叉树,将其变换为源二叉树的镜像。

思路:递归解决。先交换根节点的左右子树,然后对于根节点的左右子树,进行递归。

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

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

    }

}
*/
public class Solution {
    public void Mirror(TreeNode root) {
        if(root==null){
            return;
        }
        if(root.left==null&&root.right==null){
            return;
        }
        
        TreeNode temp=root.left;
        root.left=root.right;
        root.right=temp;
        
        if(root.left!=null){
            Mirror(root.left);
        }
        if(root.right!=null){
            Mirror(root.right);
        }
    }
}

7.重建二叉树

    输入某二叉树的前序遍历和中序遍历的结果,请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6},则重建二叉树并返回。

思路:感觉也是要用递归了。加油77!多看一个题就多会一个,还有那么多要看呢。不要再胡思乱想啦!

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
import java.util.Arrays;
public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        if(pre==null||in==null||pre.length==0||in.length==0){
            return null;
        }
        TreeNode root=new TreeNode(pre[0]);
        for(int i=0;i<in.length;i++){
            if(in[i]==pre[0]){ //找到了root节点
                root.left=reConstructBinaryTree(Arrays.copyOfRange(pre,1,i+1),Arrays.copyOfRange(in,0,i));
                root.right=reConstructBinaryTree(Arrays.copyOfRange(pre,i+1,pre.length),Arrays.copyOfRange(in,i+1,in.length));
            }
        }
        return root;
    }
}

37.序列化二叉树

    请实现两个函数,分别用来序列化和反序列化二叉树。

思路:反序列化稍微复杂一丢丢。先维护一个整型变量index=-1,表示str的当前索引。

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

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

    }

}
*/
public class Solution {
    String Serialize(TreeNode root) {
        if(root==null){
            return "#,";
        }
        StringBuilder sb=new StringBuilder();
        sb.append(root.val+",");
        sb.append(Serialize(root.left));
        sb.append(Serialize(root.right));
        return sb.toString();
        
    }
    int index=-1;
    TreeNode Deserialize(String str) {
        index++;
        if(index>=str.length()){
            return null;
        }
        String[] values=str.split(",");
        TreeNode root=null;
        if(!values[index].equals("#")){
            root=new TreeNode(Integer.valueOf(values[index]));
            root.left=Deserialize(str);
            root.right=Deserialize(str);
            
        }
        return root;
    }
}

28.对称的二叉树

    请实现一个函数,用来判断一颗二叉树是不是对称的。注意,如果一个二叉树同此二叉树的镜像是同样的,定义其为对称的。

思路:两种遍历方法,比较两个是否一样。根左右-根右左

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

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

    }

}
*/
public class Solution {
    boolean isSymmetrical(TreeNode pRoot)
    { 
        return isSymmetrical(pRoot,pRoot);
    }
    boolean isSymmetrical(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 isSymmetrical(root1.left,root2.right)&&isSymmetrical(root1.right,root2.left);
    }
    
}

26.树的子结构

    输入两棵二叉树A,B,判断B是不是A的子结构。(ps:我们约定空树不是任意一个树的子结构)

思路:首先遍历树A找到与B根节点一致的节点,然后再看B是不是包含于A,所以分为两步!

对于A中的每一个节点,递归调用HasSubtree,递归出口是某一个节点的val和A的根节点的val一致,然后对这两个节点开始调用DoesRoot1HasRoot2;

在DoesRoot1HasRoot2的调用过程中,递归出口是root2==null,表示root2已经遍历完,遍历完说明是包含的,都走到这一步!如果root2还没有遍历完root1就走完了,说明不包含,如果左右子节点有一个不相同那么也说明不包含,直接返回false,不往下走了。

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

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

    }

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

32.从上到下打印二叉树

    从上往下打印出二叉树的每个节点,同层节点从左至右打印。

思路:把节点存到一个ArrayList<Integer>里面。77加油!上个厕所继续想!也是考查二叉树遍历算法,只不过不是我们熟悉的前序、中序、后序遍历,是按层遍历,可以先通过分析一个例子来找到思路。

    用一个队列,当打印根节点以后,就把左孩子和右孩子都放入队列中,然后从队列取一个数,再把它的左孩子右孩子放入队列中,直到队列为空,就打印完毕。

import java.util.ArrayList;
/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

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

    }

}
*/
import java.util.Queue;
import java.util.ArrayList;
import java.util.LinkedList;
public class Solution {
    
    public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
        ArrayList<Integer> res=new ArrayList<Integer>();
        if(root==null){
            return res;
        }
        
        Queue<TreeNode> queue=new LinkedList<>();
        //res.add(root.val);
        queue.add(root);
        while(!queue.isEmpty()){
            TreeNode node=queue.poll();
            res.add(node.val);
            if(node.left!=null){
                queue.add(node.left);
            }
            if(node.right!=null){
                queue.add(node.right);
            }
        }
        return res;
    }
}

33.二叉搜索树的后序遍历序列

    输入一个整数数组,判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

思路:写一个实例进行分析一下。因为是后序遍历,所以最后一个数是根。首先思考一个整数数组怎么样才不是一棵二叉搜索树的后序遍历结果,所以要想二叉搜索树的后序遍历结果有什么特征!!!不满足这个特征的就不是!!!

    首先二叉搜索树的特征是什么,左孩子小于根节点,右孩子大于根节点。

import java.util.Arrays;
public class Solution {
    public static boolean VerifySquenceOfBST(int [] sequence) {
        if(sequence==null||sequence.length==0){
            return false;
        }
        int len=sequence.length;
        int root=sequence[len-1]; //根节点
        int i;
        for(i=0;i<len-1;i++){
            if(sequence[i]>root){ //右子树的开始部分
                
                break;
            }
        }
        //System.out.println(startr);
        for(int j=i;j<len-1;j++){  //右边的要是有小于root的,那么就返回false
            if(sequence[j]<root){
                return false;
            }
        }
        boolean left=true;
        if(i>0){
            left=VerifySquenceOfBST(Arrays.copyOfRange(sequence,0,i));
        }
        boolean right=true;
        if(i<len-1){
            right=VerifySquenceOfBST(Arrays.copyOfRange(sequence,i,len-1));
        }
        
        return left&&right;
    }
}

最需要注意的是,在寻找右子树的第一个节点位置的时候,必须要和i一致,因为有可能只有左子树啊!!

34.二叉树中和为某一值的路径

    输入一颗二叉树和一个整数,打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。

思路:寻找思路。因为路径定义为从根节点开始往下,树一共有三种遍历方式,前序、中序和后序,只有前序是先访问根节点的!当用前序遍历的方式访问到某一结点时,我们把该节点加入到路径上,并累加该节点的值。如果该节点为叶节点,并且路径中的和刚好等于输入的整数,那么当前路径符合要求。如果当前节点不是叶节点,那么继续访问它的子节点。当前结点访问结束后,递归函数自动回到它的父节点。因此,我们在函数退出之前要在路径上删除当前节点并减去当前节点的值,以确保返回父节点时路径刚好是从根节点到父节点。

import java.util.ArrayList;
/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

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

    }

}
*/
public class Solution {
    ArrayList<ArrayList<Integer>> pathlist=new ArrayList<ArrayList<Integer>>();
    ArrayList<Integer> path=new ArrayList<Integer>(); //全局变量
    public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) {
        if(root==null){
            return pathlist; 
        }
        path.add(root.val);
        target-=root.val;
        if(target==0&&root.left==null&&root.right==null){
            pathlist.add(new ArrayList<Integer>(path));
        }
        FindPath(root.left,target);
        FindPath(root.right,target);
        path.remove(path.size()-1); //完了以后要删除最后一个
        return pathlist;
    }
}

36.二叉搜索树与双向链表

    输入一棵二叉搜索树,将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点,只能调整树中结点指针的指向。

思路:举个例子寻找思路。七七加油~左孩子的最右节点指向根节点,根节点指向右孩子的最左节点~是一个左根右遍历的过程。

(1)先把左子树变成双向链表,返回left;

(2)到左子树双向链表的最后一个;

(3)接起来;

(4)把右子树变成双向链表;

(5)右子树和root之前的接起来;

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

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

    }

}
*/
import java.util.LinkedList;
public class Solution {
    public TreeNode Convert(TreeNode pRootOfTree) {
        LinkedList<Integer> list=new LinkedList();
        if(pRootOfTree==null){
            return pRootOfTree;
        }
        if(pRootOfTree.left==null&&pRootOfTree.right==null){
            return pRootOfTree;
        }
        TreeNode left=Convert(pRootOfTree.left);
        TreeNode p=left;
        while(p!=null&&p.right!=null){
            p=p.right;
        }
        if(left!=null){
            p.right=pRootOfTree;
            pRootOfTree.left=p;
        }
        
        
        TreeNode right=Convert(pRootOfTree.right);
        TreeNode q=right;
        if(q!=null){
            pRootOfTree.right=q;
            q.left=pRootOfTree;
        }
        if(left!=null){
            return left;
        }
        return pRootOfTree;
        //return left;
    }
}

54.二叉搜索树的第k大节点

    给定一颗二叉搜索树,请找出其中的第k小的结点。例如, 5 / \ 3 7 /\ /\ 2 4 6 8 中,按结点数值大小顺序第三个结点的值为4。

思路:写一个例子寻找思路,二叉搜索树按照中序遍历的顺序打印出来正好就是排好序的顺序,左中右,所以就使用一个计数器,从1开始,每遍历一个数,就计数器+1,直到计数器=k,那么当前遍历到的节点就是二叉搜索树的第k大节点。

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

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

    }

}
*/
public class Solution {
    int index=0;
    TreeNode KthNode(TreeNode pRoot, int k)
    {
        if(pRoot==null||k<1){
            return null;
        }
        TreeNode node=KthNode(pRoot.left,k);
        if(node!=null){
            return node;
        }
        index++;
        if(index==k){
            return pRoot;
        }
        node=KthNode(pRoot.right,k);
        if(node!=null){
            return node;
        }
        return null;
    }
}

55.二叉树的深度

    输入一棵二叉树,求该树的深度。从根结点到叶结点依次经过的结点(含根、叶结点)形成树的一条路径,最长路径的长度为树的深度。

思路:维护一个动态的max。

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

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

    }

}
*/
public class Solution {
    
    public int TreeDepth(TreeNode root) {
        int max=0;
        //int depth=0;
        if(root==null){
            return 0;
        }
        int left=0;
        if(root.left!=null){
            left=TreeDepth(root.left);
        }
        int right=0;
        if(root.right!=null){
            right=TreeDepth(root.right);
        }
        max=Math.max(left+1,right+1);
        return max;
        
    }
}

牛客上关于树的剑指offer专版多的两道题:

1.按之字形顺序打印二叉树

    请实现一个函数按照之字形打印二叉树,即第一行按照从左到右的顺序打印,第二层按照从右至左的顺序打印,第三行按照从左到右的顺序打印,其他行以此类推。

思路:这个题七七你之前写过哦~~写不出来是不是太不厉害了~

    先找一个例子进行分析,不要一看到这种需要稍微思考一下的题就被它吓住了。首先肯定是二叉树按层遍历吧,然后把每一层的都存到一个ArrayList里面,然后对于某一层的,reverse一下。

    二叉树的按层遍历还记得吗,有一个队列,遍历过的节点放到队列里面,然后取出一个就把它的左孩子和右孩子压进去,直到队列为空,遍历完毕。

import java.util.ArrayList;

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

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

    }

}
*/
import java.util.LinkedList;
import java.util.Iterator;
public class Solution {
    public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer> > res=new ArrayList<>();
        if(pRoot==null){
            return res;
        }
        ArrayList<Integer> arr=new ArrayList<>();
        LinkedList<TreeNode> queue=new LinkedList<>();
        queue.addLast(null); //层分隔符
        queue.addLast(pRoot); 
        boolean leftToright=true;
        while(queue.size()!=1){
            TreeNode node=queue.removeFirst();
            if(node==null){ //如果到达了层分隔符,也就是说一层打印完毕了~
                Iterator<TreeNode> iter=null; //
                if(leftToright){
                    iter=queue.iterator();
                }else{
                    iter=queue.descendingIterator();//降序
                }
                leftToright=!leftToright; //改为相反的
                while(iter.hasNext()){
                    TreeNode tmp=iter.next();
                    arr.add(tmp.val);
                }
                res.add(new ArrayList<Integer>(arr));
                arr.clear();
                queue.add(null);
                continue;
            }
            if(node.left!=null){
                queue.addLast(node.left);
            }
            if(node.right!=null){
                queue.addLast(node.right);
            }
        }
        return res;

    }

}

2.把二叉树打印成多行

    从上到下按层打印二叉树,同一层结点从左至右输出。每一层输出一行。

思路:思路同上。

import java.util.ArrayList;


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

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

    }

}
*/
import java.util.LinkedList;
import java.util.Iterator;
public class Solution {
    ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> res=new ArrayList<>();
        if(pRoot==null){
            return res;
        }
        ArrayList<Integer> list=new ArrayList<>();
        LinkedList<TreeNode> queue=new LinkedList<>();
        queue.addLast(null);
        queue.addLast(pRoot);
        while(queue.size()!=1){
            TreeNode node=queue.removeFirst();
            Iterator<TreeNode> iter=null;
            if(node==null){
                iter=queue.iterator();
                while(iter.hasNext()){
                TreeNode tmp=iter.next();
                list.add(tmp.val);
                }
                res.add(new ArrayList(list));
                list.clear();
                queue.add(null);
                continue;
            }
            if(node.left!=null){
                queue.addLast(node.left);
            }
            if(node.right!=null){
                queue.addLast(node.right);
            }
            
            
        }
        return res;
    }
    
}

【DEIM创新改进】独家下采样创新改进篇 | ECCV 2026 | DEIM 引入FSD-Down频域-空间动态下采样,在下采样过程中保留小目标的高频信息、助力小目标检测、遥感小目标检测有效涨点 🔥本文提出了一种名为FSD-Down的频域-空间动态下采样模块,用于改进DEIM网络模型在小目标检测中的性能。FSD-Down通过小波分解显式保留低频语义和高频细节,结合分组卷积、动态通道权重和可学习缩放因子,自适应强化目标边缘与纹理特征。该模块能有效减轻传统下采样造成的频率混叠和细节丢失,提升对小目标、密集目标和低对比度目标的检测能力。实验表明,FSD-Down计算开销可控,在保持实时性的同时显著提升检测精度,特别是在VisDrone和AITODv2数据集上对小目标的检测性能提升显著。 阅读详情

相关推荐

ADS2016子电路封装避坑指南:手把手教你制作可复用的自定义Symbol

本文详细介绍了在ADS2016中制作可复用的自定义Symbol的全流程,重点解析了子电路封装的常见问题与解决方案。从电路模块的标准化处理、Hierarchy创建技巧到Symbol视觉优化和库管理策略,帮助工程师提升射频与微波电路设计效率。特别针对Symbol比例适配和引脚优化等核心问题,提供了实用的避坑指南和工程验证方法。

weixin_30275415的博客 224

《剑指offer》刷题打卡第4天

算法和数据操作: 算法考查:排序和查找是算法考查的重点。二分查找、归并排序和快速排序。 如果我们需要重复的多次计算相同的问题,则通常可以选择用递归或者循环两种不同的方法。 递归是在一个函数的内部调用这个函数自身。而循环则是通过设置计算的初始值及终止条件,在一个范围内重复运算。 比如求1+2+…+n 用递归实现: int AddFrom1ToN_Recursive(int n) { Return n...

tpf930726的博客 1508

对计算机专业来说学历真的重要吗?

我本科学校是渣渣二本,研究生学校是985,现在毕业五年,校招笔试、面试,社招面试参加了两年了,就我个人的经历来说下这个问题。 这篇文章很长,但绝对是精华,相信我,读完以后,你会知道学历不好的解决方案,记得帮我点赞哦。 先说结论,无论赞不赞同,它本质就是这样:对于技术类工作而言,学历五年以内非常重要,但有办法弥补。五年以后,不重要。 目录: 张雪峰讲述的事实 我看到的事实 为什么会这样 ...

启舰 55万+

剑指offer打卡计划、建议(持续进行)

文章目录这个寒假,我们一起搞透剑指offer。 这个寒假,我们一起搞透剑指offer。 这个寒假笔者打算和大家一起开启刷题计划,先搞剑指offer。如果氛围可以可以持久搞leetcode。 至于刷题计划,因为剑指offer的牛客专题是67道有限的,我想着稍微高点强度的要把剑指offer先搞完。当然至于每天大概的计划还是要根据大部分人的具体情况分析。每晚我打算先把我的题解给大家参考一起讨论,然后把阶...

bigsai 8774

别再乱删文件了!修复Print Spooler服务自动停止的3个关键检查点(附Win10/Win11实测)

本文深入解析Windows系统中Print Spooler服务自动停止的常见原因及修复方法。从第三方驱动冲突、权限与服务依赖关系到打印队列积压,提供3个关键检查点的详细排查步骤,帮助用户彻底解决打印服务异常问题,适用于Win10/Win11系统。

weixin_31569671的博客 682

把收款差异从扯皮变成闭环:SAP S/4HANA Dispute Resolution 模块到底解决什么问题?

本文摘要: SAP S/4HANA的争议解决模块(Dispute Resolution)通过标准化流程管理企业应收争议,解决发票与收款差异问题。核心是创建可追踪的Dispute Case工单,明确处理角色(Processor和Manager),并与财务系统联动实现自动清账。系统支持手工/自动创建争议工单,通过动态默认值减少错误,并最终实现争议金额归零的闭环管理。文中给出制造业客户扣款的完整处理案例,并强调组织落地需统一权限与目录。最后提供ABAP代码示例展示如何通过BAPI创建争议工单。(150字)

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 168

[剑指offer]大可日常打卡-数组

4.二维数组中的查找 题目描述:在一个二维数组中(每个一维数组的长度相同),每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序。请完成一个函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数。 思路:从右上角的数开始比,要是等于就返回true;小于target就row++;大于target就col--,所以列的--应该在最外层循环,满足当前列所对应的那个条件,r...

hellodake的博客 298

防护装备穿戴检查:基于YOLOv8与UI界面的深度学习应用

通过结合YOLOv8模型与UI界面,本系统实现了防护装备穿戴检查的自动化。该系统能够快速识别工作人员是否正确佩戴了所需的防护装备,帮助提高安全管理水平。未来,随着技术的发展,防护装备穿戴检查系统将在更多领域得到应用,如工业现场、建筑工地等,实现更加精确和高效的实时监控。

YOLO 355

[剑指offer]大可日常打卡-递归

43.1~n整数中1出现的次数 题目描述:求出1~13的整数中1出现的次数,并算出100~1300的整数中1出现的次数?为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数(从1 到 n 中1出现的次数)。 思路:遍历?每一个都算一下?暴力拆解!...

hellodake的博客 201

ROCm rocr-libhsakmt分析系列9-3: queue的内核创建流程

KFD队列是用户空间与GPU通信的核心机制,通过多种队列类型(计算、DMA、调试等)实现命令流管理。核心数据结构包括描述队列属性的queue_properties、内核调度对象queue、进程级管理器process_queue_manager,以及跨进程设备的qcm_process_device等。这些结构通过ring buffer、doorbell机制和MQD硬件描述符协同工作,支持队列全生命周期管理、资源调度、异常处理和上下文保存/恢复功能。

图形/计算GPU的驱动与虚拟化技术分享园地 2134

mediasoup源码分析(二十)服务端架构设计

目录 简介 信令服务(房间服务) 调度服务 媒体服务 简介 流媒体服务器大的方向上可以分为上述三个模块。目前行业内都是分布式服务,独立部署。mediasoup信令与媒体之间虽然可以管道通信。但在行业内,服务之间通过管道通信用的少。 一般是rpc、mq,或者传统的tcp。这块licode架构比较不错,licode是信令和媒体服务通过MQ消息队列解耦。 下面介绍一下这三个服务主要功能,当然文中所说也是一家之言。 信令服务(房间服务) 信令服务也称为房间服务。有的企业把信令和房间分开,信..

lcalqf的专栏 1547

leetcode:剑指Offer第二版 C++个人笔记分享,Git代码分享

leetcode:剑指Offer第二版 C++个人笔记分享,Git代码分享引言正文后记说明 引言 之前在刷剑指Offer时,有做一些题解记录和分析,但是其实想起做学习笔记的时候,题已经刷的差不多了。 后来,本来打算每天刷题的时候都做一下笔记,但是刷了两天,又被拉去干活了,于是我的学习笔记就断了。 没办法,该干活还是得干活,笔记只能往后再找时间补上来。但是做了的题还是得分享一下,于是打算把自己的做题代码分享到Git,然后做一下Git的分享笔记。 正文 剑指Offer第二版个人做题记录:Git纯享版/其实我就是

weixin_42329812的博客 315

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

[剑指offer]大可日常打卡-链表

6.从尾到头打印链表 题目描述:输入一个链表,按链表值从尾到头的顺序返回一个ArrayList。 /** * public class ListNode { * int val; * ListNode next = null; * * ListNode(int val) { * this.val = val; * ...

hellodake的博客 211

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

[剑指offer]大可日常打卡-字符串

5.替换空格     请实现一个函数,将一个字符串中的每个空格替换成“%20”。例如,当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。 public class Solution { public String replaceSpace(StringBuffer str) { if(str==null||str.length()...

hellodake的博客 224

Leetcode 剑指 Offer II 081.组合总和

学历:2本中9硕南方人,毕业后想在南方(广州,深圳)目前研一,由于是年轻导师,组内可供参考的经验比较。苏州事业单位,没编制,合同制,包吃住,8:30-6:00,双休,五险二金顶格交,假期比较多,其他不确。在外包公司实习对秋招帮助大吗,当时以为大外包比小公司强,去了浩鲸科技实习,现在肠子都悔青了,大外包实。鼠鼠双非本末流211硕,有过一门挂科,六级没过,无实习,秋招想all in 国企和银行可行吗,挂科和。能投啥公司啊,只顾着在学,然后各招聘网站没看见多少实习,八股什么的都背了,算法没坚持刷下去。

华鑫的专栏 689

******** 剑指 Offer II 084.全排列 II

本人2025届毕业生,双非本硕,想走数据开发,项目只跟着swg做了个离线数仓,没有实习经历6月份投了。各位大佬,现在想在找些日常实习填补暑假没事做,但是项目算法和八股都不太行,只是练练手,没找到的话,九。研究生打了两年黑工,对找工作没用,对毕业也没什么用,不知道读研读了个啥,也怪自己没有尽早确立一个方向。有个问题,我现在大三(未毕业),找了一个go程序开发的工作,但是老板说我不产量不给工资,等产量了再给。突然今天想起来写,是华子居然开奖了,泡了我俩月...投递了70多家公司,最后就淘天(offer)、网。

华鑫的专栏 946

Coding日历

剑指 75 剑指专项 119 程序员 109 hot100 100 精选1 200 精选2 145 腾讯 50 总计 798

山中有石为玉 438
上一篇: [核心技术36问]1-12
下一篇: [leetcode]大可日常打卡-树
hellodake
博客等级 码龄10年 24粉丝 101原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值