2023年数据结构实验报告级及答案

《数据结构》实验报告

专业—信息管理学院

年级__2023级

学号—

学生姓名_____

指导老师______________

华中师范大学信息管理系编

I实验规定

1.每次实验中有若干习题，每个学生至少应当完毕其中的两道习题。

2.上机之前应作好充足的准备工作，预先编好程序，通过人工检查无误后，才干上机，以提高上机效率。

3.独立上机输入和调试自己所编的程序，切忌抄袭、拷贝别人程序。

4.上机结束后，应整理出实验报告。书写实验报告时，重点放在调试过程和小节部分，总结出本次实

验中的得与失，以达成巩固课堂学习、提高动手能力的目的。

II实验内容

实验一线性表

【实验目的】

I.熟悉VC环境,学习如何使用C语言实现线性表的两种存储结构。

2.通过编程、上机调试，进一步理解线性表的基本概念，纯熟运用C语言实现线性表基本操作。

3.纯熟掌握线性表的综合应用问题。

【实验内容】

1.一个线性表有n个元素（n<MAXSIZE,MAXSIZE指线性表的最大长度），且递增有。现有一元素x

要插入到线性表的适当位置上，并保持线性表原有的顺序不变。设计程序实现。规定：采用顺序存储表达实

现;采用链式存储表达方法实现；比较两种方法的优劣。

2.从单链表中删除指定的元素x,若x在单链表中不存在，给出提醒信息。

规定：

①指定的值x由键盘输入；

②程序能解决空链表的情况。

3.设有头结点的单链表，编程对表中的任意值只保存一个结点，删除其余值相同的结点。

规定：

①该算法用函数（非主函数）实现；

②在主函数中调用创建链表的函数创建一个单链表，并调用该函数，验证算法的对的性。

LinkedListExchange(LinkedListHEAD,p)

〃HEAD是单链表头结点的指针，p是链表中的一个结点。本算法将p所指结点与其后

继结点互换。

{q=head—>next;〃q是工作指针，指向链表中当前待解决结点。

pre=head：〃Pre是前驱结点指针，指向q的前驱。

while(q!=nu1I&&q!=p){pre=q;q=q->next；}〃未找到p结点，后移指针。

if(p—>next==nu11)printf("p无后继结点\n");〃p是链表中最后一个结点，无后继。

else〃解决p和后继结点互换

{q=p->next；〃暂存p的后继。

Pre->next=q;〃p前驱结点的后继指向p的后继。

P->next=q->next；//p的后继指向原p后继的后继。

q->next=p；〃原p后继的后继指针指向p。)

}〃算法结束。

4.己知非空单链表第一个结点由head指出,请写一算法，互换p所指结点与其下一个结点在链表中

的位置。

规定：

①该算法用函数Reverse(head,p)实现，其中head为表头指针,p指向要互换的结点；

②在主函数中调用创建链表的函数创建一个单链表，并调用该函数，验证算法的对的性。

5.设有一个单链表，编写可以完毕下列功能的算法：

①找出最小值的结点，且打印该数值；

②若该数值是奇数，则将其与直接后继结点互换；

③若该数值是偶数，则将其直接后继结点删除。

规定：

编写主函数验证算法的对的性。

6.在一链表中，已知每个结点具有三个域：data、next和prior,其中prior域为空，设•'一个

算法，使每个结点的Prior指向它的前驱结点，形成双向循环链表。

规定：

①建立一个结点中具有三个域的单链表;

②在主函数中调用此算法，构成双向循环链表;

③在主函数中运用正向和逆向两种方式输出链表中的数据,验证算法的对的性。

7.用链表建立通讯录。通讯录内容有:姓名、通讯地址、电话号码。

规定：

①通讯录是按姓名项的字母顺序排列的；

②能查找通讯录中某人的信息；

提醒：

可用链表来存放这个通讯录，一个人的信息作为一个结点。成链的过程可以这样考虑：先把头结点后

面的第一个数据元素结点作为链中的首结点,也是末结点。从第二个数据开始逐个作为‘工作结点'，需从

链表的首结点开始比较，假如‘工作结点'的数据比链中的‘当前结点’的数据小，就插在其前面。否则,

再看后面是否尚有结点,若没有结点了就插在其后面成为末结点;若后面尚有结点，再与后面的结点逐个比较

解决。

【实验报告】

实习时间:2023/10/14实习地点:实习机号:

