网易校招java正式批题目(牛客网)

网易校招java正式批题目(牛客网)

考试链接: https://www.nowcoder.com/test/20791607/summary.

*1.考察泛型

public class Main {
    public static void main(String[] args) {
        ArrayList<String> l1 = new ArrayList<String>();
        ArrayList<Integer> l2 = new ArrayList<Integer>();
        l1.add("1");
        l2.add(1);
        System.out.println(l1.get(0).getClass());
        System.out.println(l2.get(0).getClass());
        System.out.println(l1.getClass() == l2.getClass());
    }
}

答案：
class java.lang.String
class java.lang.Integer
true

解释：Java中泛型在编译时会进行类型擦除，因此 l1和 l2类型擦除后的结果都是java.util.ArrayList ，进而 l1.getClass() == l2.getClass()的结果是true。

*2.考察 try-catch-finally

public class Main {
    public static void main(String[] args) {
        int i = 0;
        int res = 1;
        while(true) {
            try {
                res += res / (i++);
                System.out.println("No exception");
            } catch(Exception e) {
                System.out.println("Zero exception");
            } finally {
                System.out.print("In finally clause");
                System.out.println(i);
                if (i == 2) break;
            }
        }
    }
}

答案：
Zero exception
In finally clause1
No exception
In finally clause2

首先，finally是肯定要执行的，这点很重要
排除法，finally执行的结果答案必须有
然后就是出现异常的情况，出现异常执行sql里面的方法
如果try里面没有异常，执行try里面的方法

*3.考察前序/中序/后序遍历

数据结构中，沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。对二叉树的结点从1开始进行连续编号，要求每个结点的编号大于其左、右孩子的编号，同一结点的左右孩子中，其左孩子的编号小于其右孩子的编号，可采用（ 后）次序的遍历实现编号。

分析：
先序 根左右
中序 左根右
后序 左右根

*4.查找

现在假设对N个元素的链表做顺序查找时，若查找每个元素的概率相同，则平均查找长度为(n+1)/2

分析：第一个数的比较次数为1，第二个数的比较次数为2……以此类推第N个数的比较次数为N，所以总的比较次数1+2+…+N=N(N+1)/2，总长度N(N+1)/2除以总个数N，平均比较次数为(N+1)/2,也即平均查找长度。

*5.考察完全二叉树

完全二叉树是指深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一 一对应将一棵有50个结点的完全二叉树按节点编号，如根节点的编号为1，那么编号为25的结点是（有左孩子，无右孩子）

分析：题上说了是完全二叉树，而且与深度为K的满二叉树中编号从1至n的结点一 一对应，说明满足每层从左到右都是按编号顺序排列的，根节点的编号为1，对于编号为M的结点，其左孩子编号为2M , 右孩子编号为2M+1。M=25代入，发现选B

*6.sql语句

假设有选课表course_relation(student_id, course_id)，其中student_id表示学号，course_id表示课程编号，如果小易现在想获取每个学生所选课程的个数信息，请问如下的sql语句正确的是（ ）

select student id,count (course_ id)
from course rel ation group by student_ id;

*7.Linux理论

Linux不可以对目录进行硬链接。
Linux不可以将“.”加入到path的查询目录。
Linux不可以用一般身份执行iconfig eth0。
init是Linux启动的第一个进程。C对

*8.单例模式的实现方式

public class Demo {

    private Demo() {}
    
    private static class Singleton {
        private static final Demo INSTANCE = new Demo();
    }
    
    public static Demo getInstance() {
        return Singleton.INSTANCE;
    }
}

答案：线程安全，懒加载。

单例模式的实现方式（别人的）
懒汉式(线程安全，调用效率不高，但是能延时加载)：

public class SingletonDemo2 {
 //类初始化时，不初始化这个对象(延时加载，真正用的时候再创建)  
	private static SingletonDemo2 instance; //构造器私有化  

	private SingletonDemo2(){} //方法同步，调用效率低  

	public static synchronized SingletonDemo2 getInstance(){ 
		if(instance==null){
			instance=new SingletonDemo2();
			return instance;
        }         
    }
}

链接: 参考 - 单例设计模式.

链接: https://blog.csdn.net/yin767833376/article/details/54379345.

*9.操作系统理论

