亚信校招笔试题目.docx

亚信校招笔试题目.docx

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

亚信校招笔试题目

1.BST

publicclassBSTMinLength{

publicstaticvoidmain（String[]args）{

TreeNodetNode11=newTreeNode（10,null,null）;

TreeNodetNode12=newTreeNode（50,null,null）;

TreeNodetNode13=newTreeNode（5,null,null）;

TreeNodetNode14=newTreeNode（30,null,null）;

TreeNodetNode21=newTreeNode（30,tNode11,tNode12）;

TreeNodetNode22=newTreeNode（30,tNode13,tNode14）;

TreeNodetNodeRoot=newTreeNode（100,tNode21,tNode22）;

}

privatestaticintminlength（TreeNodetNode）

{

if（tNode!

=null）{

returngetlength（tNode,0）;

}

return-1;

}

privatestaticintgetlength（TreeNodetNode,intcurLength）{

intminLeft=-1;

intminRight=-1;

if（tNode.leftNode!

=null）{

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

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

{

a[i]=-1;

}

for（j=0;j

{

for（i=0;i

{

if（pages[j]!

=a[i]）

{

continue;

}

else

{

break;

}

}

if（i!

=max_cache_size）

{

for（k=i;k

{

if（a[k]==-1）

{

flag=true;

break;

}

}

if（!

flag）

{

for（n=i;n

{

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

}

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

}

else

{

flag=false;

for（n=i;n

{

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

}

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

}

}

else

{

count++;

for（i=0;i

{

if（a[i]==-1）

{

a[i]=pages[j];

flag=true;

break;

}

}

if（!

flag）

{

for（i=0;i

{

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

}

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

}

else

flag=false;

}

}

returncount;

}

intmain（）

{

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

cout<

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->next;

curr->next=prev;

}

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->next;

half=half->next;

if（half）{

half=half->next;

}

}

if（list）{

prev->next=reverse（list）;

}

returnori;

}

returnlist;

}

4.SJF

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

int*flags=newint[n];

floatsums=0;

for（inti=0;i

flags[i]=-1;

}

intnowtime=0;

for（inti=0;i

intcount=0;

for（intk=0;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]

count=1;

flags[0]=k;

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

flags[count++]=k;

}

}

}

}

if（count==0）{

count=1;

for（intj=0;j

if（durations[j]>=0）{

flags[0]=j;

nowtime=requestTimes[j];

}

}

}

intidx=flags[0];

intminreq=requestTimes[flags[0]];

intmindrus=durations[idx];

if（count>1）{

for（intj=1;j

if（requestTimes[flags[j]]

minreq=requestTimes[flags[j]];

idx=flags[j];

}

}

}

sums+=nowtime-requestTimes[idx];

nowtime+=durations[idx];

requestTimes[idx]=-1;

durations[idx]=-1;

}

returnsums/n;

}

5无向连通判断是否为树

#include

#include

#include

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;i

if（edge[x][i]&&i!

=y）

if（visit[i]）

returnfalse;

else

if（!

DFS_check（i,x））

returnfalse;

returntrue;

}

intmain（）

{

intn,m;

scanf（"%d%d",&n,&m）;

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

inti,x,y;

for（i=0;i

{

scanf（"%d%d",&x,&y）;

edge[x-1][y-1]=true;

edge[y-1][x-1]=true;

}

memset（visit,false,sizeof（visit））;

boolresult=DFS_check（0）;

if（result）

for（i=0;i

if（!

visit[i]）

result=false;

if（result）

printf（"Yes!

\n"）;

else

printf（"No!

\n"）;

system（"pause"）;

return0;

}

6.老鼠奶酪

#include

usingnamespacestd;

intisPath（int**grid,intm,intn）;

struct_TraversedNode{

intx;

inty;

_TraversedNode*next;

};

struct_Node{

intx;

inty;

};

intmain（intargc,constchar*argv[]）

