思路思维，实践第一。

已于 2022-09-24 18:07:35 修改
阅读量60 收藏
点赞数
分类专栏： 面试题 文章标签： java
于 2022-04-26 20:02:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42434039/article/details/124435762
版权

今天是美团测试面试，没想到给了我一道，层次遍历，我没写出来。因为我写代码就只是看书看答案，没有动手实践，这样导致了随便一个小问题，比如队列的具体实现，都能把我击垮，而且我没解决问题能力；这次侮辱折现出我的问题，眼高手低，没独立思考能力，而且手生了记性也差了。
任何事情一定要亲自动手独立的做一遍，光看书就废了。这是我的人生座右铭了。

不要光看实现，要多看代码实现的原理。
这里只写我自己写过得代码。

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<>>
     */
    //[[1],[2,3],[4,5]]
    public ArrayList<ArrayList<Integer>> levelOrder (TreeNode root) {
        // write code here
        ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
        //根节点为空，直接返回res
        if(root == null)
            return res;
        if(root !=null){
            Queue<TreeNode> queue = new LinkedList<>();
            queue.offer(root);
            while(!queue.isEmpty()){
                int size = queue.size();
                ArrayList<Integer> level = new ArrayList<Integer>();
                while(size-->0){
                    TreeNode temp = queue.poll();
                    level.add(temp.val);
                    if(temp.left!=null)
                        queue.offer(temp.left);
                    if(temp.right!=null)
                        queue.offer(temp.right);
                }
                res.add(level);
            }
        }
        return res;        
    }
}

package com.sydx.aqsc.ctrl;

import javax.swing.tree.TreeNode;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;


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


class Solution {
    /**
     *
     * @param root TreeNode类
     * @return int整型ArrayList<ArrayList<>>
     */
    //[[1],[2,3],[4,5]]
    public ArrayList<ArrayList<Integer>> levelOrder (TreeNode root) {
        // write code here
        ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
        Queue<TreeNode> q=new LinkedList<>();
        q.add(root);
        while(!q.isEmpty()){
            int a=q.size();
            ArrayList<Integer> t=new ArrayList<>();
            while(a--!=0){
                TreeNode tmp=q.poll();
                t.add(tmp.val);
                if(tmp.left!=null)
                    q.add(tmp.left);
                if(tmp.right!=null)
                    q.add(tmp.right);
            }
            res.add(t);
        }

        return res;
    }
}



/**
 * 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 CBTInserter {

        private Queue<TreeNode> queue;
        private TreeNode root;
    public CBTInserter(TreeNode root) {
        this.root=root;
        Queue<TreeNode> q=new LinkedList<>();
        q.add(root);
        while(!q.isEmpty()){
            TreeNode tmp=q.poll();
            if(tmp.left!=null)
                q.add(tmp.left);
            if(tmp.right!=null)
                q.add(tmp.right);

        }
    }

    public int insert(int v) {
        Queue<TreeNode> q=new LinkedList<>();
        q.add(root);
        TreeNode a =new TreeNode(v);
        while(!q.isEmpty()){
            TreeNode tmp=q.poll();
            if(tmp.left!=null)
                q.add(tmp.left);
            else{
                tmp.left=a;
                return tmp.val;
            }
            if(tmp.right!=null)
                q.add(tmp.right);
            else{
                tmp.right=a;
                return tmp.val;
            }

        }
        return 0;
    }

    public TreeNode get_root() {
        return this.root;
    }
}

/**
 * Your CBTInserter object will be instantiated and called as such:
 * CBTInserter obj = new CBTInserter(root);
 * int param_1 = obj.insert(v);
 * TreeNode param_2 = obj.get_root();
 */

