2013搜狐校园招聘笔试题

一、不定项选择题

1.C/C++语言：以下打印结果为（）。

#include <iostream>
using namespace std;

void swap_int(int a, int b)
{
    int temp = a;
    a = b;
    b = temp;
}
void swap_str(char *a, char *b)
{
    char *temp = a;
    a = b;
    b = temp;
}

int main()
{
    int a = 10;
    int b = 5;
    char *str_a = "hello world";
    char *str_b = "world hello";
    swap_int(a, b);
    swap_str(str_a, str_b);
    printf("%d, %d, %s, %s", a, b, str_a, str_b);
    return 0;
}

A. 10, 5, hello world, world hello

B. 10, 5, world hello, hello world

C. 5, 10, hello world, world hello

D. 5, 10, world hello, hello world

答：A。都是按值传递，不改变原值

详解swap函数见：http://blog.chinaunix.net/uid-20769502-id-3436523.html

2. C/C++语言：请问打印的两个字符分别是（）。

#include <iostream>
using namespace std;

typedef struct object object;
struct object
{
    char data[3];
};

object obj_array[3] = {{'a', 'b', 'c'},
                        {'d', 'e', 'f'},
                        {'g', 'h', 'i'},
                        };

int main()
{
    object *cur = obj_array;
    printf("%c, %c", *(char*)((char*)(cur)+2), *(char*)(cur+2));
    return 0;
}

A.c, g

B. b, d

C. g, g

D. g, c

答：A

cur中存储的是'a‘的地址，当cur是object指针时，cur+1后cur存储是数组下一个元素的首地址，即'd'的地址。当cur是char指针时，cur+1是'a'的下一个字符的地址，即'b'的地址

3. C/C++语言：请问在64位平台机器下，以下程序的输出结果（）

char *string_a = (char*)malloc(100*sizeof(char));
char string_b[100];
printf("%d, %d",sizeof(string_a), sizeof(string_b));

A. 8, 100

B. 100, 8

C. 100, 100

D. 8, 8

答：A

string_a是一个指针，不管它指向的空间有多大，它本身的空间 是固定的。在64位平台机器下，一个指针的大小是8。

4、假设二叉排序树的定义是：1、若它的左子树不为空，则左子树所有节点均小于它的根节点的值；2、若右子树不为空，则右子树所有节点的值均大于根节点的值；3、它的左右子树也分别为二叉排序树。下列哪种遍历之后得到一个递增有序数列（B）
A、前序遍历    B、中序遍历     C、后序遍历      D、广度遍历

分析：要是得到的序列为递增，应先访问左子树，再访问根结点，最后访问右子树，根据定义知为中序遍历

5. 往一个栈顺序push下列元素：ABCDE，其pop可能的顺序，下列不正确的是（）

A. BACDE

B. ACDBE

C. AEBCD

D. AEDCB

答：C。

6. 1100|1010， 1001^1001， 1001&1100分别为（）

A. 1110， 0000， 1000

B. 1000， 1001， 1000

C. 1110， 1001， 0101

D. 1000， 1001， 1000

答：A

1 | 1 = 1， 1 | 0 = 1， 0 | 0 = 0

1 ^ 1 = 0， 1 ^ 0 = 1， 0 ^ 0 = 0

1 & 1 = 1， 1 & 0 = 0， 0 & 0 = 0

7.二叉树是一种树形结构，每个节点至多有两颗子树，下列一定是二叉树的是（）

A. 红黑树

B. B树

C. AVL树

D. B+树

答：AC

8.int A[2][3] = {1, 2, 3, 4, 5, 6}, A[1][0]和*(*(A+1)+1)的值分别是（）。

A. 4， 5

B. 4， 3

C.3， 5

D.3， 4

答：A

数组是A[2][3] = {{1, 2, 3}, {4, 5, 6}}，数组下标从0开始计数。前者是第1行第0列，后者是第1行第1列

9.序列16， 14， 10， 8， 7， 9， 3， 2， 4， 1的说法下面哪一个正确（）

A. 是大顶堆

B. 是小顶堆

C. 不是堆

D. 是二叉排序树

答：A

 

10. 输入若已经是排好序的，下列排序算法最快的是（）

A. 插入排序

B. Shell排序

C. 合并排序

D. 快速排序

答：A

插入排序一遍扫描即可

Shell排序虽不需要交换数据，但也要进行几次插入排序

合并排序虽不需要交换数据，但也要进行lgn次合并

快速排序在数列有序的情况下效率是最低的

11.一种既有利于短作业又兼顾长期作业的调度方法是（）。

A. 先来先服务

B. 均衡调度

C. 最短作业优先

D. 最高响应比优先

答：D