{

int**grid=newint*[8];

for（inti=0;i<8;i++）

{

grid[i]=newint[8];

}

grid[0][0]=1;grid[0][1]=1;grid[0][2]=0;grid[0][3]=0;grid[0][4]=0;grid[0][5]=0;grid

[0][6]=0;grid[0][7]=1;

grid[1][0]=1;grid[1][1]=1;grid[1][2]=1;grid[1][3]=1;grid[1][4]=1;grid[1][5]=1;grid

[1][6]=1;grid[1][7]=1;

grid[2][0]=1;grid[2][1]=0;grid[2][2]=0;grid[2][3]=0;grid[2][4]=1;grid[2][5]=0;grid

[2][6]=0;grid[2][7]=1;

grid[3][0]=1;grid[3][1]=1;grid[3][2]=1;grid[3][3]=0;grid[3][4]=1;grid[3][5]=0;grid

[3][6]=0;grid[3][7]=1;

grid[4][0]=0;grid[4][1]=1;grid[4][2]=0;grid[4][3]=0;grid[4][4]=1;grid[4][5]=1;grid

[4][6]=1;grid[4][7]=1;

grid[5][0]=0;grid[5][1]=1;grid[5][2]=0;grid[5][3]=0;grid[5][4]=0;grid[5][5]=0;grid

[5][6]=0;grid[5][7]=1;

grid[6][0]=0;grid[6][1]=1;grid[6][2]=0;grid[6][3]=9;grid[6][4]=1;grid[6][5]=1;grid

[6][6]=1;grid[6][7]=1;

grid[7][0]=0;grid[7][1]=1;grid[7][2]=1;grid[7][3]=1;grid[7][4]=0;grid[7][5]=0;grid

[7][6]=1;grid[7][7]=0;

for（inti=0;i<8;i++）

{

for（intj=0;j<8;j++）

cout<

cout<

returnisPath（grid,8,8）;

}

intisPath（int**grid,intm,intn）

{

if（grid[0][0]==0）return0;

if（grid[0][0]==9）return1;

intstep=0;

boolflag_down_success=true;

boolflag_up_success=true;

boolflag_left_success=true;

boolflag_right_success=true;

_TraversedNode*p=NULL;

_TraversedNode*p_check=NULL;

_TraversedNode*head=NULL;

_TraversedNode*TraversedNode=new_TraversedNode;

TraversedNode->x=0;

TraversedNode->y=0;

head=TraversedNode;

p=TraversedNode;

p->next=NULL;

intcount_node=0;

intnum_node=1;

_Node*node=new_Node[n+m];

_Node*node_next=new_Node[n+m];

node[0].x=0;

node[0].y=0;

while

（1）

{

for（inti=0;i

{

if（node[i].x+1<=m-1）

{

if（grid[node[i].x+1][node[i].y]!

=0）

{

if（grid[node[i].x+1][node[i].y]==9）

{

step++;

cout<<"可以最短"<

return1;

}

p_check=head;

while（p_check!

=NULL）

{

if（（p_check->x==node[i].x+1）&&（p_check->y==node[i].y））

{

p_check=NULL;

flag_down_success=false;

}

else

{

p_check=p_check->next;

}

}

if（flag_down_success）

{

TraversedNode=new_TraversedNode;

TraversedNode->x=node[i].x+1;

TraversedNode->y=node[i].y;

p->next=TraversedNode;

p=TraversedNode;

p->next=NULL;

node_next[count_node].x=node[i].x+1;

node_next[count_node].y=node[i].y;

count_node++;

}

flag_down_success=true;

}

}

if（node[i].x-1>=0）

{

if（grid[node[i].x-1][node[i].y]!

=0）

{

if（grid[node[i].x-1][node[i].y]==9）

{

step++;

cout<<"可以最短"<

return1;

}

p_check=head;

while（p_check!

=NULL）

{

if（（p_check->x==node[i].x-1）&&（p_check->y==node[i].y））

{

p_check=NULL;

flag_up_success=false;

}

else

{

p_check=p_check->next;

}

}

if（flag_up_success）

{

TraversedNode=new_TraversedNode;

TraversedNode->x=node[i].x-1;

TraversedNode->y=node[i].y;

p->next=TraversedNode;

p=TraversedNode;

p->next=NULL;

node_next[count_node].x=node[i].x-1;

node_next[count_node].y=node[i].y;

count_node++;

}

flag_up_success=true;

}

}

if（node[i].y+1<=n-1）

{

if（grid[node[i].x][node[i].y+1]!

=0）

{

if（grid[node[i].x][node[i].y+1]==9）

{

step++;

cout<<"可以最短"<

return1;

}

p_check=head;

while（p_check!

=NULL）

{

if（（p_check->x==node[i].x）&&（p_check->y==node[i].y+1））

{

p_check=NULL;

flag_right_success=false;

}

else

{

p_check=p_check->next;

}

}

if（flag_right_success）

{

TraversedNode=new_TraversedNode;

TraversedNode->x=node[i].x;

TraversedNode->y=node[i].y+1;

p->next=TraversedNode;

p=TraversedNode;

p->next=NULL;

node_next[count_node].x=node[i].x;

node_next[count_node].y=node[i].y+1;

count_node++;

}

flag_right_success=true;

}

}

if（node[i].y-1>=0）

{

if（grid[node[i].x][node[i].y-1]!

=0）

{

if（grid[node[i].x][node[i].y-1]==9）

{

step++;

cout<<"可以最短"<

return1;

}

p_check=head;

while（p_check!

=NULL）

{

if（（p_check->x==node[i].x）&&（p_check->y==node[i].y-1））

{

p_check=NULL;

flag_left_success=false;

}

else

{

p_check=p_check->next;

}

}

if（flag_left_success）

{

TraversedNode=new_TraversedNode;

TraversedNode->x=node[i].x;

TraversedNode->y=node[i].y-1;

p->next=TraversedNode;

p=TraversedNode;

p->next=NULL;

node_next[count_node].x=node[i].x;

node_next[count_node].y=node[i].y-1;

count_node++;

}

flag_left_success=true;

}

}

}

if（count_node==0）

{

cout<<"不存在到达终点的路径"<

return0;

break;

}

step++;

num_node=count_node;

count_node=0;

for（inti=0;i

{

node[i].x=node_next[i].x;

node[i].y=node_next[i].y;

cout<<"（"<

}

cout<

}

}

7．格雷码

public?

static?

int?

gray（byte?

term1,byte?

term2）{

int?

n=0;

for（int?

i=0;i<8;i++）{

byte?

t1,t2,ch;

ch?

=?

（byte）0x01;

t1=term1&ch;

t2=term2&ch;

if（（t1^t2）==ch）{

n++;

}

term1=（byte）（term1>>1）;

term2=（byte）（term>>1）;

}

if（n==1）

return?

1;

else

return0;

}

8.

#include

usingnamespacestd;

voidmyPrint（intn）

{

if（1==n）

{

cout<<"1*2"<

return;

}

intlastnumber=n*（n+1）;//每一行最后一个数

intfirst=1;//每一行第一个数

intnum=1;

intstep=n;

for（inti=1;i<=n;i++）

{

for（intj=1;j

cout<<'-';

num=first;

for（intl=0;l<（n-i+1）;l++）//每一行的前半部分

{

cout<

num++;

}

num=lastnumber-step+1;

cout<

num++;

for（l=0;l<（n-i）;l++）//每一行的后半部分

{

cout<<"*"<

num++;

}

cout<

//修改first和lastnumber

first=first+step;