历年链表考题与答案.docx

历年链表考题与答案.docx

《历年链表考题与答案.docx》由会员分享，可在线阅读，更多相关《历年链表考题与答案.docx（47页珍藏版）》请在冰豆网上搜索。

历年链表考题与答案

历年链表考题及答案

[2005秋II.14]设已建立了两条单向链表，这两链表中的数据已按从小到大的次序排好，指针h1和h2分别指向这两条链表的首结点。

链表上结点的数据结构如下：

structnode{

intdata;

node*next;

};

以下函数node*Merge（node*h1,node*h2）的功能是将h1和h2指向的两条链表上的结

点合并为一条链表，使得合并后的新链表上的数据仍然按升序排列，并返回新链表的首结点

指针。

算法提示：

首先，使newHead和q都指向首结点数据较小链表的首结点，p指向另一链

表首结点。

其次，合并p和q所指向的两条链表。

在q不是指向链尾结点的情况下，如果q

的下一个结点数据小于p指向的结点数据，则q指向下一个结点；否则使p1指向q的下一

个结点，将p指向的链表接到q所指向的结点之后，使q指向p所指向的结点，使p指向

p1所指向的链表。

直到p和q所指向的两条链表合并结束为止。

注意，在合并链表的过程

中，始终只有两条链表。

[函数]

（4分）

node*Merge（node*h1,node*h2）

{node*newHead,*p,*p1;

//使newHead和q指向首结点数据较小链表的首结点，

if（（27））{newHead=h1;p=h2;}

else{newHead=h2;p=h1;}

p指向另一链表首结点

//h1->datadata

node*q=newHead;

//合并两条链表

while（q->next）

{if（q->next->datadata）

（28）;//q=q->next

else

{（29）;//p1=q->next

q->next=p;

q=p;

p=p1;

}

}

q->next=p;

（30）;//returnnewNead

}

[2005春II.11]设已建立一条单向链表，指针head指向该链表的首结点。

结点的数据结构如下：

structNode{

intdata;

Node*next;

};

以下函数sort（Node*head）的功能是：

将head所指向链表上各结点的数据按data值从小

到大的顺序排序。

算法提示：

初始时，使p指向链表的首结点，从p之后的所有结点中找出data值最小

的结点，让p1指向该结点。

将p指向的结点的data值与p1指向的结点的data值进行交换。

让p指向下一个结点，依此类推，直至p指向链表的最后一个结点为止。

[程序]

（4分）

Node*sort（Node*head）

{Node*p=head,*p1,*p2;if（p==NULL）returnhead;while（p->next!

=NULL）

{p1=p;p2=p->next;while（p2!

=NULL）

{if（）//p2->datadata

p1=p2;

p2=p2->next;

}

if（p!

=p1）

{

intt;

t=p->data;

p->data=

;

//p1->data

=t;

//p1->data

}

;

//p=p->next

}

returnhead;

}

[2004秋II.11]已建立一条无序链表，head指向链首。

链表上结点的数据结构为：

structNode

{doublenum;Node*next;

};

以下函数sort（Node*head）的功能为：

将参数head所指向链表上的各个结点，按num值

的升序排序，并返回排序后链表的链首指针。

算法提示：

先让h指向空链，依次从head所指向的链表上取下一个结点，然后将取下的结点插入到已排序的h所指向的链表上。

Node*sort（Node*head）

{if（head==0）returnhead;

Node*h,*p;

h=0;

while（head）

{p=head;

（27）;//（27）head=head->next或head=p->next

Node*p1,*p2;

if（h==0）

{h=p;

（28）

;

//（28）p->next=0或h->next=0

}

elseif（

（29）

）

//（29）h->num>=p->num或p->num<=h->num

{p->next=h;h=p;

}

else

{p2=p1=h;

while（p2->next&&p2->numnum）

{p1=p2;p2=p2->next;

}

if（

（30）

）

//（30）p2->numnum或p->num>p2->num

{p2->next=p;p->next=0;

}

else

{p->next=p2;

p1->next=p;

}

}

}

return（h）;

}

[2004春II.11]输入一行字符串，用单向链表统计该字符串中每个字符出现的次数。

方法是：

对该字符串中的每个字符，

依次查找链表上的结点。

若链表结点上有该字符，

则将该结点的

count值加1；否则产生一个新结点，存放该字符，置

count为1，并将该结点插入链首。

最

后，输出链表上的每个结点的字符及出现次数。

链表的结构如下图所示。

head

⋯

c

c

c

c

count

count

count

count

next

next

next

next

#include

structnode

{charc;intcount;

node*next;

};

voidprint（node*head）

{while（head）

{cout<<"字符:

"<c<<"\t出现"<count<<"次\n";

head=head->next;

}

}

voiddele（node*head）

{node*p;while（head!

=NULL）{p=head;

head=（27）;//（27）head->next

deletep;

}

}

