爱奇艺2020校招Java方向笔试题（第一场）

最新推荐文章于 2024-09-11 14:17:45 发布

Yuudachi

最新推荐文章于 2024-09-11 14:17:45 发布

阅读量3.3k

点赞数 2

分类专栏：笔试面试题

本文链接：https://blog.csdn.net/Yuudachi/article/details/104025440

版权

笔试面试题专栏收录该内容

14 篇文章 3 订阅

订阅专栏

1. 计算下列程序的时间复杂度（B）

for (i=1;i<n;i++)
   for(j=1;j<m;j++)
     {a1,a2,a3,a4};

A. O（n）
B. O（nm）
C. O（m）
D. O（1）

解析：
循环次数之积 n*m

2. 求递归方程T(n)=4T(n/2)+n 的解（B）

A. O（n）
B. O（n²）
C. O（n³）
D. O（logn）

解析：
设a≥1，b＞1为常数，f(n)为函数，T(n)=aT(n/b)+f(n)为非负数,令x= $log_{b}{a}$
f(n)是n的多项式，令k为f(n)中n的指数
此处 a = 4 ,b = 2 ,x = $log_{b}{a}$ = 2 ,k = 1

1： $log_{b}{a}$ = k
T(n)= O(nk logbn)。
2： $log_{b}{a}$ ≠ k
如果 $log_{b}{a}$ < k，则T(n)= O(n^k)。
如果 $log_{b}{a}$ > k，则T(n)= O(n^x)。x = $log_{b}{a}$

满足最后一种情况即T(n)= O(n^x) = n²

3. 下列关于动态规划算法说法错误的是（B）

A. 动态规划关键在于正确地写出基本的递推关系式和恰当的边界条件
B. 当某阶段的状态确定后，当前的状态是对以往决策的总结并且直接影响未来的决策
C. 动态规划算法根据子问题具有重叠性，对每个子问题都只解一次
D. 动态规划算法将原来具有指数级复杂度的搜索算法改进成具有多项式时间算法

解析：

最优子结构性质。如果问题的最优解所包含的子问题的解也是最优的，我们就称该问题具有最优子结构性质（即满足最优化原理）。最优子结构性质为动态规划算法解决问题提供了重要线索。
无后效性。即子问题的解一旦确定，就不再改变，不受在这之后、包含它的更大的问题的求解决策影响。
子问题重叠性质。子问题重叠性质是指在用递归算法自顶向下对问题进行求解时，每次产生的子问题并不总是新问题，有些子问题会被重复计算多次。动态规划算法正是利用了这种子问题的重叠性质，对每一个子问题只计算一次，然后将其计算结果保存在一个表格中，当再次需要计算已经计算过的子问题时，只是在表格中简单地查看一下结果，从而获得较高的效率。

4. 已知图G的邻接表如下图所示，则从V1点出发进行广度优先遍历的序列为（B）

在这里插入图片描述
A. V1，V2，V3，V4，V5，V6
B. V1，V2，V5，V4，V3，V6
C. V1，V2，V3，V6，V5，V4
D. V1，V2，V4，V6，V5，V3

解析：
广度优先遍历优先遍历邻接表中的后继节点
V1，V2，V5，V4，V3，V6
深度优先遍历优先遍历邻接表中的相邻节点
V1，V2，V3，V6，V5，V4

5. 以下哪个不是队列的应用（D）

A. 图的广度优先搜索
B. 设置打印数据缓冲区
C. 树的层次遍历
D. 中缀表达式转后缀表达式

解析：
中缀表达式转后缀表达式是栈的应用

6. 有如图所示的二叉树，其后序遍历的序列为（C）

在这里插入图片描述
A. ABDGCEHF
B. BGDAEHCF
C. GDBHEFCA
D. ACFEHBDG

解析：
后序遍历：先左后右最后根节点

7. 折半查找法对带查找列表的要求为（B）

A. 必须采用链式存储结构、必须按关键字大小有序排列
B. 必须采用顺序存储结构、必须按关键字大小有序排列
C. 必须采用链式存储结构、必须没有数值相等的元素
D. 必须采用链式存储结构、必须有数值相等的元素

8. 一组N个站点共享一个30Kbps的纯ALOHA信道，每个站点平均每100s输出一个2000bit的帧。试求出N的最大值（B）

A. 1030
B. 276
C. 1500
D. 1200

解析：
ALOHA的吞吐公式为S=Ge-2G
式中，S为吞吐量，G为单位负载。
转换成一阶导数可以得到Smax=18．4%
答案：
0.184×30kbps=5.52kbps
2000bit÷100s=20bps
N=5520bps÷20bps=276

9. 在Linux系统中，某文件权限的分数是754，则以下说法错误的是（B）

A. 拥有者的权限是可读、可写、可执行
B. 同用户组的权限是可写可执行
C. 其他用户权限只有可读
D. 所有用户对该文件都可读

解析：
754对应3种用户的权限：文件所有者、同组用户、其他用户
权限权限数值具体作用
r 4 read，读取。当前用户可以读取文件内容，当前用户可以浏览目录。
w 2 write，写入。当前用户可以新增或修改文件内容，当前用户可以删除、移动目录或目录内文件。
x 1 execute，执行。当前用户可以执行文件，当前用户可以进入目录。
因此 7=4+2+1 文件所有者对该文件的的权限为可读可写可执行（A正确）；5=4+1 同组用户对该文件的权限为可读可执行；4=4所其他用户对该文件的权限为可读（C正确）；综上所有用户都有读权限（D正确）

10. 有一张表，列名称和列类型如下：

