微软算法面试100题.docx

微软算法面试100题.docx

《微软算法面试100题.docx》由会员分享，可在线阅读，更多相关《微软算法面试100题.docx（104页珍藏版）》请在冰豆网上搜索。

微软算法面试100题

1.把二元查找树转变成排序的双向链表

题目：

输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。

要求不能创建任何新的结点，只调整指针的指向。

10

/\

614

/\/\

481216

转换成双向链表

4=6=8=10=12=14=16。

首先我们定义的二元查找树节点的数据结构如下：

structBSTreeNode

{

intm_nValue;//valueofnode

BSTreeNode*m_pLeft;//leftchildofnode

BSTreeNode*m_pRight;//rightchildofnode

};

ANSWER:

Thisisatraditionalproblemthatcanbesolvedusingrecursion.

Foreachnode,connectthedoublelinkedlistscreatedfromleftandrightchildnodetoformafulllist.

/**

*@paramrootTherootnodeofthetree

*@returnTheheadnodeoftheconvertedlist.

*/

BSTreeNode*treeToLinkedList（BSTreeNode*root）{

BSTreeNode*head,*tail;

helper（head,tail,root）;

returnhead;

}

voidhelper（BSTreeNode*&head,BSTreeNode*&tail,BSTreeNode*root）{

BSTreeNode*lt,*rh;

if（root==NULL）{

head=NULL,tail=NULL;

return;

}

helper（head,lt,root->m_pLeft）;

helper（rh,tail,root->m_pRight）;

if（lt!

=NULL）{

lt->m_pRight=root;

root->m_pLeft=lt;

}else{

head=root;

}

if（rh!

=NULL）{

root->m_pRight=rh;

rh->m_pLeft=root;

}else{

tail=root;

}

}

2.设计包含min函数的栈。

定义栈的数据结构，要求添加一个min函数，能够得到栈的最小元素。

要求函数min、push以及pop的时间复杂度都是O

（1）。

ANSWER:

StackisaLIFOdatastructure.Whensomeelementispoppedfromthestack,thestatuswillrecovertotheoriginalstatusasbeforethatelementwaspushed.Sowecanrecovertheminimumelement,too.

structMinStackElement{

intdata;

intmin;

};

structMinStack{

MinStackElement*data;

intsize;

inttop;

}

MinStackMinStackInit（intmaxSize）{

MinStackstack;

stack.size=maxSize;

stack.data=（MinStackElement*）malloc（sizeof（MinStackElement）*maxSize）;

stack.top=0;

returnstack;

}

voidMinStackFree（MinStackstack）{

free（stack.data）;

}

voidMinStackPush（MinStackstack,intd）{

if（stack.top==stack.size）error（“outofstackspace.”）;

MinStackElement*p=stack.data[stack.top];

p->data=d;

p->min=（stack.top==0?

d:

stack.data[top-1]）;

if（p->min>d）p->min=d;

top++;

}

intMinStackPop（MinStackstack）{

if（stack.top==0）error（“stackisempty!

”）;

returnstack.data[--stack.top].data;

}

intMinStackMin（MinStackstack）{

if（stack.top==0）error（“stackisempty!

”）;

returnstack.data[stack.top-1].min;

}

3.求子数组的最大和

题目：

输入一个整形数组，数组里有正数也有负数。

数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。

求所有子数组的和的最大值。

要求时间复杂度为O（n）。

例如输入的数组为1,-2,3,10,-4,7,2,-5，和最大的子数组为3,10,-4,7,2，

因此输出为该子数组的和18。

ANSWER:

Atraditionalgreedyapproach.

Keepcurrentsum,slidefromlefttoright,whensum<0,resetsumto0.

intmaxSubarray（inta[],intsize）{

if（size<=0）error（“errorarraysize”）;

intsum=0;

intmax=-（1<<31）;

intcur=0;

while（cur

sum+=a[cur++];

if（sum>max）{

max=sum;

}elseif（sum<0）{

sum=0;

}

}

returnmax;

}

4.在二元树中找出和为某一值的所有路径

题目：

输入一个整数和一棵二元树。

从树的根结点开始往下访问一直到叶结点所经过的所有结点形成一条路径。

打印出和与输入整数相等的所有路径。

例如输入整数22和如下二元树

10

/\

512

/\

47

则打印出两条路径：

10,12和10,5,7。

二元树节点的数据结构定义为：

structBinaryTreeNode//anodeinthebinarytree

{

intm_nValue;//valueofnode

BinaryTreeNode*m_pLeft;//leftchildofnode

BinaryTreeNode*m_pRight;//rightchildofnode

};

ANSWER:

Usebacktrackingandrecurison.Weneedastacktohelpbacktrackingthepath.

structTreeNode{

intdata;

TreeNode*left;

TreeNode*right;

};

