2011阿里巴巴集团实习生招聘笔试题 C&C++

 答案为自己整理的，欢迎批评指正。

公共题

选择题（每题5分）

1. 若一棵二叉树具有10个度为2的结点，则该二叉树的度为0的结点个数是（      ）

A：9    B：11     C：12     D：不确定 

 

2.下列排序算法中，其时间复杂度和记录的初始排列无关的是（      ）

A：插入排序 (预先排序，运行时间为O(N))    B：堆排序     C：快速排序  (最坏情形O(N2))  D：冒泡排序 (最坏情形O(N2), 最优O(N))

3.已知中序遍历的序列为abcdef，高度最小的可能的二叉树的叶子是（     ）

A：ace      B：acf        C：adf        D：cdf 

4.参加百年阿里培训的n位同学结伴去西湖旁边为游人指路，两人一组，他们打算先让体重之和恰好为102公斤的同学一组，请给出一个算法找到这样的组合，或者确定他们中不存在这样的组合，其中最优的算法时间复杂度为？（假设体重均为整数） （     ）

A：O(log(n))    B：O(n)      C：O(n log(n))    D：O(n^2)

 

5.众所周知数据结构中非常基本的树结构包括二叉查找树（BST）。当我们把如下序列：10，5，19，4，13，7，6，3，1按顺序建立一棵BST时，树的最大深度是？（令根节点深度为0，执行不进行平衡的基本插入） （     ）

A：5    B：4    C：3     D：2 

 

6.阿里巴巴启用了新的办公大厦，这里的一切都充满了现代感；工程师们打算在娱乐区用大小相等的圆形材料分割出一些空间，使用A,B,C三个圆形材料，最多可以将空间分为八个区域（包括圆形以外的区域），如果给你五个圆形材料，你最多可以帮助工程师们分出多少个空间？ （     ）

A：20    B：22      C：26     D：32 

 

综合题（每题15分）

1） 分析MergeSort的原理以及算法复杂度，并用最擅长的编程语言实现Merge Sort。

MergeSort利用分治法的原理，依次减小问题的规模。时间复杂度为O(nlog(n)), 空间复杂度为O(N);

void Mergesort(int *p, int n){void Msort(int *p, int *temp, int left, int right);int *temp;if(n <= 0 || p == NULL)return;temp = (int *)malloc(sizeof(int) * n);if(temp == NULL)return;Msort(p, temp, 0, n-1); free(temp);}void Msort(int *p, int *temp, int left, int right){void Merge(int *p, int *temp, int left, int rightbegin, int right);int leftend = (right + left)/2;int rightbegin = leftend+1;if(left < right){Msort(p, temp, left, leftend);Msort(p, temp, rightbegin, right);Merge(p, temp, left, rightbegin, right);}}void Merge(int *p, int *temp, int left, int rightbegin, int right){int TempArray = rightbegin;int pos = left;int begin = left;while(left < TempArray && rightbegin <= right){if(p[left] <= p[rightbegin]){temp[pos++] = p[left++];}else if(p[left] > p[rightbegin]){temp[pos++] = p[rightbegin++];}}while(left < TempArray)temp[pos++] = p[left++];while(rightbegin <= right)temp[pos++] = p[rightbegin++];while(pos-- >= begin){p[pos] = temp[pos];}}

给定一个数t，以及n个整数，在这n个数中找到加和为t的所有组合，例如t = 4, n = 6,这6个数为 [4, 3, 2, 2, 1, 1],这样输出就有4个不同的组合它们的加和为4: 4, 3+1, 2+2, and 2+1+1.  请设计一个高效算法实现这个需求。

#include<iostream>#include<vector>using namespace std;void Find(int *p, int n, int sum);void Qsort(int *p, int n);int main(){int *p;int n;int sum;int i;cin>>n;p = new int[n];for( i = 0; i < n; ++i)cin>>p[i];cin>>sum;Qsort(p, n); //先把输入的数字排序for( i = 0; i < n; ++i)cout<<p[i]<<" ";cout<<endl;Find(p, n, sum);}void Find(int *p, int n, int sum){void FindSum(int *p, int n, int sum, vector<int> &vec);vector<int> vec;if(p == NULL || n < 0)return;if(sum < p[0])return;elseFindSum(p, n, sum,vec);}void FindSum(int *p, int n, int sum, vector<int> &vec){if(sum == 0){for(vector<int>::iterator iter = vec.begin(); iter != vec.end(); ++iter)cout<<*iter<<" ";cout<<endl;return ;}if(sum < *p || n < 0){return;}vec.push_back(*p);sum -= *p;FindSum(p+1, n-1, sum, vec);sum += *p;vec.pop_back();while(*p == *(p+1) && n>0) //跳过重复的数字{p++;n--;}FindSum(p+1, n-1, sum, vec);}void Qsort(int *p, int n){void swap(int *, int *);int pivot;int j = -1;if(n <= 1)return;pivot = p[n/2];swap(p+n/2, p+n-1);for(int i = 0; i < n-1; ++i){if(p[i] < pivot){j++;if(j != i){swap(p+i, p+j);}}}swap(p+j+1, p+n-1);Qsort(p, j+1);Qsort(p+j+2, n-j-2);}void swap(int *a, int *b){int temp;temp = *a;*a = *b;*b = temp;}

热点题 聊聊近期最吸引你的互联网事件，谈谈你对此事件的看法。

C&C++部分

选择题（每题5分）

1、int main(void)

{

  int count=0; int m=779;

  while(m)

  {count++;  m=m&(m-1);}

  printf("%d\n",count); return0;

}

请问最终输出的count值为（    ）         A： 3      B：4      C：5      D：8

 

2、在32位操作系统中，我们定义如下变量

int (*n)[10];

请问调用函数sizeof(n)，返回值为（     ）  A：4     B：40     C：8     D：80

 

3、int main(void)

{

  int i=1;  int j=i++;

  if((i++>++j) && (++i == j))i+=j;

  printf("%d\n",i); return 0;

}

请问最终输出的i值为（    ）             A： 2     B：3      C：4      D：5

 

4、以下叙述中正确的是（     ）

A：可以在一个函数中定义另一个函数     B：main()函数必须放在其他函数之前

C：构成C++语言程序的基本单位是类     D：所有被调用的函数一定要在调用之前进行定义

 

综合题（每题15分）

有10亿个数，这些数的值都在0~1000万之内。请使用定义一个数据结构实现这些数字的存储，并实现函数get_bigger_count( unsigned value )，输入一个值value，返回这10亿个数中比value值大的数的数目。

要求：不能使用STL，请尽量考虑性能与资源的占用。  

思路：创建一个包含1000万个元素的数组，然后遍历10亿个数字，数组用来统计对应数字出现的次数。

如果10亿个数字中0~1000万是随机出现的，可以满足需求。如果有一个数字出现的次数非常的，则数组可能溢出。