Id Int unsigned
Uname Varchar(30)
gender Char(1)
weight Tinyint unsigned
Birth Date
Salary Decimal(10,2) 
lastlogin Datetime
info Varchar(2000)

对这张表进行优化，可行的是（B C D）

A. 不用优化
B. 将Id列设置为主键
C. 为了提高查询速度，让变长的列定长
D. Info列放在单独的一张表中

解析：
主键会添加索引，定长字段有利于查询优化，将大数据量字段单独放在一个表中可以优化数据库表的存储性能

11. 在Java线程中可以通过setDaemon(true);设置线程为守护线程，可以使用join()合并线程。如何正确使用两个方法（A）

A. 在启动线程start()前使用setDaemon(true)；
B. 在启动线程start()前使用join()；
C. 在启动线程start()后使用setDaemon(true)；
D. 两个方法都要放在start()方法之前调用

解析：
setDaemon(true)在start之前
join在start之后

12. 对于如下代码,描述错误的是:（C）

class Animal{
   public void move(){
      System.out.println("the animal is moving");
   }
}
  
class Dog extends Animal{
   public void move(){
      System.out.println("the dog can run");
   }
   public void bark(){
      System.out.println("the dog can bark");
   }
}
  
public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal();  
      Animal b = new Dog();    
   }
}

A. b 对象可以调用move方法，输出为：the dog can run
B. b 对象可以调用move方法，输出为：the animal is moving
C. b对象可以调用bark方法输出为：the dog can bark
D. b 对象不能调用bark方法。

解析：
由于Java有父类委托机制。父类委托机制工作过程是：如果一个类加载器收到了类加载的请求，他首先不会自己去尝试加载这个类，而是把这个请求委托给父类加载器去完成，每一个层级的类加载都是如此，因此所有的加载请求最终都应该传送到顶层的启动类加载器中，只有当父加载器反馈自己无法完成这个加载请求时，子加载器才会尝试自己去加载。
b 此时是一个Animal对象， Animal对象没有bark方法，因此b对象不能调用bark方法

13. 对于如下代码，运行结果是（A）

public class Test {   
   public static void main(String[] args) {   
     double[] nums = {-1.6};   
     for (double num : nums) {   
       test(num);   
     }   
   }    
   private static void test(double num) {   
     System.out.println(Math.floor(num));   
     System.out.println(Math.ceil(num));   
   }   
 }

A. -2.0 -1.0
B. -1.0 -2.0
C. -2 -1
D. 2 1

解析：
Math.floor 向下取整
Math.ceil 向上取整

14. 阅读下列代码输出结果正确的是（A）

import java.util.Arrays;
public class Test
{
     public static void main(String [] args)
     {
         int a[] ={34,12,35,54,22,33,56};
        Arrays.sort(a);
        for(int j=0;j<a.length;j++)
            System.out.print(a[j]+"");
  }
}

A. 12 22 33 34 35 54 56
B. 22 33 34 35 54 12 56
C. 56 54 35 34 33 22 12
D. 33 34 35 54 12 56 22

解析：
Arrays.sort(a); 由小到大快排

15. 一个函数定义如下：

public void doSomething( int[][] mat)
{
    for( int row = 0; row < mat.length; row++)
        for(int col = 0; col < mat[0].length; col++)
            mat[row][col] = mat[row][mat[0].length - 1 - col];
}

如果mat为下列2行6列的值：

1  3  5  7  9  11
0  2  4  6  8  10

那么,doSomething(mat)执行完成后，mat的值是？（A）

A.
11 9 7 7 9 11
10 8 6 6 8 10
B.
1 3 5 5 3 1
0 2 4 4 2 0
C.
11 9 7 5 3 1
10 8 6 4 2 0
D.
1 3 5 7 9 11
1 3 5 7 9 11

解析：
在修改每一行的前n/2个时，原行中的后n/2个倒置
此处即将每行中的后3个倒置为每行中的前三个，即
11 9 7 x x x
10 8 6 y y y
在修改每一行的后n/2个时候，原行中的前n/2个倒置

此处即将每行中的前3个倒置为每行中的后三个，即
11 9 7 7 9 11
10 8 6 6 8 10

16. 与Test在同一个包下的子类对象可以访问以下哪些变量（B C D）

public class Test {
 private int eat=1;
 double drink = 2.0;
 protected int sleep = 3;
 public double run = 4.0;
}

A. eat
B. drink
C. sleep
D. run

解析：

17. 下面关于异常的描述正确的是（A C D）

A. Throwable是所有异常的根
B. 所有异常都是在运行后报错
C. 异常分为Error和EXception
D. 有一部分异常编译器会程序员检查并处理

解析：
异常的基本概念

18. 关于多线程，以下说法正确的是（C）

A. 并发和并行都用到了多线程
B. 要实现多线程只可以通过继承Thread类
C. synchronized关键字是为了解决共享资源竞争的问题
D. 在java中，每个对象可以获得多个同步锁

解析：
A. 并发用到了多线程
B. 还可以实现Runnable接口
D. 每个对象只能拥有一把同步锁 synchronized(x.class)

19. 下面关于创建型模式说法错误的是（B）

A. 适配器模式属于创建型模式
B. 创建型模式关注的是功能的实现
C. 当我们想创建一个具体的对象而又不希望指定具体的类时可以使用创建型模式
D. 创建者模式是一个对对象的构建过程“精细化”的构建过程，每个部分的构建可能是变化的，但是对象的组织过程是固定的

解析：
行为型模式关注的是功能的实现

20. 在顺序图中，如下图形表示的是（A）

在这里插入图片描述
A. 激活的对象
B. 带有生命线的对象
C. 未激活的对象
D. 注释体

解析：
https://blog.csdn.net/litianxiang_kaola/article/details/53957312