网易实习面经中的算法题（java版本含注释）

已于 2024-03-04 09:21:56 修改
阅读量1.1k 收藏 9
点赞数 3
分类专栏： 算法 文章标签： 算法 java leetcode
于 2022-05-08 10:45:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47872288/article/details/124448771
版权

目录

前言

该文章主要是收集牛客上面经被问到的高频算法
主要供个人参考以及理解

7. 整数反转（中等）

题目：题目：7. 整数反转

class Solution {
    public int reverse(int x) {

        int res=0;
        while(x!=0){
            if(res<Integer.MIN_VALUE/10||res>Integer.MAX_VALUE/10){
                return 0;
            }
            
            res=res*10+x%10;
            x=x/10;
        }

        return res;

    }
}

9. 回文数（简单）

题目：9. 回文数

class Solution {
    public boolean isPalindrome(int x) {
        // 特殊情况：
        // 如上所述，当 x < 0 时，x 不是回文数。
        // 同样地，如果数字的最后一位是 0，为了使该数字为回文，
        // 则其第一位数字也应该是 0
        // 只有 0 满足这一属性
        if (x < 0 || (x % 10 == 0 && x != 0)) {
            return false;
        }

        int cur = 0;
        while (x >cur) {
            cur = cur * 10 + x % 10;
            x /= 10;
        }

        // 当数字长度为奇数时，我们可以通过 revertedNumber/10 去除处于中位的数字。
        // 例如，当输入为 12321 时，在 while 循环的末尾我们可以得到 x = 12，revertedNumber = 123，
        // 由于处于中位的数字不影响回文（它总是与自己相等），所以我们可以简单地将其去除。
        return x == cur || x == cur / 10;
    }
}

14. 最长公共前缀（简单）

题目：leetcode：14. 最长公共前缀

class Solution {
    public String longestCommonPrefix(String[] strs) {

        //注意其中的区别，一个是字符数组，一个是里面的字符串
        int m=strs.length;
        int n=strs[0].length();

        //主体是列开始比较，每一列在外面
        for(int j=0;j<n;j++){
            for(int i=0;i<m;i++){
            
                if(strs[i].length()==j||strs[i].charAt(j)!=strs[0].charAt(j)){
                    return strs[0].substring(0,j);
                }
            }
        }
        return strs[0];

    }
}

20. 有效的括号（简单）

题目：20. 有效的括号

class Solution {
    public boolean isValid(String s) {
        //临界条件 奇数个数排除
        if(s.length()%2!=0)return false;

        Stack<Character>stack=new Stack<>();
        //转换为字符数组，也可不用转换
        char []c=s.toCharArray();

        Map<Character,Character>map=new HashMap<>(){{
            put(')','(');
            put('}','{');
            put(']','[');
        }};

        for(int i=0;i<c.length;i++){
            //如果包含这个右括号，则要相应的把左括号去除
            if(map.containsKey(c[i])){
                //先判断是否和左括号相等，如果不等先返回false
                //而且即使有右括号，栈中也要有左括号这个值，不能为空。
                if(stack.isEmpty()||map.get(c[i])!=stack.peek()){
                    return false;
                }
                stack.pop();
            }else{
            //如果没有包含这个右括号，则要把左括号进栈，相对应的当前的符号  也就是左括号
                stack.push(c[i]);
            }
        }

        //如果stack还有东西，说明不是有效的括号
        return stack.isEmpty();
    }
}

23. 合并K个升序链表（困难）

题目：23. 合并K个升序链表

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {

        //使用优先队列，本身比较的类型为ListNode，所以要转换为值去比较
        //使用函数Comparator.comparingInt
        PriorityQueue<ListNode>pq=new PriorityQueue<>(Comparator.comparingInt(o->o.val));
        
        int n=lists.length;
        for(int i=0;i<n;i++){
            //此处添加对头元素的时候，要保证每个对头元素不为空
            if(lists[i]!=null) pq.offer(lists[i]);
           
        }

        //创建一个头节点
        ListNode head=new ListNode(-1);
        ListNode ans=head;
        //如果队列不为空，则进行移动位置
        while(!pq.isEmpty()){
            ListNode cur=pq.poll();
            ans.next=cur;
            ans=ans.next;
            //并且判断下一个值是否不为空，不为空则添加
            if(cur.next!=null){
                pq.offer(cur.next);
            }
        }

        return head.next;


    }
}

64. 最小路径和（中等）

题目：leetcode：64. 最小路径和

