四道微软面试算法题

http://topic.csdn.net/u/20081006/16/75461d49-6a8f-4684-84b6-aceee56c832f.html


(1)
一个整数数列，元素取值可能是0~65535中的任意一个数，相同数值不会重复出现。0是例外，可以反复出现。
请设计一个算法，当你从该数列中随意选取5个数值，判断这5个数值是否连续相邻。
注意：
- 5个数值允许是乱序的。比如： 8 7 5 0 6
- 0可以通配任意数值。比如：8 7 5 0 6 中的0可以通配成9或者4
- 0可以多次出现。
- 复杂度如果是O(n2)则不得分。

(2)
设计一个算法，找出二叉树上任意两个结点的最近共同父结点。
复杂度如果是O(n2)则不得分。

(3)
一棵排序二叉树，令 f=(最大值+最小值)/2，设计一个算法，找出距离f值最近、大于f值的结点。
复杂度如果是O(n2)则不得分。

(4)
一个整数数列，元素取值可能是1~N（N是一个较大的正整数）中的任意一个数，相同数值不会重复出现。设计一个算法，找出数列中符合条件的数对的个数，满足数对中两数的和等于N+1。
复杂度最好是O(n)，如果是O(n2)则不得分。



自己做了一下，程序如下
(1)

2. // 返回0表示正确，否则返回失败的索引值
3. int Check(int* p_data, int p_nCount)
4. {
5.     int i, end, zeroCount=0;
7.     // 对数据进行从小到大排序
8.     Sort(p_data, p_nCount);
9.     // 检查0的个数
10.     for(i=0; i<p_nCount; i++)
11.     {
12.         if(p_data[i]==0) zeroCount++;
13.         else break;
14.     }
15.     
16.     // 从5开始，到非0值的循环
17.     i = p_nCount;
18.     end = zeroCount+1;
19.     while(i-- > end) 
20.     {// 如果前后相差大于1，表示不连续
21.         if((p_data[i] - p_data[i-1]) != 1)
22.         {// 看能否用足够的0不上，计算剩余的0个数
23.             zeroCount -= p_data[i] - p_data[i-1]-1;
24.             if(zeroCount < 0) return i;
25.         }
26.     }
27.     return 0;
28. }

(2)

1. void swap(Node** a, Node** b)
2. {
3.     Node * p = *a;
4.     *b = *a;
5.     *a = p;
6. }
7. void Check(Node * root, Node* a, Node* b)
8. {
9.     Node * parent = NULL;
10.     if (a == NULL || b == NULL) printf("NULL/r/n");
11.     printf("a=%d, b=%d, parent=", a->value, b->value);
13.     if (a->GetLevel() < b->GetLevel()) // 检查两个节点深度，如果b比a深，交换a、b，让a的深度比b大
    
14.     {
15.         swap(&a, &b);
16.     }
17.     while(a->GetLevel() > b->GetLevel()) //对齐深度，这样才好比较
18.     {
19.         a = a->parent;
20.     }
21.     if (a == b) parent = a; //对齐后如果是同一节点，那么共同父节点取a
    
22.     else
23.     {
24.         while(a->parent != b->parent) //检查a、b的父节点，如果不是，同时提升a、b节点
25.         {
26.             a = a->parent;
27.             b = b->parent;
28.         }
29.         parent = a->parent;//最后得到共同父节点
30.     }
31.     printf("%d/r/n", parent->value);
32. }

(3)

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <conio.h>
4. #include "node.h"
6. int sum = 0; // 比较次数总数
7. Node * Check(Node * p, int f)
8. {
9.     sum++;
10.     if (p==NULL) return NULL;
12.     sum++;
13.     if (p->value >= f)  // 当前节点大于f时，要检查左节点是否有更接近的值
    
14.     {
15.         Node* q = Check(p->left,f);
16.         sum++;
17.         return (q!=NULL)?q:p; // 左节点没合适的值时，用当前节点，否则要返回的节点
    
18.     }
19.     else // 当前节点小于f时，检查右节点是否有更接近的值
20.     {
21.         return Check(p->right,f);
22.     }
23. }
24. 
    