作了1,2,3,4,5,6题

1题

采用顺序存储表达实现的算法:

boolInsert_Sq(SqList&LrElemTypex)

(

inti;

if(L.length>=L.listsize)

<

L.elem*(ElexiiType*)realloc(L.elemr(L.list31ze+L.incrementsize)*sizeof(ElemiType));

if(!L.elem)returnfalse;

L.listsize+^L.incremenrsize;

)

for(1=L.length-1;x<L.elem[i]&&工厂0;工--)

L.elemJi+ll^L.elemti];

L.elem[i+l]*x;

具L.lengrh++;

returntrue;

体)

主数：

实

in.tmain(>

验<

SqLiscA;

内InitList_S<5(Ar100r10);

inta[IQ]={1,4,7,9,10,T4,17,65,98■123};

容inrxri=0;

cout«,请输入一小于2123的正整数:r,«endl;

cin>>x;

for(i=0;l<10;l++)

LisrlnsertSq(AFira[i]);

Inserc__Sq(Arx);

ListTraverse_Sq(A);

return0;

>I

运营结果：

请输入一小于123的整数：

121

14?91014176598121123

请按任意键继续・・・■

w\rtuia•tttaawvi\Ju•«wi，—\1r♦・・，>，

请输入一小于123的整数：

0

0147910141?6598123

请按任意键继续...■

请输入一小于123的整数：

124

14791014176598123124

请按任意键继续・.・■

算法代码：

boo1Insert_Sq(SqList&L,E1emTypex)

(

inti；。

if(L.length>=L.listsize)

(

L.e1em=(ElemType*)realloc(L.elem,(L.listsize+L.incrementsi

ze)*sizeof(ElemType));

。if(!L.e1em)returnfaIse；

。L.listsize+=L.incrementsize；

}

for(i=L.length-1;x<L.elem[i]&&i>=0;i—)

L.elem[i+1]=L.elem[i];

L.e1em[i+l]=x;

L.length++；

^returntrue；

}

采用链表实现的算法：

voidInsert_L(LinkListElemTypex)

(

LinkListprqrm;

p=L->nexr;

q=L;

while(p)

(

if(x>p->data&&p->next){p=p->-ext;q^q-^ext;}

elseif(x>p->data&&!(p->next))

(

rr.=(LinkList)malloc(sizeof(LNode));

m->data=x;

rc->next=NULL;

return;

I}

else{

ir=(LinkList)malloc(sizeof(LNode));

m->data=x;

iE->nextasp;

q->next=m;

return;

)

)

)

主函数：

Iintmain()

(

LinkListA;

inta[10]={]，4,7,9,10,14,工7,98,123,124};

CreateList_L_Front(Afa,10);

intxr1=0;

coux<”请输入一尔于123的整数：”《end1;

cin»x;

IInsert__L(Arx);

coutxv”操1三古结果：n«endl;

ListTraverse_L(A);

return0;

:}

运营结果：

甫物人一整数：

125

操作后结果：

14?910141798123124125

请按任意键继续...■

一1

操作后结果：

-1147910141798123124

请按任意键继续...■

区作后结果：

1347910141798123124

请按任意键继续.・・

算法代码：

voidInsert_L(LinkList&L,E1emTypex)

(

LinkListp,q,m；

»p=L->next;

q=L;

while(p)

6(

if(x>p->data&&p->next){p=p->next;q=q->next;}

eelseif(x>p->data&&!(p—>next))

。(

0m=(LinkList)ma1loc(sizeof(LNode));

。m->data=x;

g。p->next=m；

Qm->next=NULL;

oreturn;。

0)

•else{

。m=(LinkList)mal1oc(sizeof(LNode));

m->data=x;

g。m—>next=p;

Qq->next=m;

return;

6}

)

)

比较两种算法的优劣：顺序表和链表都要和X逐项比较，顺序表找到X应放的位

置之后插入,后面的元素都要向后移位，但链表只需修改指针即可，链表相对易

操作一些

2题算法：

voidDelete__L(LinlcList&L)