位图这样的数据结构在操作系统当中的哪个场景下使用？
A.文件目录的查找 ×
B.磁盘空间的管理 .对√
C.主存空间的共享 ×
D.文件的保护和保密 ×

Linux不可以用一般身份执行iconfig eth0：

*10.单位换算？

小易有个32G字节的文件，需要从电脑1传送到电脑2，假设两者之间是1024Mbit/s的网络，那么需要多久能传输完（256秒）

一字节等于8位
32 * 8 * 1024 M bit /1024Mbit/s = 256s

注意Mbit/s和Mbyte/s
一字节等于八位

*11.浅拷贝和深拷贝

对象的浅拷贝和深拷贝区别是什么？在JAVA中如何实现？

–浅拷贝和深拷贝的主要区别在于是否支持引用类型的成员变量的复制。
–浅拷贝：拷贝时创建一个新的对象，对象中的属性如果是基本数据类型会新创建对象，但是属性是引用类型不会创建新的对象，而是使用与之前的对象指向同一个内存地址。
–深拷贝：拷贝时创建一个新的对象，并且所有属性都是新对象(指向新的内存地址)。

别人的答案：
–浅拷贝只是复制了对象的引用地址，两个对象指向同一个内存地址，所以修改其中任意的值，另一个值都会随之变化，这就是浅拷贝（例：assign()）
–深拷贝是将对象及值复制过来，两个对象修改其中任意的值另一个值不会改变，这就是深拷贝（例：JSON.parse()和JSON.stringify()，但是此方法无法复制函数类型）

浅拷贝：

// java 实现浅拷贝： 必须实现Cloneable 接口，并且重写Object 的clone()​
public class ShallowCopy implements Cloneable {

	private String name;
	private int age;

	public void hashMapCopy() {
		Map<String, Object> map = new HashMap<String, Object>();
		Map<String, Object> map1 = new HashMap<String, Object>(map);		
	}

	/**
	 * 浅拷贝,且必须要实现Cloneable接口 *
	 */
	public Object clone() throws CloneNotSupportedException {
		return super.clone();
	}

	@Override
	public String toString() {
		return "ShallowCopy{" + "name='" + name + '\'' + ", age=" + age + '}';
	}	
}
深拷贝：

