数据结构作业参考答案Word文档格式.docx
《数据结构作业参考答案Word文档格式.docx》由会员分享，可在线阅读，更多相关《数据结构作业参考答案Word文档格式.docx（31页珍藏版）》请在冰豆网上搜索。
（L.elem[i-1]）;
for（p=&
（L.elem[L.length-1]）;
p>
=q;
--p）
*（p+1）=*p;
*q=e;
++L.length;
return（OK）;
}
//顺序表显示
voidxsList（SqListL）
{
inti=L.length,k;
for（k=0;
k<
i;
k++）
printf（"
%d"
L.elem[k]）;
printf（"
\n"
）;
//顺序表逆置
voidnizhi（SqList&
L）
inti=0,j=L.length-1;
ElemTypetemp;
for（;
i<
j;
i++,j--）
{
temp=L.elem[i];
L.elem[i]=L.elem[j];
L.elem[j]=temp;
}
main（）
SqListL;
charflag1='
y'
flag2='
n'
;
inti;
ElemTypek;
if（InitList_Sq（L））
建立空顺序表成功！
do{
printf（"
当前线性表长度为：
%d\n"
L.length）;
请输入要插入元素的位置：
"
scanf（"
%d"
&
i）;
请输入要插入的元素值：
k）;
if（sxbcr（L,i,k））
{
printf（"
插入成功，插入后顺序表长度为：
插入后的顺序表为：
xsList（L）;
}
else
插入失败"
\n继续插入元素？
（y/n）"
fflush（stdin）;
%c"
flag1）;
}while（flag1=='
nizhi（L）;
printf（"
顺序表逆置后为：
xsList（L）;
2．从键盘读入n个整数（升序），请编写算法实现：
（1）CreateList（）：
建立带表头结点的单链表；
（2）PrintList（）：
显示单链表，（形如：
H->
10->
20->
30->
40）;
（3）InsertList（）：
在有序单链表中插入元素x；
（4）ReverseList（）：
单链表就地逆置；
（5）DelList（）：
在有序单链表中删除所有值大于mink且小于maxk的元素。
选作：
使用文本菜单完成功能选择及执行。
参考答案：
#include<
typedefstructnode{
ElemTypedata;
structnode*link;
}Lnode,*LinkList;
//头插法建立单链表
voidCreate_L1（LinkList&
L,intn）
LinkListp;
L=（LinkList）malloc（sizeof（Lnode））;
L->
link=NULL;
for（i=n;
i>
0;
--i）
p=（LinkList）malloc（sizeof（Lnode））;
scanf（"
p->
data）;
p->
link=L->
link;
L->
link=p;
}
//尾插法建立单链表
voidCreate_L2（LinkList&
L,intn）
LinkLists,p;
inti;
data=0;
link=NULL;
p=L;
for（i=1;
=n;
i++）
{
s=（LinkList）malloc（sizeof（Lnode））;
s->
s->
p->
link=s;
p=s;
//查找是否存在结点e
LinkListdlbcz（LinkListL,ElemTypee）
LinkListp=L->
link;
while（p!
=NULL&
&
data!
=e）
p=p->
return（p）;
//在第i个元素之前插入结点e
StatusListInsert_L（LinkListL,inti,ElemTypee）
LinkListp=L,s;
intj=0;
while（p&
j<
i-1）
{
p=p->
++j;
p||j>
i-1）
returnERROR;
s=（LinkList）malloc（sizeof（Lnode））;
data=e;
link=p->
link=s;
returnOK;
//删除第i个结点
StatusListDelete_L（LinkListL,inti,ElemType&
e）
LinkListp=L,q;
while（p->
link&
p=p->
++j;
（p->
link）||j>
q=p->
link=q->
e=q->
data;
free（q）;
//求第i个元素值
StatusGetElem_L（LinkListL,inti,ElemType&
intj=1;
LinkListp=L->
while（p&
j<
i）
j++;
if（!
p||j>
i）returnERROR;
e=p->
//显示单链表中元素
voidxsList（LinkListL）
while（p）
p->
p=p->
//删除大于mink且小于maxk的元素
voidDelList（LinkList&
L,ElemTypemink,ElemTypemaxk）
LinkListp=L,q;
while（p->
link&
link->
data<
mink）
q=p;
while（q&
q->
maxk）
q=q->
link=q;
//就地升序排序
voidsh_sort（LinkList&
link,pre=L,q=L->
link,u;
while（q）
p=L->
pre=L;
while（p&
data）
pre=p;
u=q->
pre->
q->
link=p;
q=u;
//就地逆置
voidnizhi（LinkList&
link,q=L->
link=L->
//有序表插入
voidyxcharu（LinkList&
L,ElemTypee）
LinkListpre,p,s;
pre=L;
p=L->
pre=p;
s=（LinkList）malloc（sizeof（Lnode））;
s->
data=e;
pre->
LinkListL;
intn,i,mink,maxk;
ElemTypee;
charchoice='
0'
while（choice!
='
q'
）
\n****************\n"
1.建立单链表"
2.取元素值"
3.查找\n"
4.插入"
5.删除"
6.显示\n"
7.删除大于mink且小于maxk的元素值"
8.就地升序排序\n"
9.就地逆置"
a.有序表插入"
q.退出\n"
\n请选择操作：
fflush（stdin）;
scanf（"
choice）;
switch（choice）
case'
1'
:
请输入单链表中结点个数：
scanf（"
n）;
Create_L2（L,n）;
break;
2'
请输入元素位序：
GetElem_L（L,i,e）;
元素值为：
e）;
3'
请输入要查找的元素：
e）;
if（dlbcz（L,e））
查找成功！
查找失败。
4'
请输入插入位置：
请输入要插入的元素：
if（ListInsert_L（L,i,e））
插入成功！
单链表为：
插入失败。
5'
请输入删除位置：
if（ListDelete_L（L,i,e））
删除成功！
删除失败。
6'
\n单链表为：
xsList（L）;
7'
请输入mink和maxk:
%d,%d"
mink,&
maxk）;
DelList（L,mink,maxk）;
8'
sh_sort（L）;
break;
9'
nizhi（L）;
a'
请输入在有序表中插入的元素值:
yxcharu（L,e）;
}
作业2.栈、队列、数组
非编程作业：
1．若进栈序列为ABCD，请写出全部可能的出栈序列和不可能的出栈序列。
可能的出栈序列：
（14种）
dcbacdbabacdcbdaadcbcbadbdcaacdbbcdaacbdbcadabdcbadcabcd
不可能的出栈序列：
（10种）
dbcadbacdabcdacbdcabcabdcdabbdaccadbadbc
2．简要说明循环队列如何判断队满和队空？
当牺牲一个存储结点，约定以“队列头指针在队列尾指针的下一位置（指环状的下一个位置）上”作为队列“满”状态的标志时，循环队列判断队满的条件为：
（rear+1）%MaxQsize==front；
判断队空的条件为：
front==rear。
3．设A为n阶对称矩阵，采用压缩存储存放于一维数组F[n（n+1）/2]中（从F[0]开始存放），请分别给出存放上三角阵时任一矩阵元素aij（1≤i,j≤n）的地址计算公式和存放下三角阵时任一矩阵元素aij（1≤i,j≤n）的地址计算公式。
存放上三角阵时，任一矩阵元素aij（1≤i,j≤n）的地址计算公式为：
存放下三角阵时，任一矩阵元素aij（1≤i,j≤n）的地址计算公式为：
4．写出下面稀疏矩阵的三元组顺序表和十字链表表示。
编程作业
栈采用顺序栈存储，试设计算法实现将表达式转换成后缀表达式输出。
例如，输入表达式：
a+b/c-（d*e+f）*g
输出其后缀表达式：
abc/+de*f+g*-
stdlib.h>
string.h>
#defineOVERFLOW-2
#defineERROR0
#defineSTACK_INIT_SIZE100
#defineSTACKINCREMENT10
typedefcharSElemType;
typedefcharstring[80];
typedefstruct
{SElemType*base;
SElemType*top;
intstacksize;
}SqStack;
StatusInitStack（SqStack&
S）
{S.base=（SElemType*）malloc（STACK_INIT_SIZE*sizeof（SElemType））;
if（!
S.base）exit（OVERFLOW）;
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return（OK）;
StatusClearStack（SqStack&
S）
{S.base=（SElemType*）realloc（S.base,STACK_INIT_SIZE*sizeof（SElemType））;
voidDestroyStack（SqStack&
{S.stacksize=0;
if（S.base）free（S.base）;
S.base=S.top=NULL;
StatusStackEmpty（SqStackS）
{if（S.top==S.base）
returntrue;
else
returnfalse;
SElemTypeGetTop（SqStackS）
{SElemTypee;
if（S.top>
S.base）
e=*（S.top-1）;
returne;
StatusPush（SqStack&
S,SElemTypee）
if（S.top-S.base>
=S.stacksize）//栈满
{S.base=（SElemType*）realloc（S.base,（S.stacksize
+STACKINCREMENT）*sizeof（SElemType））;
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
*S.top++=e;
StatusPop（SqStack&
S,SElemType&
e）
{if（S.top==S.base）//栈空
returnERROR;
e=*--S.top;
StatusInOP（SElemTypec）
charOperators[]={'
+'
'
-'
*'
/'
（'
）'
#'
\0'
};
intlen=strlen（Operators）;
for（inti=0;
len;
if（c==Operators[i]）
returntrue;
returnfalse;
SElemTypePrecede（SElemTypecurtop,SElemTypeinput）
{SElemTypeorder;
switch（input）{
case'
switch（curtop）{
order='
>
'
break;
<
break;
switch（curtop）{
returnorder;
voidPass（stringSuffix,SElemTypech）
{*Su
升级会员 