class Solution {
    public int minPathSum(int[][] grid) {
 
        if(grid==null||grid.length==0||grid[0].length==0)return 0;

        int m=grid.length;
        int n=grid[0].length;
        int [][]dp=new int [m][n];
        //初始化
        dp[0][0]=grid[0][0];
        for(int i=1;i<m;i++){
            dp[i][0]=dp[i-1][0]+grid[i][0];
        }
        for(int j=1;j<n;j++){
            dp[0][j]=dp[0][j-1]+grid[0][j];
        }

        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                dp[i][j]=Math.min(dp[i-1][j],dp[i][j-1])+grid[i][j];
            }
        }

        return dp[m-1][n-1];
    }
}

单纯一个for循环：

class Solution {
    public int minPathSum(int[][] grid) {
        for(int i = 0; i < grid.length; i++) {
            for(int j = 0; j < grid[0].length; j++) {
                if(i == 0 && j == 0) continue;
                else if(i == 0)  grid[i][j] = grid[i][j - 1] + grid[i][j];
                else if(j == 0)  grid[i][j] = grid[i - 1][j] + grid[i][j];
                else grid[i][j] = Math.min(grid[i - 1][j], grid[i][j - 1]) + grid[i][j];
            }
        }
        return grid[grid.length - 1][grid[0].length - 1];
    }
}

103. 二叉树的锯齿形层序遍历（中等）

题目：leetcode：103. 二叉树的锯齿形层序遍历

class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> list=new ArrayList<List<Integer>>();
        if(root==null)return list;
        

        Queue<TreeNode> que =new LinkedList<>();
        que.offer(root);
        boolean direction = true;
        while(!que.isEmpty()){
            List<Integer> sonlist=new ArrayList<>();
            int n=que.size();
            
            for(int i=0;i<n;i++){
                TreeNode node=que.poll();
                sonlist.add(node.val);
                
                if(node.left!=null)que.offer(node.left);
                if(node.right!=null)que.offer(node.right);
            }
            if(!direction){
                Collections.reverse(sonlist);
            }

            direction=!direction;
            list.add(sonlist);
            
        }

        return list;

    }
}

133. 克隆图（中等）*

题目：leetcode：133.克隆图


//借助哈希表记录被克隆过的节点来避免陷入死循环

//本体使用的是dfs，深度优先遍历，使用hashmap存储其访问的值有无被访问过
class Solution {
    //存储的key为node，value为克隆的value
    HashMap<Node,Node>map=new HashMap<>();
    public Node cloneGraph(Node node) {
        //如果为null，则返回本身
        if(node==null)return node;

        //每一个判断的都判断是否有被克隆，如果被克隆访问过了，则直接返回克隆的值
        if(map.containsKey(node)){
            return map.get(node);
        }

        //创建一个克隆的节点，new node（构造函数为值，边）
        Node clonenode=new Node(node.val,new ArrayList());
        //将其克隆进去map集合中
        map.put(node,clonenode);

        //遍历node的邻接节点，通过clone的邻接节点add添加（递归的下一个节点）
        for(Node adjacent:node.neighbors){
            clonenode.neighbors.add(cloneGraph(adjacent));
        }
        return clonenode;
    }
}


class Solution {
    public Node cloneGraph(Node node) {
        if (node == null) {
            return node;
        }

        HashMap<Node, Node> map = new HashMap();

        // 将题目给定的节点添加到队列
        LinkedList<Node> queue = new LinkedList<Node> ();
        queue.offer(node);
        
        // 克隆第一个节点并存储到哈希表中
        map.put(node, new Node(node.val, new ArrayList()));

        // 广度优先搜索
        while (!queue.isEmpty()) {
            // 取出队列的头节点
            Node n = queue.poll();
            // 遍历该节点的邻居
            for (Node neighbor: n.neighbors) {
                if (!map.containsKey(neighbor)) {
                    // 如果没有被访问过，就克隆并存储在哈希表中
                    map.put(neighbor, new Node(neighbor.val, new ArrayList()));
                    // 将邻居节点加入队列中
                    queue.offer(neighbor);
                }
                // 更新当前节点的邻居列表
                map.get(n).neighbors.add(map.get(neighbor));
            }
        }

        return map.get(node);
    }
}

141. 环形链表（简单）

题目：leetcode：141. 环形链表

public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head==null||head.next==null) return false;
        ListNode p=head;
        ListNode q=head;
        while(q!=null&&q.next!=null){          
            p=p.next;
            q=q.next.next;
            if(p==q)return true;
        }
        return false;
        
    }
}

