大连理工大学数据结构(一)上机作业答案张老师.doc
《大连理工大学数据结构(一)上机作业答案张老师.doc》由会员分享，可在线阅读，更多相关《大连理工大学数据结构(一)上机作业答案张老师.doc（12页珍藏版）》请在冰豆网上搜索。
1．将顺序表逆置，要求用最少的附加空间。
参考答案
#include
#include
#include
#defineOK1
#defineERROR0
#defineINFEASIBLE-1
#defineOVERFLOW-2
typedefintElemType;
typedefintStatus;
#defineLIST_INIT_SIZE100
#defineLISTTINCREMENT10
typedefstruct{
ElemType*elem;
intlength;
intlistsize;
}SqList;
//创建空顺序表
StatusInitList_Sq（SqList&L）{
L.elem=（ElemType*）malloc（LIST_INIT_SIZE*sizeof（ElemType））;
if（!
L.elem）exit（OVERFLOW）;
L.length=0;
L.listsize=LIST_INIT_SIZE;
returnOK;
}
//创建顺序表，插入元素
voidListInput_Sq（SqList&L）{
intn,i;
printf（"inputthelengthofSqlist:
"）;
scanf（"%d",&n）;
L.length=n;
for（i=0;i {
printf（"inputelem:
"）;
scanf（"%d",&L.elem[i]）;
}
}
//输出顺序表中的元素
voidListOutput_Sq（SqListL）{
inti,n;
n=L.length;
for（i=0;i printf（"%2d",L.elem[i]）;
}
//顺序表逆置
voidReverseList_Sq（SqList&L）{
inti,n;
ElemTypep;
n=L.length;
for（i=0;i{
p=L.elem[i];
L.elem[i]=L.elem[n-i-1];
L.elem[n-i-1]=p;
}
}
voidmain（）{
SqListL;
InitList_Sq（L）;
ListInput_Sq（L）;
ListOutput_Sq（L）;
ReverseList_Sq（L）;
printf（"\n"）;
printf（"输出结果为：
"）;
ListOutput_Sq（L）;
printf（"\n"）;
}
2．从键盘读入n个整数（升序），请编写算法实现：
（1）CreateList（）：
建立带表头结点的单链表；
（2）PrintList（）：
显示单链表，（形如：
H->10->20->30->40）;
（3）InsertList（）：
在有序单链表中插入元素x；
（4）ReverseList（）：
单链表就地逆置；
（5）DelList（）：
在有序单链表中删除所有值大于mink且小于maxk的元素。
选作：
使用文本菜单完成功能选择及执行。
参考答案：
#include
#include
#include
#defineOK1
#defineERROR0
typedefintElemType;
typedefintStatus;
typedefstructLNode{
ElemTypedata;
structLNode*next;
}LNode,*LinkList;
voidCreateList（LinkList&L,intn）{
inti;
LNode*p,*q;
L=（LinkList）malloc（sizeof（LNode））;
L->next=NULL;
q=L;
printf（"请输入所要建立的单链表所包含的元素：
"）;
for（i=0;i p=（LinkList）malloc（sizeof（LNode））;
scanf（"%d",&p->data）;
p->next=NULL;
q->next=p;
q=p;
}
}
voidPrintList（LinkListL）{
LNode*p;
p=L->next;
while（p）{
printf（"%d",p->data）;
p=p->next;
}
printf（"\n"）;
}
voidInsertList（LinkListL,ElemTypem）{
LNode*p,*q,*s;
p=L;
q=L->next;
while（q&&q->data p=q;
q=q->next;
}
if（q）{
s=（LinkList）malloc（sizeof（LNode））;
s->data=m;
s->next=q;
p->next=s;
}
else{
s=（LinkList）malloc（sizeof（LNode））;
s->data=m;
s->next=NULL;
p->next=s;
}
}
voidReverseList（LinkList&L）{
LNode*p,*q;
if（L->next&&L->next->next）{
p=L->next;
q=p->next;
p->next=NULL;
while（q）{
p=q;
q=q->next;
p->next=L->next;
L->next=p;
}
}
}
voidDeleteList（LinkList&L,ElemTypemink,ElemTypemaxk）{
LNode*p=L,*q;
while（p->next&&p->next->data<=mink）
p=p->next;
q=p;
while（q&&q->data q=q->next;
p->next=q;
}
voidmain（）{
LinkListL;
intn,number;
ElemTypee,mink,maxk;
do{
printf（"*********************************\n"）;
printf（"建立单链表请按1.\n"）;
printf（"显示单链表请按2.\n"）;
printf（"有序插入新元素请按3.\n"）;
printf（"单链表就地逆置请按4.\n"）;
printf（"删除大于mink且小于maxk的所有元素请按5.\n"）;
printf（"退出请按0.\n"）;
printf（"*********************************\n"）;
printf（"\n请选择操作：
\n"）;
scanf（"%d",&number）;
switch（number）{
case1:
printf（"请输入单链表中的节点个数：
"）;
scanf（"%d",&n）;
CreateList（L,n）;
break;
case2:
printf（"要执行本操作请先建立单链表，请输入单链表中的节点个数：
"）;
scanf（"%d",&n）;
CreateList（L,n）;
printf（"单链表为：
"）;
PrintList（L）;
break;
case3:
printf（"要执行本操作请先建立单链表，请输入单链表中的节点个数：
"）;
scanf（"%d",&n）;
CreateList（L,n）;
printf（"请输入有序表中插入的值：
"）;
scanf（"%d",&e）;
InsertList（L,e）;
PrintList（L）;
break;
case4:
printf（"要执行本操作请先建立单链表，请输入单链表中的节点个数：
"）;
scanf（"%d",&n）;
CreateList（L,n）;
printf（"单链表逆置：
"）;
ReverseList（L）;
PrintList（L）;
break;
case5:
printf（"要执行本操作请先建立单链表，请输入单链表中的节点个数：
"）;
scanf（"%d",&n）;
CreateList（L,n）;
printf（"请输入mink和maxk：
"）;
scanf（"%d%d",&mink,&maxk）;
DeleteList（L,mink,maxk）;
PrintList（L）;
break;
}
}while（number!
=0）;}
第二次作业
栈采用顺序栈存储，试设计算法实现将表达式转换成后缀表达式输出。
例如，输入表达式：
a+b/c-（d*e+f）*g
输出其后缀表达式：
abc/+de*f+g*-
参考答案：
#include
#include
#include
#include
#defineOVER-2
#defineOK1
#defineERROR0
#defineture1
#definefalse0
#defineSTACK_INIT_SIZE100
#defineSTACKINCREMENT10
typedefcharSElemType;
typedefcharElemType;
typedefstruct{
SElemType*base;
SElemType*top;
intstacksize;
}SqStack;//定义结构
intInitStack（SqStack&S）{
S.base=（ElemType*）malloc（STACK_INIT_SIZE*sizeof（ElemType））;
if（!
S.base）exit（OVER）;
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
returnOK;
}//建栈
intPush（SqStack&S,SElemTypee）{
if（S.top-S.base>=S.stacksize）
{S.base=（ElemType*）realloc（S.base,（S.stacksize+STACKINCREMENT）*sizeof（ElemType））;
if（!
S.base）exit（OVER）;
S.top=S.base+S
升级会员 