亚信校招笔试题目Word下载.docx

亚信校招笔试题目Word下载.docx

《亚信校招笔试题目Word下载.docx》由会员分享，可在线阅读，更多相关《亚信校招笔试题目Word下载.docx（29页珍藏版）》请在冰豆网上搜索。

minLeft=getlength（tNode.leftNode,curLength+tNode.value）;

if（tNode.rightNode!

=null）{

minRight=getlength（tNode.rightNode,curLength+tNode.value）;

if（tNode.leftNode==null&

&

tNode.rightNode==null）{

returncurLength+tNode.value;

if（tNode.leftNode==null）{

returnminRight;

if（tNode.rightNode==null）{

returnminLeft;

returnminLeft>

minRight?

minRight:

minLeft;

}

classTreeNode{

intvalue;

TreeNodeleftNode;

TreeNoderightNode;

TreeNode（intvalue,TreeNodelefeNode,TreeNoderightNode）{

this.value=value;

this.leftNode=lefeNode;

this.rightNode=rightNode;

2.lru

#include<

iostream>

usingnamespacestd;

intlruCountMiss（intmax_cache_size,int*pages,intlen）

{

intcount=0;

inti,j,k,n;

boolflag=false;

int*a=newint[max_cache_size];

//初始化高速缓存数组

for（i=0;

i<

max_cache_size;

i++）

{

a[i]=-1;

}

for（j=0;

j<

len;

j++）

for（i=0;

if（pages[j]!

=a[i]）

continue;

else

break;

if（i!

=max_cache_size）

for（k=i;

k<

k++）

if（a[k]==-1）

flag=true;

if（!

flag）

for（n=i;

n<

max_cache_size-1;

n++）

a[n]=a[n+1];

a[max_cache_size-1]=pages[j];

flag=false;

k-1;

a[k-1]=pages[j];

count++;

if（a[i]==-1）

a[i]=pages[j];

break;

max_cache_size-1;

a[i]=a[i+1];

returncount;

}

intmain（）

intarr[]={7,0,1,2,0,3,0,4};

cout<

<

lruCountMiss（3,arr,8）<

endl;

return0;

3.反转链表

lnode*reverse（lnode*head）{

if（head）{

lnode*prev=NULL;

lnode*curr=head;

lnode*next=curr->

next;

curr->

next=prev;

while（next!

=NULL）{

prev=curr;

curr=next;

next=next->

curr->

}

returncurr;

}else{

returnhead;

};

lnode*reverseLinkedList（lnode*list）{

if（list）{

lnode*ori=list;

lnode*half=list;

lnode*prev=list;

while（list&

half&

half->

next）{

prev=list;

list=list->

half=half->

if（half）{

prev->

next=reverse（list）;

returnori;

returnlist;

4.SJF

floatwaitingTimeSJF（int*requestTimes,int*durations,intn）{

int*flags=newint[n];

floatsums=0;

for（inti=0;

i<

n;

i++）{

flags[i]=-1;

intnowtime=0;

for（inti=0;

i<

i++）{

for（intk=0;

k<

k++）{

if（count==0）{

if（requestTimes[k]<

=nowtime&

durations[k]>

=0）{

flags[count++]=k;

else{

if（durations[k]>

=0&

requestTimes[k]<

=nowtime）{

if（durations[k]<

durations[flags[0]]）{

count=1;

flags[0]=k;

}elseif（durations[k]==durations[flags[0]]）{

if（count==0）{

for（intj=0;

j<

n;

j++）{

if（durations[j]>

flags[0]=j;

nowtime=requestTimes[j];

intidx=flags[0];

intminreq=requestTimes[flags[0]];

intmindrus=durations[idx];

if（count>

1）{

for（intj=1;

count;

if（requestTimes[flags[j]]<

minreq）{

minreq=requestTimes[flags[j]];

idx=flags[j];

sums+=nowtime-requestTimes[idx];

nowtime+=durations[idx];

requestTimes[idx]=-1;

durations[idx]=-1;

returnsums/n;

5无向连通判断是否为树

#include<

stdio.h>

stdlib.h>

string.h>

constintN=10000,M=100000;

booledge[N][N];

//数组记录两点是否存在边

boolvisit[N];

//标记该节点是否访问过

boolDFS_check（intx,inty=-1）

{

if（visit[x]）

returnfalse;

visit[x]=true;

inti;

for（i=0;

N;

i++）

if（edge[x][i]&

i!

=y）

if（visit[i]）

returnfalse;

else

if（!

DFS_check（i,x））

returntrue;

intmain（）

intn,m;

scanf（"

%d%d"

&

n,&

m）;

memset（edge,false,sizeof（edge））;

inti,x,y;

for（i