142. 环形链表 II（中等）

题目：leetcode：142. 环形链表 II

public class Solution {
    public ListNode detectCycle(ListNode head) {
        if (head == null) {
            return null;
        }
        ListNode slow=head;
        ListNode fast=head;
        while(fast!=null && fast.next!=null){
            slow=slow.next;
            fast=fast.next.next;           
               
            if(fast==slow){
                ListNode ans=head;
                while(ans!=slow){
                    ans=ans.next;
                    slow=slow.next;
                    
                }
                return ans;               
            }
                     
        }
        return null;
        
    }
}

146. LRU 缓存（中等）*

题目：leetcode：146. LRU 缓存

public class LRUCache {
    class DLinkedNode {
        int key;
        int value;
        DLinkedNode prev;
        DLinkedNode next;
        public DLinkedNode() {}
        public DLinkedNode(int key, int value) {this.key = key; this.value = value;}
    }

    private Map<Integer, DLinkedNode> map = new HashMap<Integer, DLinkedNode>();
    private int size;
    private int capacity;
    private DLinkedNode head, tail;

    public LRUCache(int capacity) {
        this.size = 0;
        this.capacity = capacity;
        // 使用伪头部和伪尾部节点
        head = new DLinkedNode();
        tail = new DLinkedNode();
        head.next = tail;
        tail.prev = head;
    }

    public int get(int key) {
        DLinkedNode node= map.get(key);
        if(node==null) return -1 ;
        removeNode(node);
        addToHead(node);
        return node.value;
    }

    public void put(int key, int value) {
        DLinkedNode node=map.get(key);
        if(node == null){
            DLinkedNode newnode=new DLinkedNode(key,value); 
            map.put(key,newnode);  
            addToHead(newnode);
            size++;
            if(size>capacity){
                DLinkedNode tail=removeTail();
                map.remove(tail.key);
                size--;
            }
        }
        else{
            node.value = value;
            removeNode(node);
            addToHead(node);
        }

      
    }

    private void addToHead(DLinkedNode node) {
        node.prev = head;
        node.next = head.next;
        head.next.prev = node;
        head.next = node;
    }

    private void removeNode(DLinkedNode node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    private DLinkedNode removeTail() {
        DLinkedNode res = tail.prev;
        removeNode(res);
        return res;
    }
}

160. 相交链表（简单）

题目：题目：160. 相交链表

可以对比一下上面的那个操作，多了一步而已

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if(headA==null||headB==null){
                    return null;
                }

        ListNode a=headA;
        ListNode b=headB;
        //判断的初始条件
        while(a!=b){
            //两者的判断条件一定要分开
            if(a!=null){
                a=a.next;
            }else{
                a=headB;
            }

            if(b!=null){
                b=b.next;
            }else{
                b=headA;
            }
        }
        return a;

        
    }
}

200. 岛屿数量（中等）

题目：leetcode：200. 岛屿数量

class Solution {
    public int numIslands(char[][] grid) {
        if (grid == null || grid.length == 0) {
            return 0;
        }

        int m=grid.length;
        int n=grid[0].length;
        
        int sum=0;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(grid[i][j]=='1'){
                    sum++;
                    dfs(grid,i,j);
                }
            }
        }
        return sum;

    }
    public void dfs(char [][] grid,int i,int j){
        int m=grid.length;
        int n=grid[0].length;
        if(i<0||i>=m||j<0||j>=n||grid[i][j]=='0')return ;
        grid[i][j]='0';

        dfs(grid,i-1,j);
        dfs(grid,i+1,j);
        dfs(grid,i,j-1);
        dfs(grid,i,j+1);
    }
}

206. 反转链表（简单）

题目：leetcode：206. 反转链表

class Solution {
    public ListNode reverseList(ListNode head) {
        
        //不用创建这个临时的头节点，因为不用保存这个值，而且反转的时候，会多一个0
        //ListNode prevhead=new ListNode(0);  
        //ListNode prev=prevhead;

        ListNode prev=null;
        ListNode cur=head;
        while(cur!=null){
            ListNode node=cur.next;
            cur.next=prev;
            prev=cur;
            cur=node;
        }
        return prev;

    }
}

如果使用递归的形式：

class Solution {
   public ListNode reverseList(ListNode head) {
    // 1. 递归终止条件
    if (head == null || head.next == null) {
        return head;
    }
    ListNode newhead = reverseList(head.next);
    head.next.next = head;
    head.next = null;
    return newhead;
}
}

