8.20有赞笔试题回忆（纯记录自己的秋招笔试）
单选6题，多选2题，编程2题，问答4题（我记得是），时间1小时
回忆：
单选：
1、有1024块奶酪，只有一块是有毒的，吃到奶酪的小鼠会在7天后死亡，奶酪可被分成无限小块，求最少需要几只老鼠才能找到有毒的奶酪 答案：10
2、考察sleep和wait的区别
3、下列关于ArrayList说法错误的是（）B------->ArrayList实现自动改变size机制
A、ArrayList的内存结构是数组结构
B、ArrayList存入的数据超出容量会报错
C、ArrayList往某一下标存数据时比LinkedList快
D、ArraylIst在内存中是连续的
4、下列有关线程池说法错误的是（）
A、当线程数大于maxThreadSize时，任务放入阻塞队列
B、线程池可以自定义拒绝策略
C、可以使用ThreadPoolExecutor的构造方法实现线程池
D、线程池的空闲线程数为coreThreadSize
剩下两题想不起来了，有记得的小伙伴可以评论。
多选：
1、考察索引的失效情况
在字段a和字段b上建立了组合索引，以下情况会使用到索引的是？我选的BD
A、where条件中a后有like且like以“%”开头
B、where条件中a后有like且like不以“%”开头
C、where条件中b有！=
D、where条件中a==xx and b < ... limit 10
2、考察垃圾回收-----我选的CD
A、方法区不会进行full gc
B、full gc只回收老年代
C、老年代可以使用标记-清理算法
D、java判断对象是否回收使用的是可达性分析法
问答：
1、有2020个叶子节点，树的高度是多少？树种的叶子节点的个数？高度：11，叶子节点个数：1010
2、计算机网络的五层模型，空中需要填的是：传输层和网络层
3、数12345678910111213141516171819...20102011201220132014201520162017201820192020,被9整除之后的余数是？
4、信号量是2，现在变成了-2，问有几个线程在等待？---这题具体记不清楚了
编程题：
1、合并有序链表（题目不难，但输入和输出比较坑）
输入：1,2,3|2,3,6,7
输出：[1,2,3,6,7]
参考代码：
import java.util.Scanner;
/**
* 合并有序链表
* 输入：1,2,3|2,3,6,7 输出：[1,2,3,6,7]
* @author Administrator
*
*/
public class Test1 {
public static class ListNode {
public ListNode next;
public int val;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
String str = in.next();
int idx = str.indexOf("|");
int p1len = idx;
int p2len = str.length()-idx-1;
int[] pp1 = new int[(p1len+1)/2];
int[] pp2 = new int[(p2len+1)/2];
int p1idx = 0;
int p2idx = 0;
for(int i = 0;i < p1len;i++) {
if(str.charAt(i) == ',') {
continue;
}else
pp1[p1idx++] = (int)str.charAt(i) - (int)'0';
}
for(int j = 0;j < p2len;j++) {
if(str.charAt(j+idx+1) == ',') {
continue;
}else
pp2[p2idx++] = (int)str.charAt(j+idx+1) - (int)'0';;
}
ListNode p1head = new ListNode();
p1head.val = pp1[0];
ListNode p1cur = p1head;
int idx1 = 0;
while(idx1 < pp1.length-1) {
ListNode p1n = new ListNode();
p1n.val = pp1[idx1+1];
p1cur.next = p1n;
p1cur = p1n;
idx1++;
}
ListNode p2head = new ListNode();
p2head.val = pp2[0];
ListNode p2cur = p2head;
int idx2 = 0;
while(idx2 < pp2.length-1) {
ListNode p2n = new ListNode();
p2n.val = pp2[idx2+1];
p2cur.next = p2n;
p2cur = p2n;
idx2++;
}
ListNode pp = merge(p1head,p2head);
ListNode newHead = delDup(pp);
StringBuffer sb = new StringBuffer();
sb.append("[");
ListNode p = newHead.next;
while(p!=null) {
sb.append(p.val);
if(p.next != null)
sb.append(",");
p = p.next;
}
sb.append("]");
System.out.println(sb.toString());
}
//按照剑指offer上的合并有序链表得到的链表中有重复的元素，因此还需要去重
public static ListNode merge(ListNode p1,ListNode p2) {
if(p1 == null)
return p2;
else if(p2 == null)
return p1;
ListNode p = null;
if(p1.val <= p2.val) {
p = p1;
p.next = merge(p1.next,p2);
}else{
p = p2;
p.next = merge(p1,p2.next);
}
return p;
}
//链表中去掉值相同的元素
public static ListNode delDup(ListNode pHead) {
if (pHead == null || pHead.next == null) { // 只有0个或1个结点，则返回
return pHead;
}
ListNode newHead = new ListNode();
ListNode cur = pHead;
newHead.next = cur;
while(cur != null && cur.next != null) {
ListNode next = cur.next;
if(cur.val == cur.next.val) {
cur.next = next.next;
}
cur = next;
}
return newHead;
}
}
/**
* 合并有序链表
* 输入：1,2,3|2,3,6,7 输出：[1,2,3,6,7]
* @author Administrator
*
*/
public class Test1 {
public static class ListNode {
public ListNode next;
public int val;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
String str = in.next();
int idx = str.indexOf("|");
int p1len = idx;
int p2len = str.length()-idx-1;
int[] pp1 = new int[(p1len+1)/2];
int[] pp2 = new int[(p2len+1)/2];
int p1idx = 0;
int p2idx = 0;
for(int i = 0;i < p1len;i++) {
if(str.charAt(i) == ',') {
continue;
}else
pp1[p1idx++] = (int)str.charAt(i) - (int)'0';
}
for(int j = 0;j < p2len;j++) {
if(str.charAt(j+idx+1) == ',') {
continue;
}else
pp2[p2idx++] = (int)str.charAt(j+idx+1) - (int)'0';;
}
ListNode p1head = new ListNode();
p1head.val = pp1[0];
ListNode p1cur = p1head;
int idx1 = 0;
while(idx1 < pp1.length-1) {
ListNode p1n = new ListNode();
p1n.val = pp1[idx1+1];
p1cur.next = p1n;
p1cur = p1n;
idx1++;
}
ListNode p2head = new ListNode();
p2head.val = pp2[0];
ListNode p2cur = p2head;
int idx2 = 0;
while(idx2 < pp2.length-1) {
ListNode p2n = new ListNode();
p2n.val = pp2[idx2+1];
p2cur.next = p2n;
p2cur = p2n;
idx2++;
}
ListNode pp = merge(p1head,p2head);
ListNode newHead = delDup(pp);
StringBuffer sb = new StringBuffer();
sb.append("[");
ListNode p = newHead.next;
while(p!=null) {
sb.append(p.val);
if(p.next != null)
sb.append(",");
p = p.next;
}
sb.append("]");
System.out.println(sb.toString());
}
//按照剑指offer上的合并有序链表得到的链表中有重复的元素，因此还需要去重
public static ListNode merge(ListNode p1,ListNode p2) {
if(p1 == null)
return p2;
else if(p2 == null)
return p1;
ListNode p = null;
if(p1.val <= p2.val) {
p = p1;
p.next = merge(p1.next,p2);
}else{
p = p2;
p.next = merge(p1,p2.next);
}
return p;
}
//链表中去掉值相同的元素
public static ListNode delDup(ListNode pHead) {
if (pHead == null || pHead.next == null) { // 只有0个或1个结点，则返回
return pHead;
}
ListNode newHead = new ListNode();
ListNode cur = pHead;
newHead.next = cur;
while(cur != null && cur.next != null) {
ListNode next = cur.next;
if(cur.val == cur.next.val) {
cur.next = next.next;
}
cur = next;
}
return newHead;
}
}
2、数轴上有N个点，第一个点的坐标是你现在的位置，第N-1个坐标是你的家。现在你需要依次从0号坐标走到N-1号坐标，但是除了0号和N-1号坐标，你可以在其余的N-2个坐标中选出一个点，并直接将这个店忽略掉，请问你回家至少要走多少距离？
输入：整数N<=50,换行输入N个整数表示坐标，正数表示X轴的正方向，负数表示X轴的负方向。绝对值小于等于100
输出：一个整数表示最少需要走的距离
这题没太懂啥意思，有知道的小伙伴麻烦给下输入输出示例
查看6道真题和解析