分析：最高响应比优先法(HRN，Highest Response_ratio Next)是对FCFS方式和SJF方式的一种综合平衡。FCFS方式只考虑每个作业的等待时间而未考虑执行时间的长短，而SJF方式只考虑执行时间而未考虑等待时间的长短。因此，这两种调度算法在某些极端情况下会带来某些不便。HRN调度策略同时考虑每个作业的等待时间长短和估计需要的执行时间长短，从中选出响应比最高的作业投入执行。    响应比R定义如下： R =(W+T)/T = 1+W/T  
  其中T为该作业估计需要的执行时间，W为作业在后备状态队列中的等待时间。每当要进行作业调度时，系统计算每个作业的响应比，选择其中R最大者投入执行。这样，即使是长作业，随着它等待时间的增加，W / T也就随着增加，也就有机会获得调度执行。这种算法是介于FCFS和SJF之间的一种折中算法。由于长作业也有机会投入运行，在同一时间内处理的作业数显然要少于SJF法，从而采用HRN方式时其吞吐量将小于采用SJF 法时的吞吐量。另外，由于每次调度前要计算响应比，系统开销也要相应增加。 
等待时间一定，要求服务的时间越短，先运行；要求服务的时间一定，等待时间越长，先运行。

12.同一进程下的线程可以共享（）

A. stack

B. data section

C. register set

D. thread ID

答：B

A是栈区。同一个进程的线程共享堆区，但是各自维护自己的栈区

B是数据区。

C是寄存器

D线程ID。同一进程的线程共享一进程ID，各自拥有自己的线程ID

参考http://blog.csdn.net/yang201240/article/details/7243991

13.系统中的“颠簸”是由（）引起的。

A. 内存容量不足

B. 缺页率高

C.交换信息量大

D. 缺页率反馈模型不正确

答：D

“颠簸”是《计算机操作系统》中的“抖动”，A和B会造成抖动，但不是主要原因。主要原因是由于每个进程的页面数没有很好地计算，导致某些页面反复地进出。

14.8瓶酒一瓶有毒，用人测试。每次测试结果8小时后才会得到，而你只有8小时的时间，最少需要（）人测试

A. 2

B. 3

D. 4

D. 6

答：B。类似不带差错控制的海明码。淘宝出过这种题。类似这样的题均可有2^x=8得出x=3。。

是3个人，如果你学过数的2进制编码，就容易说了：
8瓶酒的编码如下：
0: 000
1: 001
2: 010
3: 011
4: 100
5: 101
6: 110
7: 111
3个人分别喝3个位上为1的编码，所以：
第一个：1,3,5,7
第二个：2,3,6,7
第三个：4,5,6,7
把中毒的人的位填1的二进制数，就是毒酒的编号。

15、下列关于网络编程错误的是（ABD）
A、TCP建立和关闭连接都只需要三次握手
B、UDP是可靠服务
C、主动关闭的一端会出现TIME_WAIT状态
D、服务端编程会调用listen()，客户端也可以调用bind()

答：ABD

TCP的关闭连接是四次握手

UDP提供的是面向无连接的不可靠服务

C参考http://blog.csdn.net/zhangjay/article/details/6403076

客户端不可以调用bind()

16. 进程间的通讯有哪几种形式（）

A. Socket

B. Pipe

C. Shared memory

D. Signal

答：ABCD

17、TCP/UDP下面正确的是（AC）
A、TCP provide connection-oriented,byte-stream service;
B、Both TCP and UDP provide reliability service;
C、TCP also provides flow control;
D、Both TCP and UDP provide retransmission mechanism;

18、分布式系统设计包括（ABCDE）
A、容错，design for fault
B、多数据中心的数据一致性
C、数据/服务可靠性
D、可扩展性
E、要满足ACID特性

 

19.10个不同的球，放入3个不同的桶内，共有（）种方法

A. 1000

B. 720

C. 59049

D. 360

答：C

3^10

20.87的100次幂除以7的余数是多少（）

A. 1

B. 2

C. 3

D. 4

答：D

由公式(a*b)%c == (a%c)*(b%c)可知(87^100)%7=(87%7)^100=(3^100)%7

对于任意n(n>=0)，(3^n)%7只能6种可能，依次为1，3，2，6，4，5……

87^100%7=3^100%6=9^50%7=2^50%7=32^10%7=4^10%7=16^5%7=2^5%7=32%7=4

二、简答题

1. （1）请描述进程和线程的区别？

见 4-16笔试第七题和 Linux2.6进程

（2）多线程程序有什么优点，缺点？

（3）多进程程序有什么优点，缺点？与多线程相比，有何区别。

 

2.写代码：反转一个单链表，分别以迭代和递归形式实现

typedef struct node LinkNode;
struct node
{
    int data;
    LinkNode *Next;
};
//@ret 返回新链表头节点
LinkNode *reverse_link(LinkNode *head);
LinkNode *reverse_link_recursive(LinkNode *head);