509. 斐波那契数（简单）

题目：leetcode：509. 斐波那契数

动态规划，非递归的实现

class Solution {
    public int fib(int n) {
        //当为0的时候 初始化为0
        if(n==0)return 0;
        //当为1 或者2的时候，a b为1
        int a=1;
        int b=1;
        //c用来计数
        int c=1;

        for(int i=3;i<=n;i++){
            //类似滑动窗口的移动
            c=a+b;
            a=b;
            b=c;
        }
        //最后返回c的值
        return c;

    }
}

如果使用递归地实现（耗时8ms）

class Solution {
    public int fib(int n) {

        if(n<2)return n;

        return fib(n-1)+fib(n-2);
        

    }
}

剑指 Offer 40. 最小的k个数（简单）

题目：leetcode：剑指 Offer 40. 最小的k个数

使用优先队列的方式

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        if (k == 0 || arr.length == 0) {
            return new int[0];
        }
        // 默认是小根堆，实现大根堆需要重写一下比较器。
        //要把大的数字不要了，只保留小的，所以大根堆要重写
        Queue<Integer> pq = new PriorityQueue<>((o1,o2)->(o2-o1));
        for (int num: arr) {
            if (pq.size() < k) {
                pq.offer(num);
            }else if(num<pq.peek()){
                pq.poll();
                pq.offer(num);
            }
        }
        
        // 返回堆中的元素
        int[] res = new int[pq.size()];
        int idx = 0;
        for(int num: pq) {
            res[idx++] = num;
        }
        return res;
    }
}