(

ElemTypex;

coutx〈”请输入元素x:n;

cin»x;

LinkListprq;

P=L;

if(!(p->next))

(

链表不存在"cvandl;

return;

}

while(p->next)

{

if(x=rp->next->dara&&p->nexr->nexr)

{q^-^ext;

p->next=q->next;

free(q);

return;

)

elseif(x=p->nexr->dar^&&!(p->next->nexr))

(

q^-^exr;

p->next=NULL;

free(q);

return;

)

p=sp_>next；

cout«"x不存在r,«endl;

return;

)

主函数：

intmain()

(

LinkLiscA;

ElemTypea[10]={1,2,3,4,7,56,75,89,4,60};

[CreateList_L_Front(Ara,10);

ListTraverse_L(A);

Delete__L(A);

cou七<<endl<<”操作后的结果：n«endl;

ListTraverse_L(A);

)

代码：

voidDelete_L(LinkList&L)

(

ElemTypex；

cOUt<<"请输入元素X:";

cin»x;

LinkListp,q;

叩二L;

4f(!(p->next))

6(

。cout<<"链表不存在"《endl；

^return;

)

while(p->next)

°{

。if(x==p->next—>data&&p—>next->next)

{q=p->next;

p->next=q—>next;

free(q);

return;

°}

。elseif(x==p->next->data&&!(p->next->next))

00{

ogq=p->next;

。p->next=NULL；

。。。free(q);

8ggreturn;

6}

°p—P->next;

b}

cout«*'x不存在°«end1;

oreturn;

}

结果：

1_2347567589460

喝胡人兀素x：2

A作后的结果：

1347567589460

请按任意键继续・.・.■

12347567589460

请输入元素x：60

操作后的结果：

123475675894

请按任意键继续...

1_237589460

置|25素x：18

x不存在

操作后的结果：

12347567589460

请按任意键继续...

3题

算法:

5voidDeleteRepeat_L(LinkList&L)

6(

LinkListprqrir.;

Bp^L-^ext;

9while(p->nexc!=NULL)i

0

1Q=P;

2while(q->next!=NULL)

3

4if(q->next->data=p->data)

5

6ir；=q->nexD

7q->next=m->next;

8free(m);

9)

0elseq=q->next;

1)

2p=p->next;

3)

4

5

主函数：

)intmain()

?{

JLinkListA;

inta4,7,9,1,0,1,4,1,7,9,8,1,2,3,1,2,4};

ICreateList_L_Front(A,ar18);

DeleteRepeat_L(A);

3couc<<”操后后结果：,r«endl;

IListTraverse_L(A);1

return0;

5}

运营结果：

操作后结果:

14790823

请按任意键继续..・

算法代码：

voidDeleteRepeat_L(LinkList&L)

(

LinkListp,q,m;

叩=L->next;

while(p->next!=NULL)

(

q=p;

awhi1e(q->next!=NULL)

°{

。oif(q->next->data==p->data)

00(

b。m=q->next；

soq->next=m->next;

ofree(m);

°}

。elseq=q->next;

}

^p=p->next;

4题

算法:

voidReverse_L(LinkList&headFLinkListp)

cout«rr；->next->data;

LinkListq;

rf(p->next=NULL)

Icout«r,无后继结点r,«endl;

else{

q3ssgmext;

m->next=q;

p->next=q->next;

q->mext;=g;

)

return;

)

主函数

intmain()

voidReverse__L(LinkList&seadrLinkListp);

srand((unsigned)rime(NULL));

LinkListheadrprk;

inti;

ElemTypea[10]={1,4,3,7,8,5,8,89,65,45》;

CreateList_L_Rear(head,a,10);

k=head->next;

ir.-head;I

ListTraverse_L(head);

for(i=l;i<rand()%(10);i++)//rand()%(10)是随机取。-9内的任意数,即取A中任一结点

p=k->next;

m=n:->next;//^^q=m->next;

}

Reverse__L(headrp);

结果：n«endl;

ListTraverse_L(head);

return0;

头文献并且定义了全局变量:

typedefintElemType;

I#include<stdlib.h>

}#include<iomanip・h>

I#include<LinkList.h>

i#include<stdio.h>

；#include<time.h>

'LinkList0://全局变量,使->next;

运营结果:

算法代码：

voidReverse_L(LinkList&head,LinkListp)

(

<>LinkListq,pre;

®q=head—>next;

pre=head;

ewhile(q!=NULL&&q!=p)

6(

pre=q;

®q=q->next;

)

if(p->next==NULL)

cout<V”无后继结点"v<end1;

else(

q=p->next;

pre—>next=q;

。p->next=q->next;

q->next=p;

}0

return；

)

5题

算法：

voidfxndmin_L(LinkList&L)