voidprintPaths（TreeNode*root,intsum）{

intpath[MAX_HEIGHT];

helper（root,sum,path,0）;

}

voidhelper（TreeNode*root,intsum,intpath[],inttop）{

path[top++]=root.data;

sum-=root.data;

if（root->left==NULL&&root->right==NULL）{

if（sum==0）printPath（path,top）;

}else{

if（root->left!

=NULL）helper（root->left,sum,path,top）;

if（root->right!

=NULL）helper（root->right,sum,path,top）;

}

top--;

sum-=root.data;

}

5.查找最小的k个元素

题目：

输入n个整数，输出其中最小的k个。

例如输入1，2，3，4，5，6，7和8这8个数字，则最小的4个数字为1，2，3和4。

ANSWER:

Thisisaverytraditionalquestion...

O（nlogn）:

catI_FILE|sort-n|head-nK

O（kn）:

doinsertionsortuntilkelementsareretrieved.

O（n+klogn）:

TakeO（n）timetobottom-upbuildamin-heap.Thensift-downk-1times.

SotraditionalthatIdon’twanttowritethecodes...

Onlygivesthesiftupandsiftdownfunction.

/**

*@paramitheindexoftheelementinheapa[0...n-1]tobesiftedup

voidsiftup（inta[],inti,intn）{

while（i>0）{

intj=（i&1==0?

i-1:

i+1）;

intp=（i-1）>>1;

if（j

if（a[i]

i=p;

}

}

voidsiftdown（inta[],inti,intn）{

while（2*i+1

intl=2*i+1;

if（l+1

if（a[l]

i=l;

}

}

第6题

腾讯面试题：

给你10分钟时间，根据上排给出十个数，在其下排填出对应的十个数

要求下排每个数都是先前上排那十个数在下排出现的次数。

上排的十个数如下：

【0，1，2，3，4，5，6，7，8，9】

举一个例子，

数值:

0,1,2,3,4,5,6,7,8,9

分配:

6,2,1,0,0,0,1,0,0,0

0在下排出现了6次，1在下排出现了2次，

2在下排出现了1次，3在下排出现了0次....

以此类推..

ANSWER:

Idon’tlikebrainteasers.Willskipmostofthem...

第7题

微软亚院之编程判断俩个链表是否相交

给出俩个单向链表的头指针，比如h1，h2，判断这俩个链表是否相交。

为了简化问题，我们假设俩个链表均不带环。

问题扩展：

1.如果链表可能有环列?

2.如果需要求出俩个链表相交的第一个节点列?

ANSWER:

structNode{

intdata;

intNode*next;

};

//ifthereisnocycle.

intisJoinedSimple（Node*h1,Node*h2）{

while（h1->next!

=NULL）{

h1=h1->next;

}

while（h2->next!

=NULL）{

h2=h2->next;

}

returnh1==h2;

}

//iftherecouldexistcycle

intisJoined（Node*h1,Node*h2）{

Node*cylic1=testCylic（h1）;

Node*cylic2=testCylic（h2）;

if（cylic1+cylic2==0）returnisJoinedSimple（h1,h2）;

if（cylic1==0&&cylic2!

=0||cylic1!

=0&&cylic2==0）return0;

Node*p=cylic1;

while

（1）{

if（p==cylic2||p->next==cylic2）return1;

p=p->next->next;

cylic1=cylic1->next;

if（p==cylic1）return0;

}

}

Node*testCylic（Node*h1）{

Node*p1=h1,*p2=h1;

while（p2!

=NULL&&p2->next!

=NULL）{

p1=p1->next;

p2=p2->next->next;

if（p1==p2）{

returnp1;

}

}

returnNULL;

}

第8题

此贴选一些比较怪的题，，由于其中题目本身与算法关系不大，仅考考思维。

特此并作一题。

1.有两个房间，一间房里有三盏灯，另一间房有控制着三盏灯的三个开关，

这两个房间是分割开的，从一间里不能看到另一间的情况。

现在要求受训者分别进这两房间一次，然后判断出这三盏灯分别是由哪个开关控制的。

有什么办法呢？

ANSWER:

Skip.

2.你让一些人为你工作了七天，你要用一根金条作为报酬。

金条被分成七小块，每天给出一

块。

如果你只能将金条切割两次，你怎样分给这些工人?

ANSWER:

1+2+4;

3.★用一种算法来颠倒一个链接表的顺序。

现在在不用递归式的情况下做一遍。

ANSWER:

Node*reverse（Node*head）{

if（head==NULL）returnhead;

if（head->next==NULL）returnhead;

Node*ph=reverse（head->next）;

head->next->next=head;

head->next=NULL;

returnph;

}

Node*reverseNonrecurisve（Node*head）{

if（head==NULL）returnhead;

Node*p=head;

Node*previous=NULL;

while（p->next!

=NULL）{

p->next=previous;

previous=p;

p=p->next;

}

p->next=previous;

returnp;

}

★用一种算法在一个循环的链接表里插入一个节点，但不得穿越链接表。

ANSWER:

Idon’tunderstandwhatis“Chuanyue”.

★用一种算法整理一个数组。

你为什么选择这种方法?

ANSWER:

Whatis“Zhengli?

”

★用一种算法使通用字符串相匹配。

ANSWER:

Whatis“Tongyongzifuchuan”...astringwith“*”and“?

”?

Ifso,hereisthecode.

intmatch（char*str,char*ptn）{

if（*ptn==‘\0’）return1;

if（*ptn==‘*’）{

do{

if（match（str++,ptn+1））return1;

}while（*str!

=‘\0’）;

return0;

}

if（*str==‘\0’）return0;

if（*str==*ptn||*ptn==‘?

’）{

returnmatch（str+1,ptn+1）;

}

return0;

}

★颠倒一个字符串。

优化速度。

优化空间。

voidreverse（char*str）{

reverseFixlen（str,strlen（str））;

}

voidreverseFixlen（char*str,intn）{

char*p=str+n-1;

while（str

charc=*str;

*str=*p;*p=c;

}

}

★颠倒一个句子中的词的顺序，比如将“我叫克丽丝”转换为“克丽丝叫我”，

实现速度最快，移动最少。

ANSWER:

Reversethewholestring,thenreverseeachword.UsingthereverseFixlen（）above.

voidreverseWordsInSentence（char*sen）{

intlen=strlen（sen）;

reverseFixlen（sen,len）;

char*p=str;

while（*p!

=’\0’）{

while（*p==‘‘&&*p!

=’\0’）p++;

str=p;

while（p!

=‘‘&&*p!

=’\0’）p++;

reverseFixlen（str,p-str）;

}

}

★找到一个子字符串。

优化速度。

优化空间。

ANSWER:

KMP?

BM?

Sunday?

UsingBMorsunday,ifit’sASCIIstring,thenit’seasytofastaccesstheauxiliaryarray.Otherwiseanhashmaporbstmaybeneeded.Letsassumeit’sanASCIIstring.

intbm_strstr（char*str,char*sub）{

intlen=strlen（sub）;

inti;

intaux[256];

memset（aux,sizeof（int）,256,len+1）;

for（i=0;i

aux[sub[i]]=len-i;

}

intn=strlen（str）;

i=len-1;

while（i

intj=i,k=len-1;

while（k>=0&&str[j--]==sub[k--]）

;

if（k<0）returnj+1;

if（i+1

i+=aux[str[i+1]];

else

return-1;

}

}

However,thisalgorithm,aswellasBM,KMPalgorithmsuseO（|sub|）space.Ifthisisnotacceptable,Rabin-carpalgorithmcandoit.Usinghashingtofastfilteroutmostfalsematchings.

#defineHBASE127

intrc_strstr（char*str,char*sub）{

intdest=0;

char*p=sub;

intlen=0;

intTO_REDUCE=1;

while（*p!

=’\0’）{

dest=HBASE*dest+（int）（*p）;

TO_REDUCE*=HBASE;

len++;

}

inthash=0;

p=str;

inti=0;

while（*p!

=‘\0’）{

if（i++

elsehash=（hash-（TO_REDUCE*（int）（*（p-len））））*HBASE+（int）（*p）;

if（hash==dest&&i>=len&&strncmp（sub,p-len+1,len）==0）returni-len;

p++;

}

return-1;

}

★比较两个字符串，用O（n）时间和恒量空间。

ANSWER:

Whatis“comparingtwostrings”?

Justnormalstringcomparison?

ThenaturalwayuseO（n）timeandO

（1）space.

intstrcmp（char*p1,char*p2）{

while（*p1!

=‘\0’&&*p2!

=‘\0’&&*p1==*p2）{

p1++,p2++;

}

if（*p1==‘\0’&&*p2==‘\0’）return0;

if（*p1==‘\0’）return-1;

if（*p2==‘\0’）return1;

return（*p1-*p2）;//itcanbenegotiatedwhethertheabove3if’sarenecessary,Idon’tliketoomitthem.

}

★假设你有一个用1001个整数组成的数组，这些整数是任意排列的，但是你知道所有的整数都在1到1000（包括1000）之间。

此外，除一个数字出现两次外，其他所有数字只出现一次。

假设你只能对这个数组做一次处理，用一种算法找出重复的那个数字。

如果你在运算中使用了辅助的存储方式，那么你能找到不用这种方式的算法吗?

ANSWER:

Sumupallthenumbers,thensubtractthesumfrom1001*1002/2.

Anotherway,useAXORAXORB=B:

intfindX（inta[]）{

int