本文解析了微软面试中的经典算法和数据结构题目，包括数组、字符串、链表等数据结构的操作及算法实现，如查找、排序、遍历等。
微软十五道面试题
1、有一个整数数组，请求出两两之差绝对值最小的值,
记住，只要得出最小值即可，不需要求出是哪两个数。
这个我没找到高效算法，O（n2）算法很好实现，应该都能想到的，另外一个快一点点的就是先排序一下，然后查找最小差的，排序用快排可以在）O（nlg（n））内完成，然后查找可以在线性时间完成，总复杂度O（nlg（n））
2、写一个函数，检查字符是否是整数，如果是，返回其整数值。
（或者：怎样只用4行代码编写出一个从字符串到长整形的函数？）
int char2int(char c){
if(c >= '0' || c<= '9')
return c - '0';
return -1;
}
3、给出一个函数来输出一个字符串的所有排列。
这个网上到处可以找到的
4、请编写实现malloc()内存分配函数功能一样的代码。 给出一个函数来复制两个字符串A和B。字符串A的后几个字节和字符串B的前几个字节重叠。
题目没看懂什么意思
5、怎样编写一个程序，把一个有序整数数组放到二叉树中？
排序的数组本身就可以当做是一颗排序二叉树，二分查找就是用这个特性的
struct tree_node{
int data;
struct tree_node* left;
struct tree_node* right;
};
struct tree_node* array2tree(int* array, int start, int end){
struct tree_node* ret;
int mid;
if(start > end)
return 0;
if(start == end){
ret = (struct tree_node*)malloc(sizeof(*ret));
ret->data = *(array + start);
ret->left = ret->right = 0;
return ret;
}
ret = (struct tree_node*)malloc(sizeof(*ret));
mid = (start + end) / 2;
ret->data = mid;
ret->left = array2tree(array, start, mid - 1);
ret->right = array2tree(array, mid + 1, end);
return ret;
}6、怎样从顶部开始逐层打印二叉树结点数据？请编程。
这个就是经典的BFS了。
struct tree_node{
int data;
struct tree_node* left;
struct tree_node* right;
};
void BFS(struct tree_node* root){
queue<void*> bfs_queue;
struct tree_node* iter;
bfs_queue.push(root);
while(!bfs.empty()){
iter = (struct tree_node*)bfs_queue.pop();
if(!iter)
continue;
printf("%d", iter->data);
bfs_queue.push(iter->left);
bfs_queue.push(iter->right);
}
}7、怎样把一个链表掉个顺序（也就是反序，注意链表的边界条件并考虑空链表）？
这个就保存连续的三个链表节点就可以反转单链表
struct list_node{
int test;
struct list_node* next;
};
struct list_node* reverse_list(struct list_node* head){
struct list_node* cur, *next, *nnext;
if(!head || !head->next)
return head;
cur = head;
next = head->next;
nnext = next->next;
while(!next){
next->next = cur;
cur = next;
next = nnext;
if(nnext)
nnext = nnext->next;
}
return cur;
}8、请编写能直接实现int atoi(const char * pstr)函数功能的代码。
#define INT_MAX ~0x00
int atoi(char* pstr){
int sign = 0, ret = 0, index = 0, iter = 0;
int is_minus = 0;
int* array = 0;
if(!pstr || !strlen(pstr))
return INT_MAX;
array = (int*)malloc(strlen(pstr));
if(pstr[0] == '-'){
sign = 1;
is_minus = 1;
}else if(pstr[0] == '+')
sign = 1;
else{
int bit_int;
while((bit_int = char2int(pstr[index + sign])) != -1){
*(array + index) = bit_int;
index ++;
}
}
while(iter < index){
ret += array[iter];
ret *= 10;
}
if(is_minus)
ret = 0 - ret;
return ret;
}
9、编程实现两个正整数的除法
编程实现两个正整数的除法，当然不能用除法操作符。
// return x/y.
int div(const int x, const int y)
{
....
}
这个随便找本算法的书上就有了，就不写了
10、在排序数组中，找出给定数字的出现次数
比如 [1, 2, 2, 2, 3] 中2的出现次数是3次。
二分查找，然后分别向前和向后找相同的值就行了
11、平面上N个点，每两个点都确定一条直线，
求出斜率最大的那条直线所通过的两个点（斜率不存在的情况不考虑）。时间效率越高越好。
这个没找到高效算法，不善于处理这种问题
12、一个整数数列，元素取值可能是0~65535中的任意一个数，相同数值不会重复出现。0是例外，可以反复出现。
请设计一个算法，当你从该数列中随意选取5个数值，判断这5个数值是否连续相邻。
注意：
- 5个数值允许是乱序的。比如： 8 7 5 0 6
- 0可以通配任意数值。比如：8 7 5 0 6 中的0可以通配成9或者4
- 0可以多次出现。
- 复杂度如果是O(n2)则不得分。
这个就是类似正则表达式的匹配了，0当做通配符就可以了
13、设计一个算法，找出二叉树上任意两个结点的最近共同父结点。
复杂度如果是O(n2)则不得分。
从一个节点的parent的另外的一颗子树找另一个节点就可以了，二叉树上的时间复杂度为O（n）
struct tree_node{
int data;
struct tree_node* parent;
struct tree_node* left;
struct tree_node* right;
};
int BFS(struct tree_node* root, struct tree_node* find); //改进一下BFS，当在子树root中找到了find节点就返回1，否则返回0
int is_right(struct tree_node* node){
if(node->parent && node->parent->right == node)
return 1;
return 0;
}
int is_left(struct tree_node* node){
if(node->parent && node->parent->left == node)
return 1;
return 0;
}
struct tree_node* nearest_parent(struct tree_node* one, struct tree_node* two){
struct tree_node* iter;
if(BFS(one, two))
return one;
if(BFS(two, one))
return two;
iter = one;
while(1){
if(is_left(iter)){
if(iter->parent->right && BFS(iter->parent->right, two))
return iter->parent;
iter = iter->parent;
continue;
}
if(is_right(one)){
if(iter->parent->left && BFS(iter->parent->left, two))
return iter->parent;
iter = iter->parent;
continue;
}
return iter; //iter是root节点
}
}14、一棵排序二叉树，令 f=(最大值+最小值)/2，
设计一个算法，找出距离f值最近、大于f值的结点。
复杂度如果是O(n2)则不得分。
排序二叉树上的最大值为树的最右边的节点，一直right下去就可以，最小值为最左边的节点，一直left下去就找到最小值，因此可以得到f。然后就在二叉树上找比f大的值且距离最小就可以了,这个复杂度应该为O(n)
float fvalue(struct tree_node* root){
float left_most = 0;
float right_most = 0;
struct tree_node* iter = root;
while(iter->left){
left_most = iter->data;
iter = iter->left;
}
iter = root;
while(iter->right){
right_most = iter->data;
iter = iter->right;
}
return (left_most + right_most) / 2;
}
struct tree_node* nearest(struct tree_node* root){
float f;
struct tree_node* sub_root, *temp;
float root_distance, sub_distance;
f = fvalue(root);
sub_root = root;
if(!sub_root)
return 0;
//root的data比f小，则所有的左子树都小，检查右子树就可以了
if(sub_root->data < f){
return nearest(sub_root->right);
}
//比较左子树和根节点的距离，选择较小的
root_distance = f - sub_root->data;
temp = nearest(sub_root->left);
if(!temp)
return sub_root;
sub_distance = f - temp->data;
if(root_distance > sub_distance)
return temp;
return sub_root;
}
15、一个整数数列，元素取值可能是1~N（N是一个较大的正整数）中的任意一个数，相同数值不会重复出现。
设计一个算法，找出数列中符合条件的数对的个数，满足数对中两数的和等于N+1。
复杂度最好是O(n)，如果是O(n2)则不得分
32、一个文件中有40亿个整数，每个整数为四个字节，内存为1GB，写出一个算法：求出这个文件里的整数里不包含的一个整数
上面第一个题用位图算法或者用哈希表就可以了，由于N比较大，就选择位图了，所占内存小，两种方法的时间复杂度都为O(n)
第二个只能用位图了，算了一下大概占内存400M
struct bitmap{
unsigned int bits;
unsigned char map[1];
};
struct bitmap* alloc_bitmap(int size)
{
int aligned_size, total_size;
struct bitmap* ret;
if(size <= 0)
return 0;
aligned_size = (size + 8 * sizeof(char) - 1)>>(3 * sizeof(char)); //计算需要size位需要多少字节
total_size = sizeof(bitmap) + aligned_size - 1;
ret = (struct bitmap*)malloc(total_size);
if(!ret)
exit(0);
memset(ret, 0, total_size);
ret->bits = size;
return ret;
}
void free_bitmap(struct bitmap* map){
if(map)
free(map);
}
void clear_bit(struct bitmap* map, int index){
char c = 0;
int main = 0, minor = 0;
if(index >= map->bits)
return;
main = index >> (3 * sizeof(char)); //在map数组中的索引
minor = index % (8 * sizeof(char));//在字节中的索引
c = bitmap->map[main];
c = c & ~(0x01 << minor);
bitmap->map[main] = c;
}
void set_bit(struct bitmap* map, int index){
char c = 0;
int main = 0, minor = 0;
if(index >= map->bits)
return;
main = index >> (3 * sizeof(char));
minor = index % (8 * sizeof(char));
c = bitmap->map[main];
c = c | (0x01 << minor);
bitmap->map[main] = c;
}
int is_set(struct bitmap* map, int index){
char c = 0;
int main = 0, minor = 0;
if(index >= map->bits)
return 0;
main = index >> (3 * sizeof(char));
minor = index % (8 * sizeof(char));
c = bitmap->map[main];
return c & (0x01 << minor);
}
void find_pair(int* array, int num){
struct bitmap* map;
int iter = 0;
map = alloc_bitmap(num + 1); //由于是从1到N
while(iter < num){ //建立索引表
if(!is_set(map, array[iter]))
set_bit(map, array[iter]);
iter++;
}
iter = 0;
while(iter < num){ //在索引表中搜索相加为N+1的数对
if(is_set(map, array[iter]) && is_set(map, num + 1 - array[iter])){
printf("(%d, %d)\n", array[iter], num + 1 - array[iter]);
clear_bit(map, array[iter]);
clear_bit(map, num + 1 - array[iter]);
}
iter++;
}
}下面是腾讯的一两题，随便写写吧
33、腾讯服务器每秒有2w个QQ号同时上线，找出5min内重新登入的qq号并打印出来。
struct qq_list_hashtable{
unsigned long qq;
unsigned long timestamp;
struct qq_list_hashtable *next, *prev;
struct qq_list_hashtable *hnext, *hprev;
};
struct hash_head{
struct qq_list_hashtable* next;
};
#define QQ_HASH_SIZE 11369 //最好使用素数，可以尽量均横的在哈希表上分布，避免某些地方碰撞次数特别多
struct hash_head[QQ_HASH_SIZE];
int hash_fn(int qq_num){
return qq_num % QQ_HASH_SIZE;
}代码没时间测试了，只是写出了思路，应该会有细节有错的，业余写算法的随便实现了几个，累的一B，睡觉了
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