(

ElemTypee;

LinkListprqrprerq_pre;

p=L->next;

pre=L;

e=p->data;

while(p)

(

if(e>p->data)

{

e=p->data;

Q=P；

q__pre=pre;

)

p=p->next;

pre=pre->next;

)

cou1最小值为：n«e«endl;

if(e%2&6!a->r.ext||!(e%2)&&!q->next)

8UtX<”该最小值结点的后继为空，不进行操作。r,«endl;

elseif(e%2&&q->nexr)

I{

LinkListm;

iE=q->nexr;

q_pre->nextssir.;

q->next=m->next;

q;

8uc<<”此最小值为奇数，将其与直接后继结点交换。"«endl;

)

else{

LinkListm;

mSBq->next;

q->next=ir；->next;

free(in);

coutxv此最小值为偶数，将其直接后继结点删除。"«endl;

)

)

主函数：

intmain()

{

LinkListA;

ElemTypea[10],x;

coutxv”请输入10个整数：n«endl;

for(inti=0;i<10;i++)

{

cin»x;

a[i]=x;

)

CreateList_L__Front(Ara,10);

findmin_L(A);

couc<<"操作后的结果为：

ListTraverse_L(A);

)

操作结果：

人

福10

87‘I、整数：

5432671

值

福鼻的后继为空,

小不进行操作。

有8?65432671

个

一10

刖765652

78

值2

.

点

三

小

结'*

,4不进行操作。

果

结

继

键876545678652

意90

■■

^*

人1

1笠4:

i9r18F71235

656

值

最

山.

富

小

此^

搭将其与直接后继结点交换。

后

身

操

提2

外987234s656

W八

1918762345

日677890

山

值.2

喜

偶

熊7

/小m,将其直接后继结点删除。

果

、

塞

后

镖7

继98245677890

幺

音

算法代码：

voidfindmin_L(LinkList&L)

(

ElemTypee;

LinkListp,q,pre,q_pre;

p=L—>next;

pre=L;

e=p->data;

ewhile(p)

|

if(e>p->data)

e(

。e=p->data;

、8q=p;

a。。q_pre=pre;

)

。p=p—>next?

。pre=pre->next；

}6

coutV<”最小值为："<<e<<endl；

if(e%2&&!q->nextI|!(e%2)&&!q->next)

ocout该最小值结点的后继为空，不进行操作。"<vendl;

。eIseif(e%2&&q->next)

0{

。LinkListm;

sm=q->next;

gq_pre->next=m;

q->next=m->next;

°m->next=q;<>

。。cout<<”此最小值为奇数，将其与直接后继结点互换。"<<endl；

}

