平均每个人逗留时间为20分钟，那么开场前20分钟一共来了400人，且有20个人逗留时间已经到，但他们不一定出去，注意是平均时间，所有博物馆最少应该容纳500人
双向循环列表，从任何一个元素开始可以遍历全部元素
先和后面的元素相连
s->next=p->next;
p->next->prev=s->next;
在前面的元素相连
p->next=s;
s->pre=p;
答案显而易见
画图可以实现
时间轮转为1秒
A 24
B 20
C 7
D14
总时间为73所以平均周转时间为16.25
有两种坐的方式
?
?
动态分配都在堆中，毋容置疑
?
?
Yield（）暂时交出cpu控制权，从running状态转为runnalbe状态，但是仍有可能被调度，sleep（）线程指定休眠一段时间wait（）在其他线程调用此对象的notify（）notifyAll（）方法时才能继续执行线程中sleep()方法和yeild()方法的主要区别
: 1.sleep()
方法会给其他线程运行的机会,而不管其他线程的优先级,因此会给较低优先级的线程运行的机会;yeild()方法只会给优先级相同的或者比自己高的线程运行的机会2.sleep()方法声明抛出InterruptionException异常,而yeild()方法没有声明抛出任何异常3.sleep()方法比yeild()方法具有更高的可移植性4.sleep()方法使线程进入阻塞状态yeild()方法使线程进入就绪状态当前运行的线程可以调用另一个线程的join()方法,当前运行的线程将转到阻塞状态直到另一个线程运行结束,它才会恢复运行 ?join()有两种形式:public?void?join()和public?void?join(long?timeout)可以设置阻塞的时间
sleep()方法进入阻塞状态，当有两个线程（线程1和线程2），线程1的优先级比线程2的优先级高，线程1sleep()则线程2可以获得运行机会
当有比当前线程优先级高的线程出现时，高优先级会抢占CPU并运行，yield()方法，暂停一段时间，且这段时间不确定，它会使与当前线程相同优先级的线程获得运行机会
具有相同优先级的多个线程调度不一定是分时的，多核CPU可能同时调度
?
?
首先选择排序、插入排序、冒泡排序时间复杂度为 O(n^2)
快速排序最坏排序为时间复杂度O(n^2)
堆排序需要知道是大顶堆或者小顶堆，因为不了解数列特征所以不推荐其复杂度为O(nlgn);
所以快排是最优的
?
?
TCP/IP建立在三次握手协议基础上
前提条件是，虚拟机发生故障当且仅当它的宿主发生故障
根据条件得出虚拟机发生故障则物理机发生故障，则这台物理机所虚拟出的虚拟机会发生故障，所以虚拟机发生的故障不是彼此独立的，单台虚拟机的故障率和单台物理机的故障率是相同的，如果组成集群，那么当某个虚拟机发生故障时，另一个虚拟机会代替发生故障的虚拟机运行，所以可靠性比5台物理机的可靠性相同，所以无法判断这一百台虚拟机和100台物理机哪个更可靠
附加题1
sleep（）和wait()的区别
sleep()是让进程休眠一段时间，sleep()休眠持有锁，不释放系统资源，时间过后自动醒来进入可运行状态，但不一定执行，取决于虚拟机的调度，sleep(milliseconds)可以用时间指定使它自动唤醒过来，如果时间不到只能调用interrupt()强行打断。
wait是进入线程等待池等待，出让系统资源，其他线程可以占用CPU。一般wait不会加时间限制，因为如果wait线程的运行资源不够，再notify()也没用，要等待其他线程调用notify/notifyAll唤醒等待池中的所有线程，才会进入就绪队列等待OS分配系统资源。
使用范围：wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用?
?? synchronized(x){?
????? x.notify()?
???? //或者wait()?
?? }
?
?
?
?
附加题2
大意，插入一个二叉树，求二叉树最大节点和最小节点的绝对值
java 代码如下
//树节点
public class TreeNode1 {
private TreeNode1 leftChild;
private TreeNode1 rightChild;
int intege;
?
?
public TreeNode1 getLeftChild() {
return leftChild;
}
public void setLeftChild(TreeNode1 leftChild) {
this.leftChild = leftChild;
}
public TreeNode1 getRightChild() {
return rightChild;
}
public void setRightChild(TreeNode1 rightChild) {
this.rightChild = rightChild;
}
public int getIntege() {
return intege;
}
public void setIntege(int intege) {
this.intege = intege;
}
public TreeNode1(int intege) {
super();
this.intege = intege;
}
?
?
?
?
?
?
?
?
}
?
?
二叉树
public class Btree1 {
?
?
?
?
private int max;
private int min;
?
?
?
?
public Btree1(int max, int min) {
super();
this.max = max;
this.min = min;
}
?
?
//构造二叉树
public void insert(TreeNode1 root, int i) {
if (root == null) {
System.out.println("树为空");
} else {
?
?
?
?
if (root.getIntege() < i) {
if (root.getLeftChild() != null) {
insert(root.getLeftChild(), i);
} else {
root.setLeftChild(new TreeNode1(i));
}
} else {
if (root.getRightChild() != null) {
insert(root.getRightChild(), i);
} else {
root.setRightChild(new TreeNode1(i));
}
}
}
}
?
?
插入二叉树，遍历找到节点最大值和最小值
public void FindMax_Min(TreeNode1 root) {
if (root == null) {
System.out.println("该树为空");
} else {
if(root.getIntege()>max)
{
max=root.getIntege();
}
if(root.getIntege()<min)
{
min=root.getIntege();
}
//System.out.println(root.getIntege() + " ?");
if (root.getLeftChild() != null) {
FindMax_Min(root.getLeftChild());
}
if (root.getRightChild() != null) {
FindMax_Min(root.getRightChild());
}
}
}
public void Max_Min_abs()
{
System.out.println(max-min);
}
public static void main(String[] args) {
int a[]={1,45,6,7,12,89,2,17};
Btree1 b=new Btree1(-10000,10000);
TreeNode1 treeNode1=new TreeNode1(a[0]);
for(int i=1;i<a.length;i++)
{
b.insert(treeNode1, a[i]);
}
b.FindMax_Min(treeNode1);
b.Max_Min_abs();
}
}
附加题3
求两个字符串最大的连续出现的公共部分
列如query为acbac，text为acaccbabb那么公共子串为cba 长度为3
下面为java代码编写
import java.util.Scanner;
?
?
?
?
public class FindMaxSubString {
public static void main(String[] args) {
Scanner s=new Scanner(System.in);
System.out.println("请输入query");
/*String str1 = "acbac";
String str2 = "acaccbabb";
*/
String str1=s.nextLine();
System.out.println("请输入text");
String str2=s.nextLine();
String result = getMaxString(str1, str2);
if(result!=null)
{
System.out.println(result.length());
}
else
{
System.out.println("没有公共子串");
}
}
?
?
?
?
private static String getMaxString(String str1, String str2) {
String max = null;
String min = null;
max = (str1.length() > str2.length() ? str1 : str2);
min = max.equals(str1) ? str2 : str1;
for (int i = 0; i < min.length(); i++) {
for (int start = 0, end = min.length() - i; end != min.length() + 1; start++, end++) {
String sub = min.substring(start, end);
if (max.contains(sub))
return sub;
}
}
return null;
}
}
本人做的，可能有不对的，希望大家提出啊，持续更新中
查看评论
14楼?yiluocangqiong?前天 15:10发表?[回复]
应该选第五个，链表插入的步骤中后两步不可以改变顺序
13楼?Spark木讷虫?2015-03-06 13:44发表?[回复]
双链表插入应该选第2个
Re:?yiluocangqiong?前天 15:08发表?[回复]
回复wander669：应该选第五个，链表插入的步骤中后两步不可以改变顺序
12楼?delulv?2014-09-09 13:34发表?[回复]
引用"liuyuanlongdell"的评论：单选四爸爸那题应该选576，博主忘了可以旋转了
嗯，知道的，没更新，嘿嘿，最近忙，谢谢了哈，一块交流
11楼?liuyuanlongdell?2014-09-09 13:20发表?[回复]
单选四爸爸那题应该选576，博主忘了可以旋转了
10楼?delulv?2014-09-04 10:23发表?[回复]
引用"u013993181"的评论：楼主，可不可以用c语言，写一下这个二叉树的题，鄙人不会java，所以看不懂啊，谢谢楼主了啊
嗯，行，抽空给你写一下，嘿嘿
9楼?ilovemoshui?2014-09-03 08:50发表?[回复]
楼主，可不可以用c语言，写一下这个二叉树的题，鄙人不会java，所以看不懂啊，谢谢楼主了啊
8楼?delulv?2014-09-02 16:53发表?[回复]
引用"xiaolong9805"的评论：回复xiaolong9805：还有最长公共子串，只能说你实现了它。。。
应...
题目算是做完了吧，那个串有很多种解题方式，可以用kmp算法和dp，或者可以用n后缀构造树
7楼?delulv?2014-09-02 16:49发表?[回复]
引用"xiaolong9805"的评论：排序那个应该是堆排序把，前面说了大部分从大到小，用堆排序要快于O（n*longn）。
二叉树的那道题...
前面说了大部分从大到小可是后面来了一句事先不了解数列特征的情况下选择排序，前面说的不成立，如果前面成立了，那么我们了解数列特征了，应该是这样的吧
6楼?xiaolong9805?2014-09-02 14:34发表?[回复]
排序那个应该是堆排序把，前面说了大部分从大到小，用堆排序要快于O（n*longn）。
二叉树的那道题本意是要我们写出树的遍历的非递归算法（原题中有说只能写一个函数），所以应该用栈来实现。
最后问一句，博主都答完了？
我第一部分做了三分之二，第二部分简答题没写完。。。
Re:?xiaolong9805?2014-09-02 14:43发表?[回复]
回复xiaolong9805：还有最长公共子串，只能说你实现了它。。。
应该用矩阵。
5楼?delulv?2014-09-02 12:49发表?[回复]
引用"u013866823"的评论：排序那个题为什么要用快排呢，一个基本有序的数组进行快排时候的复杂度是最糟糕的啊，我觉得可以用改进版的...
你注意数列的数量级了吗--50k
4楼?马家沟小学生?2014-09-02 09:14发表?[回复]
排序那个题为什么要用快排呢，一个基本有序的数组进行快排时候的复杂度是最糟糕的啊，我觉得可以用改进版的冒泡排序，如果数据有序，可以达到on
3楼?delulv?2014-08-31 15:32发表?[回复]
引用"sophiaan"的评论：回复lv836735240：有几个人就有几个方向
嗯，我做错了（后面有段注释，我没有细看，当时做题也着急，谢谢哈）
2楼?洛萨之子?2014-08-30 22:38发表?[回复]
链表插入那题和排序方法选择那题再仔细想想？
ps.建堆排序一般都是建大堆的（这里要升序，所以是大堆，如果要降序的建小堆）建堆所花时间成本摊销后为O（N），下筛总花费NlogN，快排在10%乱序的时候依然比不过堆排，写个程序测一测就知道了：D
Re:?delulv?2014-08-30 22:46发表?[回复]
回复hit_suit：首先不了解数列特征，说明前面数列基本逆序不知道
而建大顶堆或者小顶堆需要满足下列条件
Key[i]<=key[2i+1]&&Key[i]<=key[2i+2]或者Key[i]>=Key[2i+1]&&key>=key[2i+2]
在数列特征不知道的情况下需要排序，满足大顶堆或者小顶堆的性质，如果知道数列的特征由大到小或者由小到大，堆排序（nlgn）当然是首选
1楼?sophiaan?2014-08-30 09:55发表?[回复]?[引用]?[举报]
我觉得爸爸去哪有8个方向
Re:?sssky8209?2014-08-30 10:07发表?[回复]?[引用]?[举报]
回复sophiaan：我也觉得是。。
Re:?delulv?2014-08-30 11:56发表?[回复]?[引用]?[举报]
回复sssky8209：嗯，如果这样想，东南西北，加上东南东北西南西北，这就8个，然后这八个之间还可以有很多个。如果这样说，会不会无解呀
Re:?sophiaan?2014-08-31 15:24发表?[回复]
回复lv836735240：有几个人就有几个方向
Re:?wjk20120522?2014-08-30 15:30发表?[回复]?[引用]?[举报]
回复lv836735240：在不考虑四个小孩的顺序只考虑这四个小孩坐哪四个位置的时候，
四个小孩坐一起的时候有8个方向，2个面对面的时候只有4个。
所以，答案应该是 384 + 96 = 480
?
?
来自 <http://blog.csdn.net/lv836735240/article/details/38933847>