阿里巴巴2014笔试算法题汇总

1.两棵二叉树T1和T2，T1的节点数是百万量级，T2的节点数一千以内，请给出判断T2是否T1子树的可行算法。

分析：首先想到的是递归，但是T1的数量级太大，递归会导致栈溢出，于是以非递归实现。

[cpp]  view plain copy

1. bool IsSubtree(BinaryTreeNode* pRoot1, BinaryTreeNode* pRoot2) {    
2.     if (pRoot1 == NULL || pRoot2 == NULL) {    
3.         return false;    
4.     }    
5.     stack<BinaryTreeNode*> stk;    
6.     stk.push(pRoot1);    
7.     while (!stk.empty()) {    
8.         BinaryTreeNode *tmp = stk.top();    
9.         stk.pop();    
10.         if (tmp->m_nValue == pRoot2->m_nValue) {    
11.             stack<BinaryTreeNode*> first;    
12.             BinaryTreeNode *f;    
13.             stack<BinaryTreeNode*> second;    
14.             BinaryTreeNode *s;    
15.             first.push(tmp);    
16.             second.push(pRoot2);    
17.             bool find = true;    
18.             while (!first.empty()) {    
19.                 f = first.top();    
20.                 first.pop();    
21.                 s = second.top();    
22.                 second.pop();    
23.                 if (f->m_nValue != s->m_nValue) {    
24.                     find = false;    
25.                     break;    
26.                 }    
27.                 if (s->m_pLeft != NULL) {    
28.                     if (f->m_pLeft == NULL) {    
29.                         find = false;    
30.                         break;    
31.                 } else {    
32.                         first.push(f->m_pLeft);    
33.                         second.push(s->m_pLeft);    
34.                     }    
35.                 }    
36.                 if (s->m_pRight != NULL) {    
37.                     if (f->m_pRight == NULL) {    
38.                         find = false;    
39.                         break;    
40.                 } else {    
41.                         first.push(f->m_pRight);    
42.                         second.push(s->m_pRight);    
43.                     }    
44.                 }    
45.             }    
46.             if (find == true && first.empty()) {    
47.                 return true;    
48.             }    
49.         }    
50.         if (tmp->m_pLeft != NULL) {    
51.             stk.push(tmp->m_pLeft);    
52.         }    
53.         if (tmp->m_pRight != NULL) {    
54.             stk.push(tmp->m_pRight);    
55.         }    
56.     }    
57.     return false;    
58. }    

2.

从1到500的500个数，第一次删除奇数位，第二次删除剩下来的奇数位，以此类推，最后剩下的唯一一位数是：

A.500  B.256C.250  D.128

分析：

比如：1,2，删除奇数位，那剩下的是2，

1,2,3，删除奇数位，剩下的是2，

1,2,3,4,剩下的是4,

1,2,3,4,5,6,7,剩下的是4,

1,2,3,4,5,6,7,8和1,2,3,4,5,6,7,8,9,10,11,12,13,14,15剩下的是8，

这里有什么规律：就是当1~n，2^i<n<2^(i+1)时候，这样删除剩下的是2^i。

2^8<500<2^9，所以剩下的就是2^8=256。

转载请注明原创链接：http://blog.youkuaiyun.com/wujunokay/article/details/12233223