«>else{

gLinkListm;

egm=q->next；

。q->next=m->next;

free(m)；

cout<〈”此最小值为偶数，将其直接后继结点删除。”«endl;

6题

算法:

voidbuild_circle(DuLinkList&head)

{

DuLinkListn;

m=head;

le(m->next->data!=0)

m->next->prior=m;

->'.ext->prior=ir.;

voidInitDuL(DuLinkList&L)

{

L=(DuLNode*)malloc(sizeof(DuLNode));

if(!L)exit(1);

L->next=NULL;

L->prior=NULL;

主函数:

intmain()

{

voidInitDuL(DuLinkList&L);

voidbuild_circle(DuLinkList&head);

DuLinkListpfqrheadrk;

InitDxiL(p);

InitDuL(q);

InitDuL(head);T

ElemTypea;'

head=q;

cout«"向链表中输入一串数字，以0作为浩交标志:"«endl;

nn

scanf(%df&a);

q->data=O;

while(a)//建立单项循环链表并赋值

{

InitDuL(p);|

p->data=a;

q->next=p;

q=p;

scanf("¥d”，&a);

I

p->nexc=k=head;

build_circle(head);

while(head->next->data)//正向循环输出链表

{

cout«head->next->data«"n;

head=head->next;

cour«endl;

build_circle(k:);//反向循环输出链表

while(k->pr±or->data)

<

cout«k->prior->dara«nn;

k=k->prior;

)

)

头文献及定义的结构体：

1typedefintElemType;

2#include<stdlib.h>

3#include<iomanip.h>

4#include<stdio.h>

5typedefstructdunode{

6ElemTypedata;

7structdunode*next;

structdunode*prior;

9}DuLNodef*DuLinkList;

算法代码：

voidbuild_circle(DuLinkList&head)

(

QuLinkListm,n;

m=head;

while(m->next->data!=O)

9(

。m->next—>prior=m;

<>m=m—>next；。

m->next—>prior=m;。

)

结果:

句链表中输入一串数字，以。作为结束标志:

234567890

)3456789

,8765432请按任意键继续...

程序运营过程出现的错误

1题：

用顺序表操作比较顺利，但用链表进行比较时，找到相应位置后，插入过程出现错误,编的错误代码使插入

的操作变为替换后边的紧邻结点的操作

2题：

编写过程无错误

3题：

程算法思想是第一个结点的数和后面的依次比较，假如相等，就删掉，然后再从第二个节点继续做和第一个

结点同样的事，直到最后为空,但我在编的过程中却不知如何实现此操作，后来百度了一下：让循环套循环，内

序层的循环让固定一个结点的数依次和后面的比较，相同的删除，内部结束后P=P->next;然后再做相同的操

作，直到结点最后。

调4题：

(1)此题定义了全局变量，但是一开始编程序时，却莫名其妙在主函数里又定义了一次，此时，操

试作的就是主函数里的这个m,而全局变量没有进行任何操作,因而在编的函数里用m时，程序

会出现错误。

过(2)在调换两结点位置时，有发生错误。

5题：

程(1)在求最小值并执行完p=p->next之后,p指向空值，但在初编此程序时,却想当然认为p

求出最小值后指向最小值所在结点，因而在后面if(e%2&&!q-〉next||!(e%2)&&!q->n

ext)中，这个判断条件始终为真，由于此时q=NULL。

(2)一开始直接在程序中给a[i]赋值，而不是通过输入给a[i]值，固定的一组数不能全面检查,

应当实验多组数，特别是比较刁钻苛刻的数

题6:

(1)在定义DuLinkListp,q,head,k;后,head=p；建立链表后并p->next=head;为了也给

k赋头结点,写成了p->next=head=k;但这样却使head前继后继都变为空了。

(2)在循环输入一组整数时,用的是cin»a;,然后在输入数的时候直接:234567890

这样输入，但是由于cin任何类型都可以输入，所以空格也会被输入，因而出现错误，假如用cin

输入整数，可以借助数组,inta[5];for(i=0；i<5；i++)cin»a[i];

在编代码过程中出现的若干错误,有一部分是本来就不知道，有一些事由于不纯熟，不熟悉所

以导致错误，也有一些是由于马虎。当编码可以通过却无法产生结果时，通过逐步地调试，可

以发现犯错地方以及犯错的因素，我觉得调试的过程就是不断进步，自我纠错的过程。编出代码，

运营，改正，再完善--在这个过程中,编写代码的思维就更完善，更纯熟，犯得低档错误也会

越来越少。

实

习

小

结

实验二堆栈与队列

【实验目的】

I.学习如何使用c语言实现堆栈与队列。

2.熟悉堆栈与队列的基本操作及应用。

【实验内容】

1.现有一顺序循环队列，其结构描述为：

#defineMAX100

typedefstruct

{ElemTypequeue[MaxQueueSize]；

intfront；//队头指针

intcount;〃计数器

}QueueType；

规定：

①设计队列的几种几种操作:初始化、进队、出队、取队头元素和判断队列是否非空。

②编写一个主函数进行测试。

2.已知Q是一个非空队列，S是一个空栈。编写算法实现:将队列Q中的所有元素逆置。

规定：

①调用堆栈和队列的操作函数实现该算法。

②编写一个主函数进行测试。

3.设计一个算法，将计算机产生的n个随机数分为奇数、偶数两组，并将它们分别压入两个栈中，然后

在屏幕上输出。

4.编写一个程序，反映病人到医院看病排队看医生的情况。在病人排队过程中，重要反复两件事：

①病人到达诊室，将病历交给护士，排到等候队列中候诊。

②护士从等待队列中取出下一个病人的病历，该病人进入诊室就诊。

规定模拟病人等待就诊这一过程。程序采用菜单方式，其选项及功能说明如下：

①排队——输入排队病人的病历号，加入到病人排队队列中；

②就诊——病人排队队列中最前面的病人就诊，并将其从候诊队列中删除；

③查看排队——从队首到队尾列出所有的排队病人的病历号；

④不再排队,余下依次就诊——从队首到队尾列出所有的排队病人的病历号,并退出运营；

⑤下班一退出运营。

【实验报告】

实习时间：2023/10/21实习地点:九号楼八楼机房实习机号:

做了1,2,3,4题

1题

头文献：

JL

1typedefintElemType;

具2#include<stdlib.h>

3#include<iomanip.h>

体4#defineMaxQueueSize100

定义结构体：

实

typedefstruct

验(

ElemType*queue;

intfront;

内

intrear;

intqueuesize;

容intcount;;

IQueueType;

编写的初始化、进队、出队、取队头元素和判断队列算法：

boolInit_Sq(QueueType&Qrintmaxsize=MaxQueueSize)

{

Q.queue=(ElemType*)malloc(MaxQueueSize*sizeof(ElemType));

if(!Q.queue)exit(1);

Q.front3^.rear=0;

Q.cotmt^O;

Q.queuesize^.axsxze;

)

boolenq_Sq(QueueType&三，ElemTypee)

{

if(Q.rear=Q.front&&Q.cotmt>0)

returnfalse;

Q.queue[Q.rear]=e;

Q.rear=(Q.rear+1)%Q.queuesize;

Q.count++;

returntrue;

)

booldeq_Sq(QueueT^e&&,ElemType&e)

<

if(Q.count=0)

returnfalse;

else{

e=Q.queue[Q.front];

Q.front*(Q.front+1)%Q.queuesize;

Q.count--;

returntrue;

)

)

boolgetq_Sq(QueueTypeQfElemType&e)

(

if(Q.count=0)returnfalse;

e=Q.queue[Q.front];

returntrue;

)

boolempty_Sq(QueueTypeQ)

(

returnQ.connL=0;

i>

主函数：

intmain()

(

QueueTypeQ;

ElemTypea[10]={l,2,3,4,5,6,7,8,9,0},b[10],x,c;

inti;

Init_Sq(Qr10);

Lf(eir^)ty__Sq(；))ccmcv〈”可始化之后，进队之前队列为空”<<end1;

8Ut<<"分别让下列元素进队：-；

for(1=0；1<10；1++)

<

cout«a[i]«,*;

enq_Sq(Qra[i]);

}

cout<<andl<<"lE下？J元素出口人：r,;

for(i=0;x<4;±++)

{

deq_Sq(Qrb[i]);

cout«b[x]«'1;

)

getq_Sq(Qrx);

couc«andl<<”比时[?、首元素为：n«x«endl;;

COUtX<“再让下列元素进队：n；

for(1=0;__<3;i++)

(

cout«i+l«',;

enq__Sq(Qri+l);

)

cout«endl«”让所有元素出队:

while(Q.count>0)

I(

deq_Sq(Qrx);

cout«x«1";

：}

free(Q.queue);

}

运营结果：

第化

之VV

心

接

让

下123

下

素:

^24567890

兀134

时

：

队

身

让

鑫

队123

元

所

队5678

:0123请按任意键继续

算法代码：

boolInit_Sq(QueueType&Q,intmaxsize=MaxQueueSize)

(

Q.queue=(E1emType*)malloc(MaxQueueSize*sizeof(E1emType));

if(!Q.queue)exit(l);

fiQ.front=Q.rear=0；

oQ.count=0；

oQ.queuesize=maxsize;

)

boo1enq_Sq(QueueType&Q,ElemTypee)

(

if(Q.rear==Q.front&&Q.count>0)

。returnfalse;

Q.queue[Q.rear]=e;

Qrear=(Q.rear+l)%Q.queuesize;

oQ.count++;

returntrue;

)

booldeq_Sq(QueueType&Q,ElemTypee)

{

df(Q.count==0)

。returnfalse;

else{

oe=Q.queue[Q.front];

Q.front=(Q.front+1)%Q.queuesize;

bQ.count—；

returntrue；

}

}

boolgetq_Sq(QueueTypeQ,E1emType&e)

(

。if(Q.count==0)retumfalse;

e=Q.queue[Q.front];

returntrue;

)

boolempty_Sq(QueueTypeQ)

(

。retumQ.count==0;

2题：

头文献：

1typedef±nzElemType;

2#include<stdlib.h>

3#include<iomanip.h>

#include<SqQueue.h>

5#include<SqStack.h>

算法：

voidinverse(SqQueue&二)

{

SqStackS;

ElemTypee;

InitStack__Sq(8);

while(!QueueEmpty_Sq(Q))

(

DeQueue_Sq(Qre);

Pus