历年链表考题及答案Word格式.docx
《历年链表考题及答案Word格式.docx》由会员分享，可在线阅读，更多相关《历年链表考题及答案Word格式.docx（22页珍藏版）》请在冰豆网上搜索。
//returnnewNead
[2005春II.11]设已建立一条单向链表，指针head指向该链表的首结点。
结点的数据结构如
下：
structNode{
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!
{if（）//p2->
p1->
p1=p2;
p2=p2->
if（p!
=p1）
{intt;
t=p->
data;
data=;
//p1->
=t;
;
//p=p->
returnhead;
[2004秋II.11]已建立一条无序链表，head指向链首。
链表上结点的数据结构为：
structNode
{doublenum;
以下函数sort（Node*head）的功能为：
将参数head所指向链表上的各个结点，按num值
的升序排序，并返回排序后链表的链首指针。
先让h指向空链，依次从head所指向的链表上取下一个结点，然后将取下
的结点插入到已排序的h所指向的链表上。
{if（head==0）returnhead;
Node*h,*p;
h=0;
while（head）
{p=head;
（27）;
//（27）head=head->
next或head=p->
Node*p1,*p2;
if（h==0）
{h=p;
//（28）p->
next=0或h->
next=0
elseif（（29））//（29）h->
num>
=p->
num或p->
num<
=h->
num
{p->
next=h;
h=p;
{p2=p1=h;
while（p2->
next&
&
p2->
num）
{p1=p2;
if（（30））//（30）p2->
{p2->
next=0;
next=p2;
return（h）;
[2004春II.11]输入一行字符串，用单向链表统计该字符串中每个字符出现的次数。
方法是：
对该字符串中的每个字符，依次查找链表上的结点。
若链表结点上有该字符，则将该结点的
count值加1；
否则产生一个新结点，存放该字符，置count为1，并将该结点插入链首。
最
后，输出链表上的每个结点的字符及出现次数。
链表的结构如下图所示。
⋯
head
cccc
countcountcountcount
nextnextnextnext
#include<
iostream.h>
structnode
{charc;
intcount;
voidprint（node*head）
{while（head）
{cout<
<
"
字符:
head->
c<
\t出现"
count<
次\n"
head=head->
voiddele（node*head）
{node*p;
while（head!
head=（27）;
//（27）head->
deletep;
node*search（node*head,charch）
p=head;
while（p）
{if（p->
c==ch）
count++;
break;
//（28）p=p->
if（p==0）
{p=newnode;
c=ch;
count=1;
if（head）（29）;
//（29）p->
next=head
elsep->
//（30）head=p
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
namenamenamename
string.h>
{charname[12];
//候选人姓名
//计数候选人的得票
Node*Statistic（Node*head,char*name）
{Node*p1=head,*p2;
if（head==0）//空表，插入第1个结点
{head=newNode;
strcpy（head->
name,name）;
else//不是空表，进行结点数值查找
{while（p1）
{if（（27））//找到了//strcmp（p1->
name,name）==0
{p1->
else//不是待查结点，移动指针，准备下一结点查找
{p2=p1;
//p1=p1->
if（（29））//待查结点不存在//p1==NULL
{p1=newNode;
//在尾部插入新结点
strcpy（p1->
//p2->
next=p1
voidList（Node*head）//输出结果
name<
:
\t"
endl;
voidFree（Node*head）//释放链表空间
{Node*p;
voidmain（）//连续输入得票候选人的姓名，以输入"
0"
结束
{Node*head=0;
charname[12];
输入得票候选人的姓名:
cin>
>
name;
while（strcmp（name,"
）!
=0）
{head=Statistic（head,name）;
统计得票结果:
\n姓名得票数\n"
List（head）;
Free（head）;
[2003春II.14]以下程序使用递归函数实现单向链表操作，完成链表的创建、显示、释放链
表的结点。
{floatdata;
voidShowChain（node*head）//依次输出每一个结点上的数据
{if（head）
if（head->
next）ShowChain（_____________）;
//head->
voidAddNode（node*p,node*&
head）//将p所指向的结点插入链尾
{if（head==NULL）head=___________;
//p
elseAddNode（p,head->
next）;
voidDeleteChain（node*head）//依次删除链表上的每一个结点
{node*p=head;
if（p）
{head=____________;
if（head）DeleteChain（head）;
{node*head=NULL,*temp;
temp=newnode;
while
（2）
{temp->
next=NULL;
输入数据：
temp->
if（temp->
data>
0）AddNode（temp,head）;
//新结点加入链表尾部
{deletetemp;
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指向第一个人。
⋯⋯
head12310
intx;
//围成一圈时，人的序号
Node*DelNode（Node*head,intm）//依次输出环形链表中凡报到m者的序号
if（head==NULL）return_____________;
//head
=head->
next）//直到链表上只有一个结点为止
{count=0;
while（count<
m-2）
{count++;
p=head->
//删除p所指向的结点
next=_______________;
//p->
x<
//在主函数中，构造环形链表，调用DelNode函数依次输出报到m的人的序号
{Node*head,*p;
//最后输出留在圈中最后的人的序号
inti;
head=newNode;
x=1;
for（i=2;
i<
=10;
i++）
next=newNode;
//新结点加入链尾
p=_______________;
x=i;
next=_________________;
//构成循环链//head
head=DelNode（head,5）;
最后的一个人为：
[2002春II.14]设链表上结点的数据结构定义如下：
structNODE{
NODE*next;
函数create（）的功能为：
创建一个有序的链表（结点中x的值按升序排序），参数n为链
表上要产生的结点的个数，函数返回该有序链表的头指针。
算法思想：
每产生一个新的结点，
插入到链表的恰当位置，使得插入新结点以后的链表仍然保持有序。
_____________creat（intn）//NODE*或structNODE*
{NODE*p,*p1,*p2,*h=NULL;
inti=0;
if（n<
1）returnNULL;
while（____________）//i<
n
{p=newNODE;
x;
if（_________________）h=p;
//h==NULL或!
h
{p1=p2=h;
while（p2&
_____________）//（p->
x）>
=（p2->
x）
if（p2==h）{p->
else{p->
i++;
returnh;
[2001秋II.14]设链表上结点的数据结构定义如下：
structPNODE
{intx;
PNODE*next;
设已建立了一条链表，h为链首指针。
函数DelAdd的功能为：
若链表上能找到结点的
x值为value，则从链表上删除该结点（假定链表上各个结点的值是不同的）；
否则构造一个
新结点，其x的值为value，并将新结点插入链尾。
该函数返回新链表的首指针。
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=（28）;
p1=（29）;
if（flag==0）
{p1=newPNODE;
x=value;
if（h==0）h==p1;
else（30）;
[2001春II.13]下面程序中，函数padd的功能为调整pa指向的链表中结点的位置，使得所
有x值为偶数的结点出现在链表的前半部，所有x值为奇数的结点出现在链表的后半部。
如
本程序的输出为：
10,8,6,4,2,1,3,5,7,9。
structNODE
NODE*padd（NODE*pa）
{NODE*p1,*p2,*p;
p1=p2=pa;
while（p1）
x%2==0&
_________________）//p1!
=pa第1个结点为偶数时不取
{p=p1;
p1=p1->
________________=p1;
//从链表上取下偶数结点并插入链首//p2->
next=pa;
__________________;
//pa=p
else{p2=p1;
returnpa;
{NODEa[10]={{1},{2},{3},{4},{5},{6},{7},{8},{9},{10}},*ha=a,*p;
for（i=0;
9;
i++）a[i].next=______________;
//拉成链表//&
a[i+1]
a[9].next=NULL;
ha=padd（ha）;
p=ha;
’,’p;
’n’;
*[2000秋II.11]设结点的数据结构定义如下：
{intx,y;
函数padd的功能为：
根据pa，pb指向的两个链表（按结点的y值升序排列）生成一个
新链表（pc为链首指针）。
新生成链表仍按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->
y=pa->
y;
if（pc==NULL）pc=pcr=pt;
{pcr->
next=pt;
（29）;
}//pcr=pt;
pa=pa->
pb=pb->
if（（30））pb=pb->
//pa->
y>
pb->
y
elsepa=pa->
returnpc;
[05级试卷A]学生的记录由学号和成绩组成，设若干名学生的数据已在主函数中存放到链表
中。
下列函数fun的功能是：
用链表中高于或等于平均分的学生数据构成一个由头指针h所
指向的新链表，建立新链表时每次都将新生成的结点插入到头结点的前面。
形参head是链
表头指针，平均分通过形参aver带回，函数返回新链表的头指针h。
structstudent{
charno[10];
//学号
floatgrade;
//成绩
student*next;
student*fun（student*head,float&
aver）
{student*h,*p,*p1;
floatsum=0;
intn=0;
aver=0;
while（p!
=NULL）//求成绩和
{sum=;
//sum+p->
grade;
n++;
p=p->
aver=sum/n;
h=NULL;
=NULL）//用高于或等于平均分的学生数据构成一个新的链表
{if（）//p->
grade>
=aver
{p1=newstudent;
//strcpy（p1->
no,p->
no）;
grade=p->
h=p1;
[05级试卷B]以下用面向对象的方法实现一个单向链表，主要实现在链表尾追加一个结点
的功能。
ListNodeNodeNodehead
datadatadata
nextnextNULL
要求：
（1）定义一个结点类Node，结构如上图所示。
data是一个整型数据。
（2）定义一个链表类List作为Node类的友元类，其私有数据成员Node*head为指向链
表首结点的指针。
各成员函数的功能见程序中的注释，请完善程序。
classNode
{
public:
Node（intd=0）//构造函数
{data=d;
________________________________;
//将List类说明成本类的友元类
//friendclassList;
classList
Node*head;
List（）//缺省构造函数，建立一个空链表
_____________________________;
//head=NULL;
List（intd）;
//构造一个第1个结点数据值为d的结点
voidappend（intd=0）;
//追加一个数据值为d的结点到链表尾部
voidprint（）;
//输出链表各结点值
~List（）;
//析构函数，释放链表各结点空间
List:
List（intd）//构造一个第1个结点数据值为d的结点
{head=newNode（d）;
voidList:
append（intd）//追加一个数据值为d的结点到链表尾部
if（head==NULL）
Node*p=head;
while（_________________）//循环结束后，p指向链表最后一个结点
=NULL
next=newNode（d）;
print（）//输出链表各结点值
升级会员 