```java
//java实现深拷贝：通过继承Serializable接口，然后使用InputStream 和OutputStream 构造一个新的对象

public class DeepCopy {

	
	public static Object deepCopy(Object obj) {
		try {
			ByteArrayOutputStream bo = new ByteArrayOutputStream();
			ObjectOutputStream objectOutputStream = new ObjectOutputStream(bo);
			objectOutputStream.writeObject(obj);

			ByteArrayInputStream bio = new ByteArrayInputStream(bo.toByteArray());
			ObjectInputStream objectInputStream = new ObjectInputStream(bio);

			return objectInputStream.readObject();

		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		return null;
	}

	public static void main(String[] args) {
		User user = new User("zhangsan", 23);
		User user1 = (User) DeepCopy.deepCopy(user);

		System.out.println("user hashcode:" + user.hashCode());
		System.out.println("user1 hashcode:" + user1.hashCode());

		System.out.println("==" + user.equals(user1));
		System.out.println("user:" + user.toString());
		System.out.println("user1:" + user1.toString());
	}
}

class User implements Serializable {

	private String name;
	private int age;

	public User(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override  
    public String toString() {  
        return "User{" +  
                "name='" + name + '\'' +  
                ", age=" + age +  
                '}';  
    }
}

运行结果：

参考链接: https://www.jianshu.com/p/50f247ef5397.

*12.Thread类和Runnable方法创建线程

使用Thread类和Runnable方法来创建一个线程的区别是什么？

（1）继承Thread: 线程代码存放Thread子类run方法中，且该run方法被调用。
（2）实现Runnable：线程代码存在实现了Runnable类接口的对象的run方法中，且该run方法被调用。

// 继承Tread类
MyThread extends Thread{
    @overwrite
    public void run(){
    业务流程
    }
}
public static void main(String[] args){
    MyThread mt = new MyTread();
    mt.start();
}

// 实现Runnable接口
MyThread implements Runnable{
    @overwrite
    public void run(){
    业务流程
    }
}
public static void main(String[] args){
    MyThread mt = new MyTread();
    Thread td = new Thread(mt);
    td.start();
}

从代码的角度来说，实现Runnable接口比继承Thread 多了一个步骤，把要干的事塞进了一线程里；
继承Thread的话，有一个Java局限性，Java是单继承，如果继承了Thread,就不能继承其他类，用Runnable接口就摆脱了这种缺陷，实现Runnable接口的话，一个类可以实现多个接口，这个类既可以作为被线程执行的目标外，还可以给这个类添加其他类；
其次还实现接口还可以资源共享：对于同一个资源的消耗来说，要用Runnable接口，继承Thread类无法处理对相同资源处理的情况，即Runnable的代码可以被多个线程（Thread实例）共享。

参考链接: https://blog.csdn.net/u012841209/article/details/70470744.

参考链接: https://blog.csdn.net/qq_32004233/article/details/78324573.

*13.编程

定义S(n)，表示n在十进制下的各位数字之和。现在给定一个x，请你求出最小正整数n，满足x<=S(n).



（1）

import java.util.Scanner;
 
public class Test01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int i = scanner.nextInt();
        int[] arr = new int[i];
        for (int i1 = 0; i1 < i; i1++) {
            int j = scanner.nextInt();
            arr[i1] = j;
        }
        for (int i1 = 0; i1 < arr.length; i1++) {
            int k = arr[i1] / 9;
            int k1 = arr[i1] % 9;
            StringBuilder stringBuilder = new StringBuilder();
            if (k1 != 0) {
                stringBuilder.append(k1);
            }
            for (int i2 = 0; i2 < k; i2++) {
                stringBuilder.append(9);
            }
            System.out.println(stringBuilder);
        }
    }
}

(2)

import java.util.Scanner;
 
/*
 * 定义S(n)，表示n在十进制下的各位数字之和。现在给定一个x，请你求出最小正整数n，满足x<=S(n).
 */
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int T = in.nextInt();
        for (int i = 0; i < T; i++) {
            int x = in.nextInt();
            solution(x);
        }
    }
 
    public static void solution(int x) {
        int n = x / 9;
        int h = x % 9;
        int i = 0;
        String result = "";
        for (i = 0; i < n; i++) {
            result = result + "9";
        }
        if (h != 0) {
            result = h + result;
        }
        System.out.println(result);
    }
}

(3) C++……？

#include<bits/stdc++.h>
using namespace std;
int main(){
    int T,n,m;
    cin>>T;
    long long x;
    while(T--){
        cin>>x;
        n=x/9;
        m=x%9;
        if(m!=0)
        cout<<m;
        for(int i=0;i<n;i++)
            cout<<"9";
        cout<<endl;
    }
      
    return 0;
}

（4）python……？

#coding=utf-8
import sys

if __name__ == "__main__":
    # 读取第一行的n
    n = int(sys.stdin.readline().strip())

    for i in range(n):
        # 读取每一行
        line = sys.stdin.readline().strip()
        # 把每一行的数字分隔后转化成int列表
        line1=int(line)

        geshu9=line1/9
        yushu=line1%9
        sum=0
        list1=[]
        for i in range(0,geshu9):
            list1.append('9')
        if yushu!=0:
            list1.insert(0,str(yushu))
        res="".join(list1)
        print res

链接: https://blog.csdn.net/u011035397/article/details/101119761.

*14.

小易给定你数字A,B(A
解题思路

分析题目，如果走 A=A+p 这边，A增加只要一步；如果走p=pq这边，A在这步并不增加，A增加最少还需多加一步。所以先判断走 A=A+p 能否使 A >= B，如果可以就直接走这边结束；如果不行再判断连走哪边两部使A增加更多，即 p2 和 pq ，由于题目已经限制了q是一定大于等于2的，所以我们直接不用考虑这个问题。如果走 A=A+p 不能使 A >= B 那么就走 p=pq 这边。

(1) √

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int T = in.nextInt();
        for (int i = 0; i < T; i++) {
            long A = in.nextInt();
            long B = in.nextInt();
            long p = in.nextInt();
            int q = in.nextInt();
            solution(A, B, p, q);
        }
    }
 
    public static void solution(long A, long B, long p, int q) {
        int count = 0;
        while (A < B) {
            if (A + p >= B) {
                A = A + p;
            } else {
                p = p * q;
            }
            count++;
        }
        System.out.println(count);
    }
}

注意： 这里 p*q 有可能会超出 int 范围，所以使用 long 型.

原文链接: https://blog.csdn.net/qq_41331466/article/details/101124858.

(2)别人的（python）：……？

import sys
  
num = sys.stdin.readline().strip()
args = []
try:
    while True:
        line = sys.stdin.readline().strip()
        if not line:
            break
        lines = line.split()
        args.append([int(i) for i in lines])
except:
    pass
  
for ag in args:
    a, b, p, q = [*ag]
    count = 1
    while a + p < b:
        p *= q
        count += 1
    print(count)

（3）python……？

import sys
t = int(sys.stdin.readline())
arr = []
for i in range(t):
    arr.append(list(map(int, sys.stdin.readline().strip().split())))
for n in range(t):
    a,b,p,q = arr[n]
    res = 1
    while a + p < b:
        p = p * q
        res += 1
    print(res)

（4）Java：……？

package test;
 
import java.util.Scanner;
 
/**
 * @author Mr.Zhao
 * @version 1.0
 * @Description:
 * @date 2020/1/5 10:48
 */
public class Test02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int i = scanner.nextInt();
        long[][] arrInt = new long[i][4];
        scanner.nextLine();
        for (int i1 = 0; i1 < i; i1++) {
            String str = scanner.nextLine();
            String[] arrString = str.split("\\s");
            for (int i11 = 0; i11 < 4; i11++) {
                arrInt[i1][i11] = Long.parseLong(arrString[i11]);
            }
        }
 
        for (int j = 0; j < i; j++) {
            int number = 0;
            outterLoop:for (int k = 0; k < 4; k++) {
                if (arrInt[j][0] >= arrInt[j][1]) {
                    System.out.println(number);
                    number = 0;
                } else {
                    while (arrInt[j][0] <= arrInt[j][1]) {
                        long m = arrInt[j][0] + arrInt[j][2];
                        long n = arrInt[j][2] * arrInt[j][3];
                        if (m >= arrInt[j][1]) {
                            System.out.println(++number);
                            break outterLoop;
                        }else {
                            if ((2 * arrInt[j][2]) <= n) {
                                arrInt[j][2] = n;
                                number++;
                            } else {
                                arrInt[j][0] = m;
                                number++;
                            }
                        }
                    }
                }
            }
        }
    }
}

*15.

逆序对距离之和。小易给定一个1到n的排列，希望你能求出这个序列中所有逆序对的距离和。
下标i,j的距离为 |i-j| ，逆序对是指序列中一对下标i,j满足iaj .

import java.util.Arrays;
import java.util.Scanner;
 
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int sum = 0;
        scanner.nextLine();
        String str = scanner.nextLine();
        String[] arrStr = str.split("\\s");
        int[] arrInt = new int[arrStr.length];
        for (int i = 0; i < arrStr.length; i++) {
            arrInt[i] = Integer.parseInt(arrStr[i]);
        }
        for (int i = 0; i < n; i++) {
            for (int j = i+1; j < n; j++) {
                if (arrInt[i] > arrInt[j]) {
                    sum += (j - i);
                }
            }
        }
        System.out.println(sum);
 
    }
}

一个逆序数的题目：
链接: https://blog.csdn.net/qq_29590355/article/details/89167624.

*16.最长子序列（完美数字序列）

小易定义一个数字序列是完美的，当且仅当对于任意2<=i<=n，都满足即每个数字都要大于等于前面所有数字的和。
现在给定数字序列Ai，小易想请你从中找出最长的一段连续子序列，满足它是完美的。

别人也没写完整：

l=[1,2,1000,3,100,100000,7,19,2,4,8,20,50,10000,100,200,10000]
m=[]
for i in range(len(l)):
    for j in range(i,len(l)):
        if sum(l[i:j])<=l[j] and  l[i:j]==sorted(l[i:j]):   
        #通过一个sorted排序过滤掉，部分后续值很大的影响
            m.append(l[i:j+1])
     
 
# 最长满足连续子数列
Per_list=max(m,key=lambda x:len(x))
length=len(Per_list)
print("最长完美连续子序列为{}，其长度为{}".format(Per_list,length))