/**
 * 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 CBTInserter {

        private Queue<TreeNode> queue;
        private TreeNode root;
    public CBTInserter(TreeNode root) {
        this.root=root;
 
 
    }

    public int insert(int v) {
        Queue<TreeNode> q=new LinkedList<>();
        q.add(root);
        TreeNode a =new TreeNode(v);
        while(!q.isEmpty()){
            TreeNode tmp=q.poll();
            if(tmp.left!=null)
                q.add(tmp.left);
            else{
                tmp.left=a;
                return tmp.val;
            }
            if(tmp.right!=null)
                q.add(tmp.right);
            else{
                tmp.right=a;
                return tmp.val;
            }

        }
        return 0;
    }

    public TreeNode get_root() {
        return this.root;
    }
}

 

/**
 * 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 CBTInserter {
        private Queue<TreeNode> q;
        private TreeNode root;
    public CBTInserter(TreeNode root) {
        this.root=root;
        this.q=q;
        Queue<TreeNode> q=new LinkedList<>();//重新赋值了
        q.add(root);
        while(q.peek().left!=null&&q.peek().right!=null){
            TreeNode tmp=q.poll();
            if(tmp.left!=null)
                q.add(tmp.left);
            if(tmp.right!=null)
                q.add(tmp.right);

        }
    }

    public int insert(int v) {
        TreeNode parent= q.peek();
        TreeNode node=new TreeNode(v);
         if(parent.left==null) {
             parent.left = node;
 
         }
        if(parent.right==null) {//错误
            parent.right = node;
            q.poll();
            q.add(parent.left);
            q.add(parent.right);
        
        }
             return parent.val;
    }

    public TreeNode get_root() {
        return this.root;
    }
}

/**
 * Your CBTInserter object will be instantiated and called as such:
 * CBTInserter obj = new CBTInserter(root);
 * int param_1 = obj.insert(v);
 * TreeNode param_2 = obj.get_root();
 */

{
    private int[] cost;
    public int minCostClimbingStairs(int[] cost) {
        this.cost=cost;
        int size=cost.length;
        
       return Math.min(dfs(size-1), dfs(size-2));
    }

    private int  dfs(int i) {
        if(i<2)return cost[i];
        return  Math.min(dfs(i-1), dfs(i-2));
    }

}

class Solution {
    private int[] cost;
    private int[] dp;
    public int minCostClimbingStairs(int[] cost) {
        this.cost=cost;
        int size=cost.length;
          dp=new int[size];
          helper(size-1);
          if(size==2)return Math.min(cost[1], cost[0]);
          else if(size==1)return cost[0];
       else return Math.min(dp[size-1], dp[size-2]);
    }

    private void  helper(int i) {
        if(i<2){
            dp[i]=cost[i];
            System.out.println(dp[i]);
    }
        else if(dp[i]==0){
            helper( i-1);
            helper(i-2);
            dp[i]= Math.min(dp[i-1], dp[i-2])+cost[i];
        }
        
    }

}

class Solution {
    public int divide(int a, int b) {
            if (a == 0x80000000 && b == -1){
        return Integer.MAX_VALUE;
    }
                if (a ==Integer.MAX_VALUE && b == 1){
        return Integer.MAX_VALUE;
    }
        int nag=1;
        if(a<0){
            nag*=-1;
            a=-a;
        }
        if(b<0){
            nag*=-1;
            b=-b;
        }
        int res=0;
        while(a>=b){
            int t=b;
            int count=1;
            while(a>=2*t){
                count*=2;
                t=t+t;
            }
            res+=count;
            a=a-t;
        }
        return res*nag;
    }
}

 

class Solution {
    public String addBinary(String a, String b) {
        StringBuilder result=new StringBuilder();
        int i=a.length()-1;
        int j=b.length()-1;
        int jinwei=0;
        while(i>=0||j>=0){
            int digitalA=i>=0?a.charAt(i--)-'0':0;
            int digitalB=j>=0?b.charAt(j--)-'0':0;
            int sum=digitalA+digitalB +jinwei;
            if(sum>=2) {
                jinwei = 1;
                result.append(sum-2);
            }
            else  {
                result.append(sum);
                 jinwei=0;
            }
        }
          if(jinwei==1)
               result.append(1);
        return result.reverse().toString();
    }
}

 字符计算，分两种情况

class Solution {
    public String addBinary(String a, String b) {
        StringBuilder result=new StringBuilder();
        int i=a.length()-1;
        int j=b.length()-1;
        int jinwei=0;
        while(i>=0||j>=0){
            char digitalA=i>=0?a.charAt(i--):'0';
            char digitalB=j>=0?b.charAt(j--):'0';
            int sum=digitalA-'0'+digitalB-'0'+jinwei;
        System.out.println(sum);
            if(sum>=2) {
             
                 
                result.append(sum-2);
                jinwei = 1;
            }
            else  {
 
                
                result.append(sum);
                 jinwei=0;
            }
 
        }
          if(jinwei==1)
               result.append(1);
        return result.reverse().toString();
    }
}

