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

来源：互联网发布：5g 投资知乎编辑：程序博客网时间：2024/04/30 05:13

公共题

选择题（每题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);

[cpp] view plaincopy
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. 请设计一个高效算法实现这个需求。

[cpp] view plaincopy
#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;  
    cin>>n;  
    p = new int[n];  
    for(int i = 0; i < n; ++i)  
        cin>>p[i];  
    cin>>sum;  
    Qsort(p, n); //先把输入的数字排序  
    for(int 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;  
    else  
        FindSum(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) && p < p+n) //跳过重复的数字  
        p++;  
    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万是随机出现的，可以满足需求。如果有一个数字出现的次数非常的，则数组可能溢出。

0 0