#include <iostream>
using namespace std;

typedef struct node LinkNode;
struct node
{
    int data;
    LinkNode *Next;
};
//@ret 返回新链表头节点
LinkNode *reverse_link(LinkNode *head);
LinkNode *reverse_link_recursive(LinkNode *head);
//非递归方法
LinkNode *reverse_link(LinkNode *head)
{
    LinkNode *p = head;
    while(p->Next != NULL)
        p = p->Next;
    LinkNode *ret = p;
    LinkNode *q = head;
    while(1)
    {
        while(q->Next != p)
            q = q->Next;
        p->Next = q;
        p = q;
        if(q == head)
        {
            q->Next = NULL;
            break;
        }
        q = head;
    }
    return ret;
}
//递归方法
LinkNode *reverse_link_recursive(LinkNode *head)
{
    if(head->Next == NULL)
        return head;
    LinkNode *ret = reverse_link_recursive(head->Next);
    head->Next->Next = head;
    head->Next = NULL;
    return ret;
}
//输出结果，用于测试
void Print(LinkNode *head)
{
    LinkNode *p = head;
    while(p)
    {
        cout<<p->data<<' ';
        p = p->Next;
    }
    cout<<endl;
}
//不是题目要求，用于测试
int main()
{
    int i;
    LinkNode *p = NULL;
    for(i = 0; i < 10; i++)
    {
        LinkNode *q = new LinkNode;
        q->data = i;
        q->Next = p;
        p = q;
    }
    Print(p);
    p = reverse_link(p);
    Print(p);
    p = reverse_link_recursive(p);
    Print(p);
    return 0;
}

// 返回新链表头节点
LinkNode *reverse_link(LinkNode *head)
{
    if(head == NULL)
        return NULL;
    LinkNode *prev , *curr , *reverse_head , *temp;
    prev = NULL , curr = head;
    while(curr->next)
    {
        temp = curr->next;
        curr->next = prev;
        prev = curr;
        curr = temp;
    }
    curr->next = prev;
    reverse_head = curr;
    return reverse_head;
}

LinkNode *reverse_link_recursive(LinkNode *head)
{
    if(head == NULL)
        return NULL;
    LinkNode *curr , *reverse_head , *temp;
    if(head->next == NULL)    // 链表中只有一个节点，逆转后的头指针不变
        return head;
    else
    {
        curr = head;
        temp = head->next;    // temp为(a2,...an)的头指针
        reverse_head = reverse_link_recursive(temp);   // 逆转链表(a2,...an),并返回逆转后的头指针
        temp->next = curr;    // 将a1链接在a2之后
        curr->next = NULL;
    }
    return reverse_head;      // (a2,...an)逆转链表的头指针即为(a1,a2,...an)逆转链表的头指针
}

3、给一个数组，元素都是整数（有正数也有负数），寻找连续的元素相加之和为最大的序列。
如：1、-2、3、5、-4、6 连续序列3、5、-4、6的和最大。
如元素全为负数，则最大的和为0，即一个也没有选。
/*
array[]     输入数组
n           数组元素个数
            返回最大序列和
*/
int find_max_sum(int array[] , int n)

int find_max_sum(int array[] , int n)
{
    int i , max , sum;
    sum = max = array[0];
    for(i = 1 ; i < n ; ++i)
    {
        if(sum < 0)
            sum = array[i];
        else
            sum += array[i];
        if(sum > max)
            max = sum;
    }
    if(max < 0)
        max = 0;
    return max;
}

#include <iostream>
using namespace std;
int main()
{
    int n,m,i,j,num,start,end,start1;
    long max,temp;
    while(cin>>n)
    {
        for(j=1;j<=n;j++)
        {
            cin>>m;
            cin>>num;
            max=temp=num;
            start=start1=end=1;
            for(i=2;i<=m;i++)
            {
                cin>>num;
                if(temp>=0) {temp=num+temp;}
                else
                {
                    temp=num;
                    start1=i;
                }
                if(temp>max)
                {
                    max=temp;
                    start=start1;
                    end=i;
                }
            }
            cout<<"Case "<<j<<':'<<endl;
            cout<<max<<' '<<start<<' '<<end<<endl;
            if(j!=n) cout<<endl;
        }
    }
    return 0;
}

三、设计题
1、设计一个图片存储系统：假设有一个相册系统，每个用户不限制上传的图片数目，每张相片压缩后都在1M以内，需求如下：
（1）文件数量太大，采用传统的文件系统存储导致目录系统非常臃肿，访问速度变得缓慢；
（2）单机存储容量已经远远不能承载所有的文件；
（3）上传之后，用户只有读取操作和删除操作，不支持修改，整个系统读写比例10:1
思路：可以使用分布式的文件系统，觉得hadoop的HDFS很符合要求，这是hadoop对googleGDFS的实现。