数据结构习题参考答案64文档格式.docx
《数据结构习题参考答案64文档格式.docx》由会员分享,可在线阅读,更多相关《数据结构习题参考答案64文档格式.docx(59页珍藏版)》请在冰豆网上搜索。
//插入剩余段
deleteLb;
//释放Lb的头结点}
(2)将两个非递减的有序链表合并为一个非递增的有序链表。
表中允许有重复的数据。
voidunion(LinkList&
La,LinkList&
Lb,LinkList&
Lc,){
pa=La->
pb=Lb->
//初始化
Lc->
next=NULL;
while(pa||pb){
if(!
pa){q=pb;
pb=pb->
elseif(!
pb){q=pa;
pa=pa->
}
elseif(pa->
data<
=pb->
data){q=pa;
else{q=pb;
q->
next=Lc->
next=q;
//插入
(3)已知两个链表A和B分别表示两个集合,其元素递增排列。
请设计算法求出A与B的交集,并存放于A链表中。
voidMix(LinkList&
pa=la->
pb=lb->
∥设工作指针pa和pb;
Lc=pc=La;
//用La的头结点作为Lc的头结点
while(pa&
pb)
data==pb->
data)∥交集并入结果表中。
{pc->
u=pb;
pb=pb->
deleteu;
data){u=pa;
else{u=pb;
while(pa){u=pa;
pa=pa->
}∥释放结点空间
while(pb){u=pb;
}∥释放结点空间
pc->
next=null;
∥置链表尾标记。
deleteLb;
∥注:
本算法中也可对B表不作释放空间的处理
(4)已知两个链表A和B分别表示两个集合,其元素递增排列。
请设计算法求出两个集合A和B的差集(即仅由在A中出现而不在B中出现的元素所构成的集合),并以同样的形式存储,同时返回该集合的元素个数。
voidDifference(LinkedListA,B,*n)
∥A和B均是带头结点的递增有序的单链表,分别存储了一个集合,本算法求两集合的差集,存储于单链表A中,*n是结果集合中元素个数,调用时为0
{p=A->
next;
∥p和q分别是链表A和B的工作指针。
q=B->
pre=A;
∥pre为A中p所指结点的前驱结点的指针。
while(p!
=null&
q!
=null)
if(p->
q->
data){pre=p;
p=p->
*n++;
}∥A链表中当前结点指针后移。
elseif(p->
data)q=q->
∥B链表中当前结点指针后移。
else{pre->
next=p->
∥处理A,B中元素值相同的结点,应删除。
u=p;
p=p->
deleteu;
}∥删除结点
(6)设计一个算法,通过一趟遍历在单链表中确定值最大的结点。
ElemTypeMax(LinkListL){
if(L->
next==NULL)returnNULL;
pmax=L->
//假定第一个结点中数据具有最大值
p=L->
next->
while(p!
=NULL){//如果下一个结点存在
if(p->
data>
pmax->
data)pmax=p;
p=p->
returnpmax->
data;
(7)设计一个算法,通过遍历一趟,将链表中所有结点的链接方向逆转,仍利用原表的存储空间。
voidinverse(LinkList&
L){
//逆置带头结点的单链表L
L->
next=NULL;
while(p){
q=p->
//q指向*p的后继
p->
next=L->
next=p;
//*p插入在头结点之后
p=q;
(8)设计一个算法,删除递增有序链表中值大于mink且小于maxk的所有元素(mink和maxk是给定的两个参数,其值可以和表中的元素相同,也可以不同)。
voiddelete(LinkList&
L,intmink,intmaxk){
//首元结点
while(p&
=mink)
{pre=p;
}//查找第一个值>
mink的结点
if(p){
maxk)p=p->
//查找第一个值≥maxk的结点
q=pre->
pre->
//修改指针
while(q!
=p)
{s=q->
deleteq;
q=s;
}//释放结点空间
}//if
(9)已知p指向双向循环链表中的一个结点,其结点结构为data、prior、next三个域,写出算法change(p),交换p所指向的结点和它的前缀结点的顺序。
知道双向循环链表中的一个结点,与前驱交换涉及到四个结点(p结点,前驱结点,前驱的前驱结点,后继结点)六条链。
voidExchange(LinkedListp)
∥p是双向循环链表中的一个结点,本算法将p所指结点与其前驱结点交换。
{q=p->
llink;
llink->
rlink=p;
∥p的前驱的前驱之后继为p
llink=q->
∥p的前驱指向其前驱的前驱。
rlink=p->
rlink;
∥p的前驱的后继为p的后继。
llink=p;
∥p与其前驱交换
rlink->
llink=q;
∥p的后继的前驱指向原p的前驱
rlink=q;
∥p的后继指向其原来的前驱
}∥算法exchange结束。
(10)已知长度为n的线性表A采用顺序存储结构,请写一时间复杂度为O(n)、空间复杂度为O
(1)的算法,该算法删除线性表中所有值为item的数据元素。
[题目分析]在顺序存储的线性表上删除元素,通常要涉及到一系列元素的移动(删第i个元素,第i+1至第n个元素要依次前移)。
本题要求删除线性表中所有值为item的数据元素,并未要求元素间的相对位置不变。
因此可以考虑设头尾两个指针(i=1,j=n),从两端向中间移动,凡遇到值item的数据元素时,直接将右端元素左移至值为item的数据元素位置。
voidDelete(ElemTypeA[],intn)
∥A是有n个元素的一维数组,本算法删除A中所有值为item的元素。
{i=1;
j=n;
∥设置数组低、高端指针(下标)。
while(i<
j)
{while(i<
j&
A[i]!
=item)i++;
∥若值不为item,左移指针。
if(i<
j)while(i<
A[j]==item)j--;
∥若右端元素值为item,指针左移
j)A[i++]=A[j--];
[算法讨论]因元素只扫描一趟,算法时间复杂度为O(n)。
删除元素未使用其它辅助空间,最后线性表中的元素个数是j。
第3章栈和队列
CCDAADABCDDDBCB
2.算法设计题(答案仅做参考)
(2)回文是指正读反读均相同的字符序列,如“abba”和“abdba”均是回文,但“good”不是回文。
试写一个算法判定给定的字符向量是否为回文。
(提示:
将一半字符入栈)
根据提示,算法可设计为:
//以下为顺序栈的存储结构定义
#defineStackSize100//假定预分配的栈空间最多为100个元素
typedefcharDataType;
//假定栈元素的数据类型为字符
typedefstruct{
DataTypedata[StackSize];
inttop;
}SeqStack;
intIsHuiwen(char*t)
{//判断t字符向量是否为回文,若是,返回1,否则返回0
SeqStacks;
inti,len;
chartemp;
InitStack(&
s);
len=strlen(t);
//求向量长度
for(i=0;
i<
len/2;
i++)//将一半字符入栈
Push(&
s,t[i]);
while(!
EmptyStack(&
s))
{//每弹出一个字符与相应字符比较
temp=Pop(&
if(temp!
=S[i])
return0;
//不等则返回0
elsei++;
}
return1;
//比较完毕均相等则返回1
}
(3)设从键盘输入一整数的序列:
a1,a2,a3,…,an,试编写算法实现:
用栈结构存储输入的整数,当ai≠-1时,将ai进栈;
当ai=-1时,输出栈顶整数并出栈。
算法应对异常情况(入栈满等)给出相应的信息。
#definemaxsize栈空间容量
voidInOutS(ints[maxsize])
//s是元素为整数的栈,本算法进行入栈和退栈操作。
{inttop=0;
//top为栈顶指针,定义top=0时为栈空。
for(i=1;
=n;
i++)//n个整数序列作处理。
{scanf(“%d”,&
x);
//从键盘读入整数序列。
if(x!
=-1)//读入的整数不等于-1时入栈。
if(top==maxsize-1){printf(“栈满\n”);
exit(0);
}elses[++top]=x;
//x入栈。
else//读入的整数等于-1时退栈。
{if(top==0){printf(“栈空\n”);
}elseprintf(“出栈元素是%d\n”,s[top--]);
}}
}//算法结束。
(4)从键盘上输入一个后缀表达式,试编写算法计算表达式的值。
规定:
逆波兰表达式的长度不超过一行,以$符作为输入结束,操作数之间用空格分隔,操作符只可能有+、-、*、/四种运算。
例如:
23434+2*$。
[题目分析]逆波兰表达式(即后缀表达式)求值规则如下:
设立运算数栈OPND,对表达式从左到右扫描(读入),当表达式中扫描到数时,压入OPND栈。
当扫描到运算符时,从OPND退出两个数,进行相应运算,结果再压入OPND栈。
这个过程一直进行到读出表达式结束符$,这时OPND栈中只有一个数,就是结果。
floatexpr()
//从键盘输入逆波兰表达式,以‘$’表示输入结束,本算法求逆波兰式表达式的值。
{floatOPND[30];
//OPND是操作数栈。
init(OPND);
//两栈初始化。
floatnum=0.0;
//数字初始化。
scanf(“%c”,&
//x是字符型变量。
while(x!
=’$’)
{switch
{case‘0’<
=x<
=’9’:
while((x>
=’0’&
x<
=’9’)||x==’.’)//拼数
=’.’)//处理整数
{num=num*10+(ord(x)-ord(‘0’));
scanf(“%c”,&
else//处理小数部分。
{scale=10.0;
while(x>
=’9’)
{num=num+(ord(x)-ord(‘0’)/scale;
scale=scale*10;
}//else
push(OPND,num);
num=0.0;
//数压入栈,下个数初始化
casex=‘’:
break;
//遇空格,继续读下一个字符。
casex=‘+’:
push(OPND,pop(OPND)+pop(OPND));
casex=‘-’:
x1=pop(OPND);
x2=pop(OPND);
push(OPND,x2-x1);
casex=‘*’:
push(OPND,pop(OPND)*pop(OPND));
casex=‘/’:
push(OPND,x2/x1);
default:
//其它符号不作处理。
}//结束switch
//读入表达式中下一个字符。
}//结束while(x!
=‘$’)
printf(“后缀表达式的值为%f”,pop(OPND));
}//算法结束。
[算法讨论]假设输入的后缀表达式是正确的,未作错误检查。
算法中拼数部分是核心。
若遇到大于等于‘0’且小于等于‘9’的字符,认为是数。
这种字符的序号减去字符‘0’的序号得出数。
对于整数,每读入一个数字字符,前面得到的部分数要乘上10再加新读入的数得到新的部分数。
当读到小数点,认为数的整数部分已完,要接着处理小数部分。
小数部分的数要除以10(或10的幂数)变成十分位,百分位,千分位数等等,与前面部分数相加。
在拼数过程中,若遇非数字字符,表示数已拼完,将数压入栈中,并且将变量num恢复为0,准备下一个数。
这时对新读入的字符进入‘+’、‘-’、‘*’、‘/’及空格的判断,因此在结束处理数字字符的case后,不能加入break语句。
(5)假设以I和O分别表示入栈和出栈操作。
栈的初态和终态均为空,入栈和出栈的操作序列可表示为仅由I和O组成的序列,称可以操作的序列为合法序列,否则称为非法序列。
下面所示的序列中哪些是合法的?
A.IOIIOIOOB.IOOIOIIOC.IIIOIOIOD.IIIOOIOO
通过对
的分析,写出一个算法,判定所给的操作序列是否合法。
若合法,返回true,否则返回false(假定被判定的操作序列已存入一维数组中)。
A和D是合法序列,B和C是非法序列。
设被判定的操作序列已存入一维数组A中。
intJudge(charA[])
//判断字符数组A中的输入输出序列是否是合法序列。
如是,返回true,否则返回false。
{i=0;
//i为下标。
j=k=0;
//j和k分别为I和字母O的的个数。
while(A[i]!
=‘\0’)//当未到字符数组尾就作。
{switch(A[i])
{case‘I’:
j++;
break;
//入栈次数增1。
case‘O’:
k++;
if(k>
j){printf(“序列非法\n”);
i++;
//不论A[i]是‘I’或‘O’,指针i均后移。
if(j!
=k){printf(“序列非法\n”);
return(false);
else{printf(“序列合法\n”);
return(true);
[算法讨论]在入栈出栈序列(即由‘I’和‘O’组成的字符串)的任一位置,入栈次数(‘I’的个数)都必须大于等于出栈次数(即‘O’的个数),否则视作非法序列,立即给出信息,退出算法。
整个序列(即读到字符数组中字符串的结束标记‘\0’),入栈次数必须等于出栈次数(题目中要求栈的初态和终态都为空),否则视为非法序列。
(6)假设以带头结点的循环链表表示队列,并且只设一个指针指向队尾元素站点(注意不设头指针),试编写相应的置空队、判队空、入队和出队等算法。
算法如下:
//先定义链队结构:
typedefstructqueuenode{
Datatypedata;
structqueuenode*next;
}QueueNode;
//以上是结点类型的定义
queuenode*rear;
}LinkQueue;
//只设一个指向队尾元素的指针
(1)置空队
voidInitQueue(LinkQueue*Q)
{//置空队:
就是使头结点成为队尾元素
QueueNode*s;
Q->
rear=Q->
rear->
//将队尾指针指向头结点
while(Q->
rear!
=Q->
next)//当队列非空,将队中元素逐个出队
{s=Q->
Q->
next=s->
free(s);
}//回收结点空间
}
(2)判队空
intEmptyQueue(LinkQueue*Q)
{//判队空
//当头结点的next指针指向自己时为空队
returnQ->
next==Q->
(3)入队
voidEnQueue(LinkQueue*Q,Datatypex)
{//入队
//也就是在尾结点处插入元素
QueueNode*p=(QueueNode*)malloc(sizeof(QueueNode));
//申请新结点
p->
data=x;
next=Q->
//初始化新结点并链入
Q-rear->
rear=p;
//将尾指针移至新结点
(4)出队
DatatypeDeQueue(LinkQueue*Q)
{//出队,把头结点之后的元素摘下
Datatypet;
QueueNode*p;
if(EmptyQueue(Q))
Error("
Queueunderflow"
);
p=Q->
//p指向将要摘下的结点
x=p->
//保存结点中数据
if(p==Q->
rear)
{//当队列中只有一个结点时,p结点出队后,要将队尾指针指向头结点
Q->
else
//摘下结点p
free(p);
//释放被删结点
returnx;
(7)假设以数组Q[m]存放循环队列中的元素,同时设置一个标志tag,以tag==0和tag==1来区别在队头指针(front)和队尾指针(rear)相等时,队列状态为“空”还是“满”。
试编写与此结构相应的插入(enqueue)和删除(dlqueue)算法。
【解答】
循环队列类定义
#include<
assert.h>
template<
classType>
classQueue{//循环队列的类定义
public:
Queue(int=10);
~Queue(){delete[]Q;
voidEnQueue(Type&
item);
TypeDeQueue();
TypeGetFront();
voidMakeEmpty(){front=rear=tag=0;
}//置空队列
intIsEmpty()const{returnfront==rear&
tag==0;
}//判队列空否
intIsFull()const{returnfront==rear&
tag==1;
}//判队列满否
private:
intrear,front,tag;
//队尾指针、队头指针和队满标志
Type*Q;
//存放队列元素的数组
intm;
//队列最大可容纳元素个数
}
构造函数
Queue<
Type>
:
Queue(intsz):
rear(0),front(0),tag(0),m(sz){
//建立一个最大具有m个元素的空队列。
Q=newType[m];
//创建队列空间
assert(Q!
=0);
//断言:
动态存储分配成功与否
插入函数
template<
voidQueue<
:
EnQueue(Type&
item){
assert(!
IsFull());