腾讯技术类笔试笔试题(校园)123

一. 单选题(每题4分,15题,共60分)

1.考虑函数原型void hello(int a,int b=7,char* pszC=

A hello(5) B.hello(5,8) C.hello(6,

2.下面有关重载函数的说法中正确的是:C

A.重载函数必须具有不同的返回值类型 B.重载函数形参个数必须不同

C.重载函数必须有不同的形参列表 D.重载函数名可以不同

重载：必须同名函数；必须参数表不同（包含参数个数不同；参数类型不同；或参数个数与类型都不同）

3.分析一下程序的运行结果:C

#include

class CBase

{

public:

CBase(){cout

~CBase(){cout

};

class CSub : public CBase

{

public:

CSub(){cout

~CSub(){cout

};

void main()

{

CSub obj;

}

A. constructing CSub class B. constructing CBase class

constructing CBase class constructing CSub class

destructing CSub class destructing CBase class

destructing CBase class destructing CSub class

C. constructing CBase class

constructing CSub class

destructing CSub class

destructing CBase class

D. constructing CSub class

constructing CBase class

destructing CBase class

destructing CSub class

子类对象生成时：先调用父类的构造函数，然后在调用子类的构造函数；

析构时相反

4.在一个cpp文件里面,定义了一个static类型的全局变量,下面一个正确的描述是:

A.只能在该cpp所在的编译模块中使用该变量

B.该变量的值是不可改变的

C.该变量不能在类的成员函数中引用

D.这种变量只能是基本类型(如int,char)不能是C++类型

Static全局变量和普通全局变量：

针对：一个工程里有多个cpp文件时

相同点：存储方式相同，都是静态存储；

不同点：作用域不同。

普通全局变量---作用域是整个源程序（含有多个源文件），在各个源文件中都有效

Static全局变量----作用域是当前源文件

5.观察下面一段代码:

class ClassA

{

public:

virtual ~ ClassA(){};

virtual void FunctionA(){};

};

class ClassB

{

public:

virtual void FunctionB(){};

};

class ClassC : public ClassA,public ClassB

{

public:

};

ClassC aObject;

ClassA* pA=&aObject;

ClassB* pB=&aObject;

ClassC* pC=&aObject;

关于pA,pB,pC的取值,下面的描述中正确的是:

A.pA,pB,pC的取值相同. B.pC=pA+pB

C.pA和pB不相同 D.pC不等于pA也不等于pB

6.参照1.5的代码,假设定义了ClassA* pA2,下面正确的代码是:

A.pA2=static_cast(pB);

B.void* pVoid=static_cast(pB);

pA2=static_cast(pVoid);

C.pA2=pB;

D.pA2=static_cast(static_cast(pB));

7.参照1.5的代码,下面那一个语句是不安全的:

A.delete pA B.delete pB C.delete pC

删除那个都有错误，编译是无错误，运行是有错误

8.下列程序的运行结果为:

#include

void main()

{

int a=2;

int b=++a;

cout

}

A.0.5 B.0 C0.7 D.0.6666666－

9.有如下一段代码:

#define ADD(x,y) x+y

int m=3;

m+=m*ADD(m,m); //展开后为m=m+m*m+m=3+3*3+3

则m的值为:

A.15 B.12 C.18 D.58

10.如下是一个带权的图,图中结点A到结点D的关键路径的长度是:

A.13 B.15 C.28 D.58

11.下面的模板声明中,正确的是:

A.template //改为template

B.template

C.template

D.template//分号改为逗号

12.在Windows编程中下面的说法正确的是:

A.两个窗口,他们的窗口句柄可以是相同的 B.两个窗口,他们的处理函数可以是相同的

C.两个窗口,他们的窗口句柄和窗口处理函数都不可以相同.

13.下面哪种情况下,B不能隐式转换为A?

A.class B:public A{} B.class A:public B{}

C.class B{operator A();} D.class A{A(const B&);}

14.某公司使用包过滤防火墙控制进出公司局域网的数据,在不考虑使用代理服务器的情况下,下面描述错误的是”该防火墙能够( )”.

A.使公司员工只能访问Internet上与其业务联系的公司的IP地址.

B.仅允许HTTP协议通过,不允许其他协议通过,例如TCP/UDP.

C.使员工不能直接访问FTP服务器端口号为21的FTP地址.

D.仅允许公司中具有某些特定IP地址的计算机可以访问外部网络

15.数字字符0的ASCII值为48,若有以下程序:

main()

{

char a=’1’,b=’2’;

printf(“%c,”,b++);

printf(“%d\n”,b-a);

}

程序运行之后的输出结果是:

A.3,2 B.50,2 C.2,2 D.2,50

二. 填空题(共40分)

本程序从正文文件text.in读入一篇英文短文,统计该短文中不同单词和它的出现次数,并按词典编辑顺序将单词及它的出现次数输出到正文文件word.out中.

程序用一棵有序二叉树存储这些单词及其出现的次数,一边读入一边建立.然后中序遍历该二叉树,将遍历经过的二叉树上的节点的内容输出.

程序中的外部函数

int getword(FILE* pFile,char* pszWordBuffer,int nBufferLen);

从与pFile所对应的文件中读取单词置入pszWordBuffer,并返回1;若单词遇文件尾,已无单词可读时,则返回0.

#include

#include

#include

#include

#define SOURCE_FILE

#define OUTPUT_FILE

#define MAX_WORD_LEN 128

typedef struct treenode

{

char szWord[MAX_WORD_LEN];

int nCount;

struct treenode* pLeft;

struct treenode* pRight;

}BNODE;

int getword(FILE* pFile,char* pasWordBuffer,int nBufferLen);

void binary_tree(BNODE** ppNode,char* pszWord)

{

if(ppNode != NULL && pszWord != NULL)

{

BNODE* pCurrentNode = NULL;

BNODE* pMemoNode = NULL;

int nStrCmpRes=0;

____(1)_____;pCurrentNode=*ppNode

while(pCurrentNode)

{

/*寻找插入位置*/

nStrCmpRes = strcmp(pszWord, ___(2)___ );pCurrentNode->nCount

if(!nStrCmpRes)

{

___(3)___; pCurrentNode->nCount++

return;

}

else

{

___(4)___; pMemoNode=pCurrentNode

pCurrentNode = nStrCmpRes>0? pCurrentNode->pRight : pCurrentNode->pLeft;

}

}

}

pCurrent=new BNODE;

if(pCurrentNode != NULL)

{

memset(pCurrentNode,0,sizeof(BNODE));

strncpy(pCurrentNode->szWord,pszWord,MAX_WORD_LEN-1);

pCurrentNode->nCount=1;

}

if(pMemoNode==NULL)

{

___(5)___; *ppNode= pCurrentNode

}

else if(nStrCmpRes>0)

{

pMemoNode->pRight=pCurrentNode;

}

else

{

pMemoNode->pLeft=pCurrentNode;

}

}

void midorder(FILE* pFile,BNODE* pNode)

{

if(___(6)___) return;!pNode||!pFile

midorder(pFile,pNode->pLeft);

fprintf(pFile,

midorder(pFile,pNode->pRight);

}

void main()

{

FILE* pFile=NULL;

BNODE* pRootNode=NULL;

char szWord[MAX_WORD_LEN]={0};

pFile=fopen(SOURCE_FILE,

if(pFile==NULL)

{

printf(

return;

}

while(getword(pFile,szWord,MAX_WORD_LEN)==1)

{

binary_tree(___(7)___);// pRootNode,szWord

}

fclose(pFile);

pFile=fopen(OUTPUT_FILE,

midorder(pFile,pRootNode);

fclose(pFile);

}

三. 附加题(每题30分,2题,共60分)

1. 从程序健壮性进行分析,下面的FillUserInfo函数和Main函数分别存在什么问题? #include

#include

#define MAX_NAME_LEN 20

struct USERINFO

{

int nAge;

char szName[MAX_NAME_LEN];

};

void FillUserInfo(USERINFO* parUserInfo)

{

stu::cout

int nCount=0;

std::cin>>nCount;

for(int i=0;i

{

std::cout

std::cin>>parUserInfo[i]->nAge;

std::string strName;

std::cout

std::cin>>strName;

strcpy(parUserInfo[i].szName,strName.c_str());

}

}

int main(int argc,char* argv[])

{

USERINFO arUserInfos[100]={0};

FillUserInfo(arUserInfos);

printf(

printf(arUserInfos[0].szName);

printf(

return 0;

}

2. 假设你在编写一个使用多线程技术的程序,当程序中止运行时,需要怎样一个机制来安

全有效的中止所有的线程?请描述其具体流程.

----------------------------------------------------------------------------------------------------------------------

一、单项选择

1、向单链表插入节点；

2、排序的稳定性比较；

3、带头节点的单链表的判空条件；

4、二叉树的节点总数的计算；

5、递归向非递归的转化使用什么？队列，还是栈；

6、中断响应时间的定义；

7、面向对象程序设计语言不同于其他语言的主要特点;

二、填空题

1、正弦函数用泰勒展开式来计算：

下面的流程图描述了利用上述展开式计算并打印sinx的近似值的过程，其中e（>0）表示误差要求，小于该误差就可以结束计算，打印结果，请填写流程图中的空格部分。 图略

2、双循环链表的排序问题；

应该比较简单，相信你们能够搞定！

三、附加题

“背包问题”的基本描述是：有一个背包，能盛放的物品总重量为S，设有N个物件，其重量分别为W1,W2, „„„ , Wn , 希望从N件物品中选择若干物品，所选择的物品的重量之和恰能放入该背包，即所选物品的重量之和等于S。递归和非递归解法都可以求得“背包问题”的一组解，试写出“背包问题”的非递归解法。

1 计算 a^b

2 根据先序中序求后序

3 a[3][4]哪个不能表示 a[1][1]: *(&a[0][0]) *(*(a+1)+1) *(&a[1]+1) *(&a[0][0]+4)

4 for(int i..)

for(int j..)

printf(i,j);

printf(j)

会出现什么问题

5 for(i=0;i

6 10个数顺序插入查找二叉树，元素62的比较次数

7 10个数放入模10hash链表，最大长度是多少

8 fun((exp1,exp2),(exp3,exp4,exp5))有几个实参

9 希尔 冒泡 快速 插入 哪个平均速度最快

10 二分查找是 顺序存储 链存储 按value有序中的哪些

11 顺序查找的平均时间

12 *p=NULL *p=new char[100] sizeof(p)各为多少

13 频繁的插入删除操作使用什么结构比较合适，链表还是数组

14 enum的声明方式

其他1个选择暂时想不起来了

大题：

1 把字符串转换为小写，不成功返回NULL,成功返回新串

char* toLower(char* sSrcStr)

{

char* sDest= NULL;

if( -1_)

{

int j;

sLen = strlen(sSrcStr);

sDest = new [_2_];

if(*sDest == NULL)

return NULL;

sDest[sLen] = '\0';

while(3_)

sDest[sLen] = toLowerChar(sSrcStr[sLen]);

}

return sDest;

}

2 把字符串转换为整数 例如：

main()

{

...

if( *string == '-' )

n = _1__;

else

n = num(string);

..

}

int num(char* string)

{

for(;!(*string==0);string++)

{

int k;

k = _2_;

j = --sLen;

while(_3__)

k = k * 10;

num = num + k;

}

return num;

}

附加题：

1 linux下调试core的命令，察看堆栈状态命令

2 写出socks套接字 服务端 客户端 通讯程序

3 填空补全程序，按照我的理解是添入：win32调入dll的函数名

查找函数入口的函数名 找到函数的调用形式

把formView加到singledoc的声明 将singledoc加到app的声明

4 有关系 s(sno,sname) c(cno,cname) sc(sno,cno,grade)

1 问上课程

2 成绩最高的学生号

3 每科大于90分的人数

----------------------------------------------------------------------------------------------------------------------题目：给定一个数，假设其各位数之和能被9整除，证明这个数可以被9整除。

令数N表示为A1A2„An，已知Sigma(Ai)(i=1,2,„,n)%9==0为真，证明N%9==0为真。 N%9 = (A1*10^(n-1)+A2*10^(n-2)+„.+An*10^0)%9



写到这一步的时候，你会注意到一个非常重要的结论：10^i%9==1恒为真。



故而 N%9 = Sigma(Ai)%9，又已知Sigma(Ai)%9==0为真，N%9==0得证。



1. 1-20的两个数把和告诉A,积告诉B，A说不知道是多少，

B也说不知道，这时A说我知道了，B接着说我也知道了，问这两个数是多少？ 答案：2和3

2 爸爸,妈妈,妹妹,小强,至少两个人同一生肖的概率是多少?

1-12*11*10*9/12*12*12*12 = 1-55/96 = 41/96

3, 计算 a^b

答案：

运算符优先级：括号，下标，->和.(成员)最高；

单目的比双目的高；

算术双目的比其他双目的高；

位运算 高于 关系运算；

关系运算 高于 按位运算（与，或，异或）；

按位运算 高于 逻辑运算；

三目的只有一个 条件运算，低于逻辑运算；

赋值运算仅比 , （顺序运算）高。

在此题中，位左移”

4），

再与a异或。

例如： 当 a = 6； b = 4 时； 则 a^b

4 如何输出源文件的标题和目前执行行的行数？

答案： printf(”The file name: %d\n”, __FILE__);

printf(”The current line No:%d\n”, __LINE__);

ANSI C标准预定义宏:

__LINE__

__FILE__

__DATE__

__TIME__

__STDC__ 当要求程序严格遵循ANSI C标准时该标识符被赋值为1

__cplusplus__ 当编写C++程序时该标识符被定义

5 a[3][4]哪个不能表示 a[1][1]: *(&a[0][0]+5) *(*(a+1)+1) *(&a[1]+1) *(&a[0][ 0]+4)

答案: *(&a[1]+1)

a是数组的首地址，a[1]就表示a[1][0]地址了，不用再取地址了。

6 fun((exp1,exp2),(exp3,exp4,exp5))有几个实参？

答案：两个。

形式参数：在声明和定义函数时，写在函数名后的括号中的参数。

实参是调用参数中的变量，行参是被调用函数中的变量。

7. 希尔 冒泡 快速 插入 哪个平均速度最快？

答案：快速排序

快速排序、归并排序和基数排序在不同情况下都是最快最有用的。

8. enum的声明方式

答案：enum 枚举类型名 {

枚举常量1，

枚举常量2，

„

枚举常量n

};

For example:

enum weekday { sunday, monday, tuesday, wednesday, thursday, friday, saturda

y};

enum weekday week_day;//week_day 就是一个枚举类型变量

9. 频繁的插入删除操作使用什么结构比较合适，链表还是数组？

答案：链表

10. *p=NULL *p=new char[100] sizeof(p)各为多少？

答案：都为4。因为都是指针类型，所占存储空间必然为4。

11. 顺序查找的平均时间

答案：(1+2+3+„+n)/n = (n+1)/2

12. for(i=0,sum=0; i

答案：sum = 55

13. 不能做switch()的参数类型是：

答案：switch的参数不能为浮点型。

14.不使用其他变量，交换两个整型a，b的值

答案：x = x+y; y = x-y; x = x-y

15. 写出float x 与“零值”比较的if语句。

if(x>=0.000001 && x

float: 6位精度

double: 16位精度

16.

两个数相乘，小数点后位数没有限制，请写一个高精度算法

*********

数据库

*********

1. 有个表tableQQ，有整型的ID项和字符类型的Nickname项，这两个项都不允许为空

(1)写出建立该表的SQL语句

(2)找出Nickname为QQ的用户，按ID降序排列的SQL语句

(3)写出删除ID为1234用户记录的SQL语句

(4)写出添加ID为5555，Nickname为’1234′的SQL语句

答案：

(1) CREATE TABLE tableQQ

(

ID NUMBER(12) NOT NULL,

Nickname Varchar2(30) NOT NULL

);

(2) select * from tableQQ where Nickname = ‘QQ’ order by ID desc;

(3) delete from tableQQ where >

(4) insert into tableQQ values(5555,’1234′);

该信息出自应届毕业生求职网YJBYS.COM：http://www.yjbys.com

//删除表

(5)drop table tableQQ;

2. 有关系 s(sno,sname) c(cno,cname) sc(sno,cno,grade)

1 问上课程 “db”的学生

2 成绩最高的学生号

3 每科大于90分的人数

答案：

(1)select s.sno, s.cname

from s, c, sc

where s.sno = sc.sno and c.cno = sc.cno and c.cname = ‘db’;

(2)select sno, max(grade)from sc group by sno;

(3)select cno, count(sno) from sc where grade > 90 group by cno;

*************

===============

操作系统 网络

===============

1. 描述实时系统的基本特性

答案：在特定时间内完成特定的任务，实时性与可靠性。

2. Internet采用哪种网络协议？该协议的主要层次结构？

答案：TCP/IP协议。应用层、传输层、网络层、数据链路层和物理层。

3. Internet物理地址和IP地址转换采用什么协议？

答案：地址解析协议ARP address resolution protocol

4. IP地址的编码分为哪俩部分？

答案：网络号和主机号。不过是要和“子网掩码”按位与上之后才能区分哪些是网络位 哪些是主机位。

10 二分查找是 顺序存储 链存储 按value有序中的哪些

大题：

1 把字符串转换为小写，不成功返回NULL,成功返回新串

char* toLower(char* sSrcStr)

{

char* sDest= NULL;

if( __1___)

{

int j;

sLen = strlen(sSrcStr);

sDest = new [_______2_____];

if(*sDest == NULL)

return NULL;

sDest[sLen] = ‘\0′;

while(_____3____)

sDest[sLen] = toLowerChar(sSrcStr[sLen]);

}

return sDest;

}

2 把字符串转换为整数 例如：”-123″ -> -123

main()

{

„..

if( *string == ‘-’ )

n = ____1______;

else

n = num(string);

„..

}

int num(char* string)

{

for(;!(*string==0);string++)

{

int k;

k = __2_____;

j = –sLen;

while( __3__)

k = k * 10;

num = num + k;

}

return num;

}

附加题：

1 linux下调试core的命令，察看堆栈状态命令

2 写出socks套接字 服务端 客户端 通讯程序

3 填空补全程序，按照我的理解是添入：win32调入dll的函数名

查找函数入口的函数名 找到函数的调用形式

把formView加到singledoc的声明 将singledoc加到app的声明

#define Max(a,b) ( a/b)?a:b

写一个病毒

while (1)

{

int *p = new int[10000000];

}

不使用额外空间,将 A,B两链表的元素交叉归并

将树序列化 转存在数组或 链表中

struct st{

int i;

short s;

char c;

};

sizeof(struct st);

答案：8

char * p1;

void * p2;

int *p3;

char p4[10];

sizeof(p1„p4) =?

答案：4，4，4，10

二分查找

快速排序

双向链表的删除结点

有12个小球,外形相同,其中一个小球的质量与其他11个不同

给一个天平,问如何用3次把这个小球找出来

并且求出这个小球是比其他的轻还是重

该信息出自应届毕业生求职网YJBYS.COM：http://www.yjbys.com

解答:

哈哈，据说这是微软前几年的一个面试题。很经典滴啊！三次一定能求出来，而且能确定是重还是轻。

数据结构的知识还没怎么学透，不过这个题我到是自己研究过，可以分析下。 将12个球分别编号为a1,a2,a3„„.a10,a11,a12.

第一步：将12球分开3拨，每拨4个，a1~a4第一拨，记为b1， a5~a6第2拨，记为b2，其余第3拨，记为b3；

第二步：将b1和b2放到天平两盘上，记左盘为c1，右为c2；这时候分两中情况： 1.c1和c2平衡，此时可以确定从a1到a8都是常球；然后把c2拿空，并从c1上拿下a4，从a9到a12四球里随便取三球，假设为a9到a11，放到c2上。此时c1上是a1到a3，c2上是a9到a11。从这里又分三种情况：

A：天平平衡，很简单，说明没有放上去的a12就是异球，而到此步一共称了两次，所以将a12随便跟11个常球再称一次，也就是第三次，马上就可以确定a12是重还是轻； B：若c1上升，则这次称说明异球为a9到a11三球中的一个，而且是比常球重。取下c1所有的球，并将a8放到c1上，将a9取下，比较a8和a11（第三次称），如果平衡则说明从c2上取下的a9是偏重异球，如果不平衡，则偏向哪盘则哪盘里放的就是偏重异球； C：若c1下降，说明a9到a11里有一个是偏轻异球。次种情况和B类似，所以接下来的步骤照搬B就是；

2.c1和c2不平衡，这时候又分两种情况，c1上升和c1下降，但是不管哪种情况都能说明a9到a12是常球。这步是解题的关键。也是这个题最妙的地方。

A：c1上升，此时不能判断异球在哪盘也不能判断是轻还是重。取下c1中的a2到a4三球放一边，将c2中的a5和a6放到c1上，然后将常球a9放到c2上。至此，c1上是a1，a5和a6，c2上是a7，a8和a9。此时又分三中情况：

1）如果平衡，说明天平上所有的球都是常球，异球在从c1上取下a2到a4中。而且可以断定异球轻重。因为a5到a8都是常球，而第2次称的时候c1是上升的，所以a2到a4里必然有一个轻球。那么第三次称就用来从a2到a4中找到轻球。这很简单，随便拿两球放到c1和c2，平衡则剩余的为要找球，不平衡则哪边低则哪个为要找球；

2）c1仍然保持上升，则说明要么a1是要找的轻球，要么a7和a8两球中有一个是重球（这步懂吧？好好想想，很简单的。因为a9是常球，而取下的a2到a4肯定也是常球，还可以推出换盘放置的a5和a6也是常球。所以要么a1轻，要么a7或a8重）。至此，还剩一次称的机会。只需把a7和a8放上两盘，平衡则说明a1是要找的偏轻异球，如果不平衡，则哪边高说明哪个是偏重异球；

3）如果换球称第2次后天平平衡打破，并且c1降低了，这说明异球肯定在换过来的a5和a6两求中，并且异球偏重，否则天平要么平衡要么保持c1上升。确定要找球是偏重之后，将a5和a6放到两盘上称第3次根据哪边高可以判定a5和a6哪个是重球；

B：第1次称后c1是下降的，此时可以将c1看成c2，其实以后的步骤都同A，所以就不必要再重复叙述了。至此，不管情况如何，用且只用三次就能称出12个外观手感一模一样的小球中有质量不同于其他11球的偏常的球。而且在称的过程中可以判定其是偏轻还是

偏重。

给一个奇数阶N幻方，填入数字1，2，3„N*N,使得横竖斜方向上的和都相同 答案:

#include

#include

#include

usingnamespace std;

int main()

{

int n;

cin>>n;

int i;

int **Matr=newint*[n];//动态分配二维数组

for(i=0;iMatr[ i ]=newint[n];//动态分配二维数组

//j=n/2代表首行中间数作为起点，即1所在位置

int j=n/2,num=1;//初始值

i=0;

while(num!=n*n+1)

{

//往右上角延升，若超出则用%转移到左下角

Matr[(i%n+n)%n][(j%n+n)%n]=num;

//斜行的长度和n是相等的，超出则转至下一斜行

if(num%n==0)

i++;

else

{

i–;

j++;

}

num++;

}

for(i=0;i{

for(j=0;jcout

for(i=0;idelete [ ]Matr[ i ];

return1;



----------------------------------------------------------------------------------------------------------------------

1．请定义一个宏，比较两个数a、b的大小，不能使用大于、小于、if语句。

int const shift = sizeof(int)*8-1;

unsigned mask = (0x1

if ( (a-b)&mask )

max_num = b;

else

max_num = a;

#define Max(a,b) ( a/b)?a:b

2．如何输出源文件的标题和目前执行行的行数

int line= __LINE__;

char *file = __FILE__;

cout

3．两个数相乘，小数点后位数没有限制，请写一个高精度算法

与大数相乘原理一样，只是调整小数点位置，即有效小数个数

算法提示：

输入 string a, string b；计算string c=a*b; 返回 c;

1， 纪录小数点在a,b中的位置l1,l2，则需要小数点后移动位置数为l=length(a)+length(b)-l1-l2-2;

2， 去掉a,b中的小数点，（a,b小数点后移，使a,b变为整数）

3， 计算c=a*b; （要么用java的BigInterger搞, 要么自己用C++写高精度数乘法，超过百万位，用FFT,我就不细说，这都预先写过就别做了）

4， 输出c,（注意在输出倒数第l个数时，输出一个小数点。若是输出的数少于l个，就补0）

4．写一个病毒

while (1)

{

int *p = new int[10000000];

}

上面这个不对，没有传染性，寄生性……

5．不使用额外空间,将 A,B两链表的元素交叉归并将树序列化转存在数组或 链表中

struct st{

int i;

short s;

char c;

};

sizeof(struct st);

8

char * p1;

void * p2;

int p3;

char p4[10];

sizeof(p1...p4) =?

4，4，4，10

5.让你在100000000个浮点数中找出最大的10000个，要求时间复杂度优。

最小堆

二分查找

快速排序

双向链表的删除结点

有A、B、C、D四个人，要在夜里过一座桥。他们通过这座桥分别需要耗时1、2、5、10分钟

，只有一支手电，并且同时最多只能两个人一起过桥。请问，如何安排，能够在17分钟内 这四个人都过桥？

基础题有15道选择和2道读程序填空。选择题的确是很基础，主要考数据结构，还有一些体系结构、数据库的题目；读程序题跟我们平时考试的差不多，一道是两个升序链合并成一个升序链+递归，一道是四色着色方案

附加题有几道没有看清楚。有一道是unix防僵死算法，最后一道是sql查询，还有几道忘了，其中一个是很长的程序题。。

发信人: charly (查理一世), 板面: Work

标 题: 腾讯笔试题

发信站: 飘渺水云间 (Sat Nov 11 10:55:33 2006), 转信

15个选择题，60分

一个程序填空，40分

三道附加题60分

附加题考的是

不用第三个变量实现两个整形变量的交换

linux的子进程

操作系统资源抢占管理，两个进程要对文件

进行独占访问，采用共享变量，判断可行否

书写strcpy()

时间两个小时，选择题 15*4

然后是程序填空题 10 (2*5), 30 (10*3)

附加题用c++ 实现一个链地址hash。

程序填空题我就不说了，比较easy的说，值得一提的是选择题。 绝大部分考的是C++，我大致说下主要部分吧：

涉及程序执行压栈的：1道

涉及容器和迭代器的：4道

涉及虚拟函数以及dynamic_cast的 3道

涉及参数传递的 1道

简单的程序段落判断 2道

涉及类的静态成员赋值的 1道

剩下的是杂七杂八的。

不管怎么说，假如你把c++ primer 仔细阅读了一遍，基本上没问题。 考的有些细，没有涉及算法和编译等知识，所以我同屋一个兄弟很郁 闷，因为他linux底层比较好，本来报的是后台开发，哪知道结果考这 种类型的题目。

程序填空的考了文件操作，以及数组移动等。

附加题比较简单的说，只要把数据结构的hash部分好好看，然后用class 组装一下就ok了。

1.哪一个声明是错误的( )

char * const p = 0;

char const * p = 0;

const char * p = 0;

char * p const = 0;

2.下面的结构体所占内存是( )

#pragma pack(4)

struct {

unino {

char ch1;

double num;

} bbb;

char ch2;

}aaa;

#pragma pack()

3.x = 0xffffffff，则 x = (x&0xffff0000) >> 16 的结果是( )

4.#define TEST(x) (x*2+1)，则 TEST(1+1)的结果是( )

5.有15个结点的满二叉树，叶子数是( )

6.程序片段的输出结果( )

class A {

public:

A() { printf(

~A() { printf(

};

class B : public A {

public:

B() { printf(

~B() { printf(

};

B b = new B;

delete b;

7.int Func(const char *)的重载函数是( ) (选项略)

8.按顺序A, B, C进栈，出栈的结果是( )

9.程序片段的输出结果( )

class A {

public:

virtual int func() { return 1; }

};

class B : public A {

public:

virtual int func() { return 2; }

};

A *a = new B;

printf(

delete a;

10.程序片段的执行描述中正确的是( )

class A {

public:

virtual void func(A& ra);

};

class B : public A {

public:

virtual void func(B& rb);

};

B b;

A &a = b;

a.func(b);

(有点记不清了，反正俺错了这题，以为引用和指针是不同的...>_

11.关于哈希表特点错误的是( ) (选项略)

12.函数功能描述正确的是( )

int whatido(char * str)

{

return *str ? whatido(++str)+1 : 0;

}

二、程序填空(5×8)

1.二叉树的遍历

2.静态单链表Appand元素

三、附加题(20×3)

1.写出3D的镜象转置矩阵(什么东东？看不懂题意...)

2.SQL的简单东东(俺全忘了...哭)

3.商场“买200送100”算折扣(还是不懂...)

----------------------------------------------------------------------------------------------------------------------