node*search（node*head,charch）

{node*p;p=head;

while（p）

{if（p->c==ch）

{p->count++;break;}

（28）;//（28）p=p->next

}

if（p==0）

{

p=newnode;

p->c=ch;

p->count=1;

if（head）

（29）

;

//（29）p->next=head

elsep->next=0;

（30）

;

//（30）head=p

}

returnhead;

}

voidmain（void）

{chars[300],*p=s;node*h=0;

charc;

cout<<"请输入一行字符串：

";

cin.getline（s,300）;

while（c=*p++）h=search（h,c）;

print（h）;dele（h）;

}

[2003秋II.12]

用链表实现对候选人的得票进行统计。

函数Statistic的输入参数：

head指向链

首，name存放候选人的姓名。

该函数的功能为：

若在链表的结点上找到

name，则将姓名为

name的结点上得得票数加

1；否则新建一个结点，初始化其姓名和的票数，并将新结点插

入链尾。

最后返回链表的首指针。

链表的结构如下图所示。

head

name

name

name

⋯

name

count

count

count

count

next

next

next

next

#include

#include

structNode

{charname[12];

intcount;

Node*next;

//候选人姓名

//计数候选人的得票

};

{Node*p1=head,*p2;

if（head==0）//空表，插入第1个结点

{head=newNode;strcpy（head->name,name）;

head->count=1;

head->next=0;

}

else

//不是空表，进行结点数值查找

{while（p1）

{if（（27））//找到了//strcmp（p1->name,name）==0

{p1->count++;

break;

}

else//不是待查结点，移动指针，准备下一结点查找

{p2=p1;

（28）;//p1=p1->next

}

}

if（

{

（29））//待查结点不存在

p1=newNode;//在尾部插入新结点

strcpy（p1->name,name）;

p1->count=1;

p1->next=0;

（30）;//p2->next=p1

//p1==NULL

}

}

returnhead;

}

voidList（Node*head）//输出结果

{while（head）

{cout<name<<":

\t"<count<next;

}

}

voidFree（Node*head）//释放链表空间

{Node*p;

while（head）

{p=head;head=head->next;deletep;

}

}

voidmain（）//连续输入得票候选人的姓名，以输入"0"结束

{Node*head=0;charname[12];

cout<<"输入得票候选人的姓名:

";cin>>name;

while（strcmp（name,"0"）!

=0）

{head=Statistic（head,name）;cout<<"输入得票候选人的姓名:

";

cin>>name;

}

cout<<"统计得票结果:

\n姓名得票数\n";

List（head）;

Free（head）;

}

[2003春II.14]以下程序使用递归函数实现单向链表操作，完成链表的创建、显示、释放链

表的结点。

#include

structnode

{floatdata;node*next;

};

voidShowChain（node*head）//依次输出每一个结点上的数据

{if（head）

{cout<data<

if（head->next）ShowChain（_____________）;

//head->next

}

}

voidAddNode（node*p,node*&head）

{if（head==NULL）head=___________;

//将

p所指向的结点插入链尾

//p

elseAddNode（p,head->next）;

}

voidDeleteChain（node*head）//依次删除链表上的每一个结点

{node*p=head;

if（p）

{head=____________;//head->next

deletep;

if（head）DeleteChain（head）;

}

}

voidmain（void）

{node*head=NULL,*temp;temp=newnode;while

（2）

{temp->next=NULL;cout<<"输入数据：

";

cin>>temp->data;

if（temp->data>0）AddNode（temp,head）;//

新结点加入链表尾部

else

{

deletetemp;break;}

temp=________________;

//newnode

}

ShowChain（head）;

DeleteChain（head）;

}

[2002秋II.14]n个人围成一圈，他们的序号依次为

1到n，从第一个人开始顺序报数

1、2、

3、⋯、m，报到m者退出圈子，并输出退出圈子的人的序号。

接着再顺序报数，直到圈子

中留下一个人为止。

用一个有

n个结点的环形链表模拟围成一圈的人。

假定有10

个人围成

一圈，凡报到

5者退出圈子，则退出圈子人的序号依次为

5、10、6、2、9、8、1、4、7，

最后留在圈中的人是3号。

单向环形链表的结构如下图所示。

其中

head指向第一个人。

head

1

2

3

⋯⋯

10

#include

structNode{

intx;//围成一圈时，人的序号

Node*next;

};

Node*DelNode（Node*head,intm）//依次输出环形链表中凡报到m者的序号

{Node*p;intcount;

if（head==NULL）return_____________;//head

while（head!

=head->next）//直到链表上只有一个结点为止

{count=0;

while（count

{count++;head=head->next;}

p=head->next;//删除p所指向的结点

head->next=_______________;//p->next

head=head->next;

cout<x<

deletep;

}

returnhead;

}

voidmain（void）

//在主函数中，构造环形链表，调用

