笔试面试总结

榜样：

http://www.cnblogs.com/figure9/archive/2013/01/09/2853649.html

ArrayList和Vector的区别？

http://blog.csdn.net/luxiaoxun/article/details/7980618

1. 输出集合的排列、组合

http://blog.csdn.net/u010570643/article/details/8968032

2. 正则表达式

3.负载均衡、LVS

4.消息队列

5.红黑树

性质1. 节点是红色或黑色。性质2. 根是黑色。性质3. 所有叶子都是黑色（叶子是NIL节点）。性质4. 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)性质5. 从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。

6.深入理解Java垃圾回收机制

7.洗牌算法

8. fun能输出0-n之间的随机数字，设计一个函数输出0-m之间的随机数

完全二叉树：深度为k，有n个节点的二叉树，当且仅当其每一个节点都与深度为k的满二叉树中序号为1至n的节点对应时，称之为完全二叉树

满二叉树：深度为k，且有2^k-1个节点

排序算法总结：

http://blog.csdn.net/hkx1n/article/details/3922249

冒泡排序是稳定的，

选择排序是不稳定的，反例：3， 2， 2，1

堆排序的空间复杂度是O(1)，就地排序，推排序不是稳定的排序算法，反例：3，2，2，1，排序过程就是构建大根堆，调整为大根堆，取出根与堆的最后一个元素交换，再次调整，直至堆为空，最好，最差，平均时间复杂度都是O(nlogn)

快速排序：5 3 3 4 3 8 9 10 11，如果中枢元素选择了第一个元素，则第一次调用时5与第五个3交换了位置，可见是不稳定的排序算法。

为什么是不稳定的？？？

原地partition策略：

int partition(T *a, int left, int right, int pi) {T pv = a[pi];int si = left; //si之前的元素都要比中枢元素小
swap(pi, right); //把中枢元素搞到最右边for (int i = left; i <= rigth - 1; i++) {if (a[i] < pv) { //发现一只比中枢元素小的
swap(i, si); //为了保证“si之前的元素都要比中枢元素小”，移到si位置，同时si加一
si++;}}swap(si, right); //当pv本身就在最右边时，si会在最后一次循环时加一，si = right，这次做自身交换return si;}

4,3,2,1 pi = 1走一遍

快速排序算法的时间复杂度最坏是O(n^n)（已经排好序了），平均是O(nlogn)，因为要递归实现，空间复杂度是O(logn)

归并排序是稳定的排序算法，最优时间O(n),最差：O(nlog)，平均O(nlogn)，最差空间复杂度O(n)

希尔排序相当于多次的插入排序，插入排序本身是稳定的，而希尔排序是无序的

微软2014校园招聘笔试试题

http://blog.csdn.net/hackbuteer1/article/details/12190807

http://blog.csdn.net/zhou2214/article/details/12145057

线程之间哪些资源是私有的?..

regulat expression:

http://zh.wikipedia.org/wiki/%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F

^ $ \

声明函数指针?????????????

db cluster indexing

==============================================================================================================================================

--------------------------------------------
没有bug的二分搜索？
#include <stdio.h>int binary_search_middle(int *a,int p,int q,int f)
{int m;int idx;idx=-1;while(p+1<q){m=(p+q)/2;if(a[m]>f){q=m;}if(a[m]==f){idx=m;break;}if(a[m]<f){p=m;}}/*when a[0]=3,a[1]=4, we want to search 4*/if(p+1==q){if(a[p]==f){idx=p;}if(a[q]==f){idx=q;}}return idx;
}int binary_search_left(int *a,int p,int q,int f)
{int m;int idx;idx=-1;while(p+1<q){m=(p+q)/2;if(a[m]>=f){q=m;}if(a[m]<f){p=m;}}/*when a[0]=3,a[1]=4, we want to search 4*/if(p+1==q){if(a[p]==f&&a[q]==f){idx=p;}else if(a[q]==f){idx=q;}else if(a[p]==f){idx=p;}}return idx;
}int binary_search_right(int *a,int p,int q,int f)
{int m;int idx;idx=-1;while(p+1<q){m=(p+q)/2;if(a[m]>f){q=m;}if(a[m]<=f){p=m;}}/*when a[0]=3,a[1]=4, we want to search 4*/if(p+1==q){if(a[p]==f&&a[q]==f){idx=q;}else if(a[q]==f){idx=q;}else if(a[p]==f){idx=p;}}return idx;
}int main()
{int a[]={2,2,2,2,2,3};printf("%d\n",binary_search_middle(a,0,5,3));return 0;
}