26. // 给出根节点，计算最接近 f=(最大值+最小值)/2 的节点
27. void Check(Node * root)
28. {
29.     Node * min = root->GetMinNode();
30.     Node * max = root->GetMaxNode();
31.     int f = (max->value + min->value)/2;
32.     printf("min=%d, max=%d, f=%d , ", min->value, max->value, f);
33.     sum=0;
34.     Node* p = Check(root, f);
35.     printf("target=%d/t/t%d/r/n", p->value,sum);
36. }
38. // 生成测试数据
39. Node * CreateTestTree(void)
40. {
41.     int data[]={100,50,30,20,40,70,60,80,150,130,120,140,170,160,180};
42.     int len = 15;
43.     Node * root= new Node(data[0]);
44.     for(int i = 1; i < len; i++)
45.     {
46.         root->Insert(data[i]);
47.     }
48.     return root;
49. }
51. // 主测试函数
52. void main(void)
53. {
54.     clrscr();
55.     Node * treeRoot = CreateTestTree();
56.     treeRoot->PrintTree(40,1,3);
57.     Node * p = NULL;
58.     // 单独测试 Node * Check(Node * p, int f)
59.     for (int i=10;i<=200 ;i+=5)
60.     {
61.         p = Check(treeRoot, i);
62.         printf ("f=%d, node=%d/r/n",i,p->value);
63.     }
65.     // 测试题目3
66.     Check(treeRoot);
67.     delete treeRoot;
68.     treeRoot = NULL;
69.     return ;
70. }

(4)

1. #include <stdio.h>
2. // 题目4：
3. //一个整数数列，元素取值可能是1~N（N是一个较大的正整数）中的任意一个数，相同数值不会重复出现。设计一个算法，找出数列中符合条件的数对的个数，满足数对中两数的和等于N+1。
4. //复杂度最好是O(n)，如果是O(n2)则不得分。
6. // buf中数据应该已经排序
7. // 返回匹配数对数量
8. // 算法中遍历1次数组，复杂度O(N)
   
9. int c4(int* buf, int count)
10. {
11.     const int *p = buf; // 前指针
12.     const int *q = buf+count-1; // 后指针
13.     int n=*q+1; // N值
14.     int c = 0; // 匹配数量
15.     int compare = 0; //比较次数
16.     
17.     while (p<q) // 当前指针小于后指针时，循环数组
18.     { compare++;
19.         if ((*p + *q) == n) // 命中，计数加1，移动指针
20.         { compare++; printf("%d,%d; ", *p,*q);
21.             c++; p++; q--;
22.         }
23.         else
24.         {
25.             if ((*q + *p ) > n )
26.                q--; // 当前2个值大于N时，前指针的值可能还有匹配，后指针左移
27.             else
28.                p++; // 当前2个值小于N时，后指针的值可能还有匹配，前指针右移
29.         }
30.     }
31.     printf("compare=%d;/r/n ", compare); // 打印总比较次数
32.     return c;
33. }
35. void test(int index, const int* buf, int count, int expected)
36. {
38.     for(int i=0; i<count; i++) printf("%2d,", buf[i]);
39.     int actual = c4(buf, count);
40.     printf("test %2d/t [%s] expected=%d, actual=%d/r/n/r/n",
41.         index, expected==actual?"  ok ":"false", expected, actual);
42. }
44. int main(void)
45. {
46.     int i=1;
47.     int t0[10]={1,2,3,4,5,95,96,97,98,99};
48.     int t0_expected=5;
49.     test(i++, t0, 10, t0_expected);
51.     int t1[10]={1,2,13,14,15,95,96,97,98,99};
52.     int t1_expected=2;
53.     test(i++, t1, 10, t1_expected);
55.     int t2[10]={1,2,3,44,55,95,96,97,98,99};
56.     int t2_expected=3;
57.     test(i++, t2, 10, t2_expected);
59.     int t3[10]={1,12,13,87,88,95,96,97,98,99};
60.     int t3_expected=3;
61.     test(i++, t3, 10, t3_expected);
63.     int t4[10]={1,20,30,40,50,51,96,97,98,99};
64.     int t4_expected=1;
65.     test(i++, t4, 10, t4_expected);
67.     int t5[16]={1,12,13,14,20,30,31,32,33,70,80,95,96,97,98,99};
68.     int t5_expected=3;
69.     test(i++, t5, 16, t5_expected);
70.     
71.     
72.     int t6[16]={1,3,4,12,13,14,20,30,31,70,80,85,86,87,88,99};
73.     int t6_expected=6;
74.     test(i++, t6, 16, t6_expected);
75.     
76.     return 0;
77. }