DelNode

函数依次输出报到

m的人的序号

{

Node*head,*p;

//最后输出留在圈中最后的人的序号

inti;

head=newNode;

head->x=1;

head->next=NULL;

p=head;

for（i=2;i<=10;i++）

{p->next=newNode;p=_______________;

//新结点加入链尾

//p->next

p->x=i;

}

p->next=_________________;

//构成循环链

//head

head=DelNode（head,5）;

cout<<"最后的一个人为：

"<x<

}

[2002春II.14]设链表上结点的数据结构定义如下：

structNODE{

intx;

NODE*next;

};

函数create（）的功能为：

创建一个有序的链表（结点中x的值按升序排序），参数n为链表上要产生的结点的个数，函数返回该有序链表的头指针。

算法思想：

每产生一个新的结点，插入到链表的恰当位置，使得插入新结点以后的链表仍然保持有序。

_____________creat（intn）//NODE*或structNODE*

{NODE*p,*p1,*p2,*h=NULL;

inti=0;

if（n<1）returnNULL;

while（____________）//i

{p=newNODE;

cin>>p->x;p->next=NULL;

if（_________________）h=p;

else

{p1=p2=h;

//h==NULL

或

!

h

while（p2&&_____________）

//（p->x）>=（p2->x）

{p1=p2;p2=p2->next;

}

if（p2==h）{p->next=p2;h=p;}

else{p->next=p2;p1->next=p;}

}

i++;

}

returnh;

}

[2001秋II.14]设链表上结点的数据结构定义如下：

structPNODE

{intx;

PNODE*next;

};

设已建立了一条链表，h为链首指针。

函数DelAdd的功能为：

若链表上能找到结点的

x值为value，则从链表上删除该结点（假定链表上各个结点的值是不同的）；否则构造一个

新结点，其x的值为value，并将新结点插入链尾。

该函数返回新链表的首指针。

[程序]（4分）

PNODE*DelAdd（PNODE*h,intvalue）

{PNODE*p1,*p2;

intflag=0;

//

值为1

时，表示已删除值为

value的结点

p1=h;

while（p1&&flag==0）

{

if（p1->x==value）

{

flag=1;

if（p1==h）

{

h=

（27）

;deletep1;}

//p1->next

else

{

p2->next=

（28）

;deletep1;}

//p1->next

}

else

{

p2=p1;

p1=

（29）

;}

//p1->next

}

if（flag==0）

{p1=newPNODE;p1->x=value;

p1->next=0;

if（h==0）h==p1;

else（30）

;

//p2->next=p1

}

returnh;

}

[2001春II.13]下面程序中，函数padd的功能为调整pa指向的链表中结点的位置，使得所

有x值为偶数的结点出现在链表的前半部，所有x值为奇数的结点出现在链表的后半部。

本程序的输出为：

10,8,6,4,2,1,3,5,7,9。

如

#include

structNODE

{intx;

NODE*next;

};

NODE*padd（NODE*pa）

{NODE*p1,*p2,*p;p1=p2=pa;

while（p1）

{if（p1->x%2==0&&_________________）//p1!

=pa第1个结点为偶数时不取

{p=p1;p1=p1->next;

________________=p1;//从链表上取下偶数结点并插入链首//p2->next

p->next=pa;__________________;//pa=p

}

else{p2=p1;p1=p1->next;}

}

returnpa;

}

voidmain（void）

{NODEa[10]={{1},{2},{3},{4},{5},{6},{7},{8},{9},{10}},*ha=a,*p;inti;

for（i=0;i<9;i++）a[i].next=______________;//拉成链表

a[9].next=NULL;

ha=padd（ha）;

p=ha;

while（p）

{cout<x<<’,’p=p;->next;}

//&a[i+1]

cout<<’n’;

}

*[2000秋II.11]设结点的数据结构定义如下：

structPNODE

{

intx,y;

PNODE*next;

};

函数

新链表（pc

padd的功能为：

根据pa，pb指向的两个链表（按结点的y值升序排列）生成一个

为链首指针）。

新生成链表仍按y值升序排列。

生成新链表的规则为：

当在pa和

pb链表中发现y值相同的结点时，则在pc表中对应的两个结点的x值之和，新结点的

链表中增加一个新结点，新结点的x

y取值为pa或pb链表中对应结点的

取值为两链

y值。

PNODE*padd（PNODE*pa,PNODE*pb）

{PNODE*pcr,*pt,*pc=0;

while（（27））//pa&&pb

{if（pa->y==pb->y）

{pt=new（28）;//PNODE

pt->x=pa->x+pb->x;pt->y=pa->y;pt->next=NULL;

if（pc==NULL）pc=pcr=pt;

else

{pcr->next=pt;（29）;}//pcr=pt;

pa=pa->next;pb=pb->next;

}

else

if（（30））pb=pb->ne