循环+变量维护

class Solution {
    public int[] countBits(int n) {
        int count=0;
        int[] res=new int[n+1];
        while(n>=0){
            int i=n;
        while(i!=0){
            count++;
            i=i&(i-1);
        }
        res[n]=count;
        count=0;
        n--;
    }
    return res;
}
}

双循环提高维度 位移

class Solution {
    public int singleNumber(int[] nums) {
        int[] bit=new int[32];
        for(int num:nums){
            for(int i=0;i<32;i++){
                int nume=num>>31-i;     
                bit[i]+=(nume&1);
                
            }
        }
        int result=0;
        for(int i=0;i<32;i++){
            result=result*2+bit[i]%3;
        }
        return result;
    }
}

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int i=0,j=numbers.length-1;
        while(i<j){
            int s=numbers[i]+numbers[j];
            if(s<target){
                i++;
            }
            else if(s>target){
                j--;
            }
            else break;
        }
        return new int[]{i,j};
    }
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res=new LinkedList<>();
     
            Arrays.sort(nums);
        for(int i=0;i<nums.length-2;){
            two(nums,i,res);
            int temp=nums[i];
            while(i<nums.length &&temp==nums[i]){
                i++;
            }
        }
    
      return res;
    }
    private void two(int[] nums, int i, List<List<Integer>> res) {
        int m=i+1;
        int n= nums.length-1;
        while (m<n ){
            if(nums[m]+nums[n]+nums[i]==0){
                ArrayList<Integer> rt=new ArrayList<>();
                rt.add(nums[i]);
                rt.add(nums[m]);
                rt.add(nums[n]);
                res.add(rt);
                int temp=nums[m];
                while(m<n&&temp!=nums[m]){
                    m++;
                }
            }
            else if(nums[m]+nums[n]+nums[i]<0){
                m++;
            }
            else
                n--;
        }
 
    }
}