用到的Node类

1. // Node.h 
2. #include <stdio.h>
4. #ifndef NODE
5. #define NODE
7. class Node
8. {
9.     public :
10.         int value;
11.         Node* parent;
12.         Node* left;
13.         Node* right;
15.     private:
16.         int level;
17.         // 打印树时的间隔比例因子
18.         static const int SPACE;
19.         int m_nMaxRow;
20. public :
22.     Node(void);
23.     Node(int p_value);
24.     Node(Node * p_parent);
25.     Node(int p_value, Node * p_parent);
27.     // 删除树
28.     ~Node();
30.     // 打印树
31.     void PrintTree();
32.     // 打印树 x = col, y = row，不是很好看 :P
33.     void PrintTree(int x, int y, int z);
34.     // 获取树深度
35.     int GetLevel();
36.     // 找最小值节点
37.     Node* GetMinNode();
38.     // 找最大值节点
39.     Node* GetMaxNode();
40.     // 插入新数据
41.     Node* Insert(int p_value);
42. };
44. #endif

1. // Node.cpp
   
2. #include <stdio.h>
3. #include <conio.h>
4. #include "node.h"
6. //using namespace std;
8. const int Node::SPACE = 3;
10. Node::Node(void)
11. {
12.     m_nMaxRow = 0;
13.     parent = NULL;
14.     left = NULL;
15.     right = NULL;
16.     level = -1;
17. }
19. Node::Node(int p_value)
20. {
21.     m_nMaxRow = 0;
22.     value = p_value;
23.     parent = NULL;
24.     left = NULL;
25.     right = NULL;
26.     level = -1;
27. }
28. Node::Node(Node * p_parent)
29. {
30.     m_nMaxRow = 0;
31.     parent = p_parent;
32.     left = NULL;
33.     right = NULL;
34.     if(p_parent) level = p_parent->level+1;
35. }
36. Node::Node(int p_value, Node * p_parent)
37. {
38.     m_nMaxRow = 0;
39.     value = p_value;
40.     parent = p_parent;
41.     left = NULL;
42.     right = NULL;
43.     if(p_parent) level = p_parent->level+1;
44. }
46. // 删除树
47. Node::~Node()
48. {
49.     if (this->left) {delete left; left = NULL;}
50.     if (this->right) {delete right; right = NULL;}
51. }
53. // 打印树
54. void Node::PrintTree()
55. {
56.     if (this->left) this->left->PrintTree();
57.     printf("%d ",this->value);
58.     if (this->right) this->right->PrintTree();
59. }
60. // 打印树
61. // x = col, y = row
62. void Node::PrintTree(int x, int y, int z)
63. {
64.     if (x<0) x = 0;
65.     if (y>25) return;
66. //      if (y>m_nMaxRow) m_nMaxRow = y;
67.     if (this->left) this->left->PrintTree(x-SPACE-z-z, y+1, z-1);
69.     gotoxy(x, y);
70.     printf("%d ",this->value);
71.     if (this->right) this->right->PrintTree(x+SPACE+z+z, y+1, z-1);
72. }
73. // 获取树深度
74. int Node::GetLevel()
75. {
76.     // 如果已经初始化，直接返回
77.     if (level != -1)
78.         return level;
80.     // 否则算计深度
81.     level = 0;
82.     Node * p = this->parent;
83.     while(p != NULL)
84.     {
85.         level ++;
86.         p = p->parent;
87.     }
88.     return level;
89. }
90. // 找最小值节点
91. Node* Node::GetMinNode()
92. {
93.     if (this->left != NULL) return this->left;
94.     else return this;
95. }
96. // 找最大值节点
97. Node* Node::GetMaxNode()
98. {
99.     if (this->right != NULL) return this->right;
100.     else return this;
101. }
103. // 插入新数据
104. Node* Node::Insert(int p_value)
105. {
106.     if (p_value > this->value)
107.     {
108.         if(this->right) return this->right->Insert(p_value);
109.         else return this->right = new Node(p_value, this);
110.     }
111.     else
112.     {
113.         if(this->left) return this->left->Insert(p_value);
114.         else return this->left = new Node(p_value, this);
115.     }
116. }