使用快排思想：

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        quicksort(arr,0,arr.length-1);
        return Arrays.copyOf(arr,k);

    }
    public void quicksort(int [] arr,int l,int r){
        if(l>=r)return;

        int left=l;
        int right=r;
        while(left<right){
            while(left<right&&arr[right]>=arr[l])right--;
            while(left<right&&arr[left]<=arr[l])left++;
            swap(arr,left,right);
        }
        swap(arr,left,l);
        quicksort(arr,l,left-1);
        quicksort(arr,left+1,r);
    }
    public void swap(int []arr,int left,int right){
        int temp=arr[left];
        arr[left]=arr[right];
        arr[right]=temp;
    }
}
码农研究僧
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
网易2019实习生Java编程题
heihei
03-28 1610
题1：平面内有n个矩形, 第i个矩形的左下角坐标为(x1[i], y1[i]), 右上角坐标为(x2[i], y2[i])。 如果两个或者多个矩形有公共区域则认为它们是相互重叠的(不考虑边界和角落)。 请你计算出平面内重叠矩形数量最多的地方,有多少个矩形相互重叠。 思路：把坐标离散化之后直接统计（当时通过率90%） #include&lt;stdio.h&gt; #include&lt;a...
算法与数据结构——网易笔试题（一）
wjheha的博客
01-26 1143
算法题 13：二叉堆（网易2016实习研发工程师） 思路： ************************************************************************************************************************************ 算法题 15：暗黑的字符串（网易2017年秋招） 题目
Java基础算法50题（二）
HK的博客
07-17 7067
Java基础算法后25题
2024年Java面经(附答案)
m0_59679869的博客
05-21 958
这是我在2024上半年面试中遇到的高频率面试题，希望分享出来能帮到大家
记录一下5道Java笔试算法题
小太阳的博客
06-03 606
(1）字符串拆分成数组，如“ab&&2”通过”&&“做分隔符，分割得到字符串数组[“b”，“2”](2）实现字符串组合，如[“ab”，”2”]通过“&&"分隔符，组合成字符串"ab&&2”以下逻辑题，用Java编程语言，并尽量考虑时间和空间优化。
【算法百题之二十一】20网易面试题-二进制计数
Lampard的博客
02-09 907
【算法百题之二十一】二进制计数 大家好，我是Lampard~~ 很高兴又能和大家见面了，接下来准备系列更新的是算法题，一日一练，早日升仙！ 今天的问题是： 小A刚学了二进制，他十分激动。为了确定他的确掌握了二进制，你给他出了这样一道题目：给定N个非负整数，将这N个数字按照二进制下1的个数分类，二进制下1的个数相同的数字属于同一类。求最后一共有几类数...
【秋招机试真题】网易笔试0919
weixin_42669700的博客
09-19 321
第一题： 题目描述：无聊的牛牛突发奇想，想将手中的一排格子红蓝两种颜色，对于每个格子牛牛都有自己的想法。例如，如下的格子。 1号和2号格子涂蓝色，3号格子涂红色，4号格子涂蓝色，5号格子涂红色，6、7涂蓝色，8号涂红色。如果按照这个方法涂的华，他需要6步（1、2可以一起涂，6、7可以一起涂）。但是他也可以将1-7号涂上蓝色，再将3、5、8号分别涂成红色，则步数数量最少，为4次。 说明：第一题10分钟AC，挺简单的； 解题思路： 三种方案： 1、一个颜色一个颜色的涂； ...
Java 面经手册·小傅哥.pdf
01-26
当你仔细阅读书籍时，会发现Java中有大量的数学知识，包括：扰动函数、负载因子、拉链寻址、开放寻址、斐波那契（Fibonacci）散列法还有黄金分割点的使用等等。 适合人群 1. 具备一定编程基础，工作1-3年的研发...
面经分享-Java面试题及答案总结.zip
03-08
面经分享-Java面试题及答案总结 面经分享-Java面试题及答案总结 面经分享-Java面试题及答案总结 面经分享-Java面试题及答案总结 面经分享-Java面试题及答案总结 面经分享-Java面试题及答案总结 面经分享-Java面试题...
2024嵌入式大厂面经经典算法题
06-09
2024嵌入式大厂面经经典算法题提取方式是百度网盘分享地址
网易考拉 面经
12-08
一份网易考拉面试者总结的问题及部分答案，内容不算太多，可以参考一下
2024嵌入式大厂面经算法面试题总结
最新发布
06-09
2024嵌入式大厂面经算法面试题总结提取方式是百度网盘分享地址
网易2018内推Java开发工程师笔试题----操作序列
lingyuan_zhu的博客
08-13 2515
1.题目 小易有一个长度为n的整数序列,a_1,...,a_n。然后考虑在一个空序列b上进行n次以下操作: 1、将a_i放入b序列的末尾 2、逆置b序列 小易需要你计算输出操作n次之后的b序列。 2.基本解题思路 网上大神的解决思路是： 个数是奇数的时候：奇数放在左边，偶数放在右边  个数是偶数的时候：偶数放在左边，奇数放在右边 为什么形成这样的解题思路呢？ 以1,2,3,
大三程序员实习面试经历（Java）
热门推荐
待到春花烂漫时
05-06 2万+
暑假该去实习了，网上搜罗了一些前辈们比较有含金量的面试经历，五个部分，纯属混剪： Part1 第一次去了广州黄村创业园，面试了创业公司，环境非常好，但是感觉不靠谱才3个人，一个技术，一个HR和总经理，没有笔试题，而且面试官不是技术人员不懂问问题 第二次去了天河员村那边，新三板的公司果然高大上，开发直接占一层楼不用走电梯，面试题有Java基础，SQL，数据库，算法，总的来说考的范围...
网易2019笔试题
Rnan_prince的博客
08-19 8305
1.苹果分堆  计算累加小组成员数，结合二分查找，复杂度O( min(n, mlogn) ) package wangyi123; import java.util.Scanner; public class groupNum { public static void main(String[] args) { Scanner sc = new Scanner(System....
旷视 2019 春季算法实习生面试总结
weixin_30826761的博客
03-30 460
20190314 一面 自我介绍 项目介绍 2019 春季实习生招聘之项目介绍 了解过哪些 CV 领域 一张图片多个类别怎么设计损失函数，多标签分类问题 SVM、决策树优缺点，非线性回归用什么方法，L1、L2 正则化区别 链表归并快排 LeetCode 148——排序链表 反转链表 LeetCode 206——反转链表 实习时间，想做什么项目，检测、分割、行人重识别 骰子掷出 1-7 的均匀分布...
java实习生面试题_java后端实习生面试题目
weixin_34566429的博客
02-15 438
public classTest1 {public static voidmain(String[] args) {String str;for (int i = 10000; i < 100000; i++) {str=String.valueOf(i);if (str.charAt(0) == str.charAt(1)&& str.charAt(2) != str.ch...
java后端实习面经
10-25
根据引用和引用的描述，Java后端实习面经主要包括以下内容： 1. 针对性复习知识点，准备对应的八股文。 2. 根据自己的简历来进行针对性地复习。 3. 面试官问的几乎都是简历上写的东西。 4. 面试官可能会问一些基础...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

码农研究僧

你的鼓励将是我创作的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值