/**
 * 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 boolean isPalindrome(ListNode head) {
        if (head == null || head.next == null) {
            return true;
        }
        ListNode dummy=new ListNode(0);
        dummy.next=head;
        ListNode slow=dummy;
        ListNode fast=dummy;
        while(fast!=null&&fast.next!=null){
            slow=slow.next;
             fast=fast.next;
            if(fast.next!=null)
                fast=fast.next;
        }
        ListNode t=slow.next;
        ListNode s=reverseList(t);
        ListNode m=head;
        while(s!=null){
            if(m.val!=s.val)
                return false;
                m=m.next;
                s=s.next;
        }
        return true;
    }
        private ListNode reverseList(ListNode head1) {
        ListNode pre=null ;
        ListNode cur=head1;
        while(cur!=null){
            ListNode next=cur.next;
            cur.next=pre;
            pre=cur;
            cur=next;
        }
        return pre;
    }
}

 

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer>  stack=new Stack<>();
        for(String token:tokens){
            if(token.equals("*")||token.equals("/")||token.equals("+")||token.equals("-")){
                int num2=stack.pop();
                int num1=stack.pop();
                if(token.equals("*")){
                    stack.push(num1*num2);
                }
                else if(token.equals("/")){
                    stack.push(num1/num2);
                }
                else if(token.equals("+")){
                    stack.push(num1+num2);
                }
                else  if(token.equals("-")){
                    stack.push(num1-num2);
                }
            }
            else
                stack.push(Integer.parseInt(token));
        }
        return stack.pop();
    }
}

class Solution {
    public int[] asteroidCollision(int[] asteroids) {
        Stack<Integer> stack = new Stack<>();
        for(int as:asteroids){
            while (!stack.empty()&&stack.peek()<-as&&stack.peek()>0) {
                stack.pop();
            }
             if(!stack.isEmpty()&&stack.peek()>0&&as==-1*stack.peek()){
                 stack.pop();
             }
            else if(stack.isEmpty()||as>0||stack.peek()<0){
                stack.push(as);
            }
        }
        int [] res=new int[stack.size()];
        int i=0;
        for (int s:stack){
            res[i++]=s;
        }
        return res;
    }
}
Spring（小雨点）
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【架构实践】软件研发的第一性原理
禅与计算机程序设计艺术
03-11 2万+
更可行的思路是解决电池的原料问题，因为电池的原材料是相对固定的，这才是最基础的出发点。，正如樊登在其《低风险创业》一书中说，如果创业时钱多不是好事，因为钱多就猛招人、大做广告、买流量等，表面上看，不好的产品销售不错，会给自己错觉，觉得开发出来的产品是好产品，但最后钱烧光了，产品卖不出去了，还要裁人。首先，必须说，这种思考方法非常耗费脑力，因为需要透过现象找到最本质的，最为真实的元素作为基础，在电池的例子中，如果马斯克归因的结果是供应商的问题，说服他们降价，那么不仅会导致关系紧张，也没有办法解决问题。
架构思维第一篇
Just Do It!
05-26 435
定义与实现解耦，运行时加载实现 代表性实现方式就是java里面的SPI机制。比如mysql的驱动mysql-connector-java里面有个MATA-INF/services目录，里面定义具体驱动类，这些驱动类都实现Driver类接口。 如下图所示： 驱动加载类如下： 系统的可扩展性可以遵循标准、识别、注册、运行总的法则去演化不同的具体的实现，可以根据实际的场景选择合适的方法，不再是 SPI，思维就会打开很多。如 Spring 通过 PostProcessor 开放了用户自定..
了解抽象思维的应用与实践
热门推荐
张彦峰的博客
11-25 3万+
抽象思维是一种认知和思维方式，通过在众多事物中提取共同的、本质性的特征，舍弃非本质的特征，形成概念、判断、推理等思维形式，以反映事物的本质和规律。抽象是将复杂的现实世界简化为更易于理解和处理的概念或模型的过程。这种思维方式使人们能够通过一般性的规律和原则来理解和处理复杂的现实情境。在抽象思维中，人们通过对感性材料的加工制作，去粗取精、去伪存真，从具体事物中提炼出普遍性的特征。这有助于人们更有效地组织和理解信息，提高认知效率，并使得复杂的问题变得更加可管理。
SDU 程序设计思维实践 第四周 csp模拟
Anadem‘s Blog
03-11 1990
题目A - 咕咕东的奇遇 题意 咕咕东是个贪玩的孩子，有一天，他从上古遗迹中得到了一个神奇的圆环。这个圆环由字母表组成首尾相接的环，环上有一个指针，最初指向字母a。咕咕东每次可以顺时针或者逆时针旋转一格。例如，a顺时针旋转到z，逆时针旋转到b。咕咕东手里有一个字符串，但是他太笨了，所以他来请求你的帮助，问最少需要转多少次。 Input zeus Output 18 思路 考虑上衣字符拨到当前...
程设思维实践-实验E1
weixin_51649539的博客
02-23 3379
程设思维实践-实验E1本次实验线上进行，推荐大家使用 CSP(ubuntu) 环境进行实验（Windows 也可以进行实验）。A : 签到题【请在实验开始5分钟内完成签到】B : Slot输入格式输出格式思路代码C : Discount输入格式输出格式思路代码D : Orthogonality输入格式输出格式思路代码E : uNrEaDaBlE sTrInG代码F : Remove It代码G : Rally代码H : : (Colon) 本次实验线上进行，推荐大家使用 CSP(ubuntu) 环境进行实验
python从入门到实践第二章思维导图
06-05
本文将对Python编程语言的初学者提供一份详细的入门知识点总结，主要从Python变量和简单数据类型的使用场合、变量命名规则、字符串操作、空白字符处理、数据类型、四则运算和注释编写等方面进行阐述。 一、变量和...
创新思维综合教程第三册Unit3,PowerPoint演示
11-06
【创新思维综合教程第三册Unit3 PowerPoint演示】是面向学习者提供的一种教学资源，旨在培养和提升学习者的创新思维能力。这一单元的内容可能涵盖了多种创新思维的方法、工具和实例，以PPT的形式呈现，便于讲解和...
SDU 程序设计思维与实践 week5 最大矩形【单调栈】
01-08
【SDU程序设计思维与实践】week5的最大矩形问题主要涉及了算法设计中的单调栈这一数据结构。问题的目标是求解给定直方图中最大的矩形面积，直方图由一系列高度不等的小矩形构成，每个小矩形宽度为1。单调栈在这里的...
第七章创新思维方式拓宽护理工作思路.pptx
09-28
【创新思维方式】是护理工作中拓宽工作思路的关键。创新思维涵盖了理解、想象、批判性思维以及创造性思维等基本概念。理解思维是指人脑对客观事物本质及其规律性联系的间接、概括的反映，它强调思维的概括性和间接性...
开发多线程程序时，需要注意那些问题
最新发布
OO_SEN的博客
08-23 539
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
Yolov8：模型部署到安卓端
m0_70694811的博客
08-21 778
下载安装jdk-8u202-windows-x64.exe，这篇文章有百度网盘资源链接，直接下载，并按照这篇文章的JDK步骤进行安装和环境变量配置。C:\Program Files\Java\jdk-1.8\bin和C:\Program Files\Java\jdk-1.8\jre\bin。比如因为我的jdk路径是C:\Program Files\Java\jdk-1.8，所以这两个相对路径就改成。参考这边文章的USB驱动设置和手机端设置。同意协议后，下载相应版本的JDK。
笔记redis
风止的博客
08-22 1049
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
@Transactional中使用线程锁导致了锁失效与解决方案
liuruiaaa的博客
08-23 743
@Transactional中使用线程锁导致了锁失效与解决方案
JavaScript 错误 - Throw 和 Try to Catch的使用
逆风优雅的博客
08-23 150
trycatchthrow上面的代码 因为 try中 没有adddlert这个方法，或者这个方法有误，这时，代码会执行catch部分。JavaScript 实际上会创建带有两个属性的Error 对象name和message。
使用Java通过身份证号码匹配省市县名称的技术博客
weixin_41489908的博客
08-21 347
每日自动更新各类学习教程及工具下载合集​​在中国，身份证号码包含了持有人的出生地信息。通过解析身份证号码的前六位，我们可以获取对应的省、市、县（区）信息。在这篇博客中，我们将探讨如何使用Java代码来实现这一功能，并展示详细的代码示例和运行结果。
Java中自定义注解的使用
echola_mendes的博客
08-22 996
以【记录操作日志】为例，一般在开发中为了记录用户操作，当系统出现问题时，可以追溯日志所提供详细的错误信息，帮助开发者快速定位问题的原因最简单的方法：在每个方法中增加日志信息打印代码，来记录操作日志，但是这样重复代码也很多，也不易扩展，而且易出错使用自定义注解就会方便很多，减少不必要的重复代码，减少非业务代码的侵入性，如果需要扩展操作用户的信息以及IP就会很方便，易于扩展和维护@interface在需要使用自定义注解的地方使用该注解@LogOperation("新增")// 方法实现。
JavaSE 集合
ALLWE的博客
08-20 683
调用空构造器时初始化 Object[] elementData 数组，长度为10；初始化 size 属性，值为0；当elementData 数组中的10个位置都有元素后，添加第11个元素时数组扩容；扩容长度为原数组的1.5倍；扩容逻辑是创建一个长度为 15 的数组，将旧数组的数据拷贝到新数组中。
如何用Java SpringBoot+Vue搭建校内跑腿业务系统？实战教程解析
WEIXIN_JSJBCZDS的博客
08-21 983
如何用Java SpringBoot+Vue搭建校内跑腿业务系统？实战教程解析 【毕设攻略】Java SpringBoot+Vue打造校内跑腿系统！从零开始，手把手教你构建完整的业务流程。实战教程，技术难点全解析，让你的毕设项目脱颖而出，校园创业从这里启航！点击视频，开启你的编程之旅！
单例模式和多例模式
qq_68874993的博客
08-21 1293
本文内容是单例模式和多例模式的基本介绍及其区别
创新思维教育：探索与实践
第一单元"原理"探讨创新的难度、创新意识、创新能力以及思路在创新中的作用。通过案例分析，如医院感染率下降的创新解决方案和罗振宇的《罗辑思维》，帮助学生深入理解创新的实际应用。 课程结构清晰，理论与实践相...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值