Scanf(“%d”,&pArray[i]);
intmain(intargc,char*argv[])
{
SqlistL;
intArray[M],Select;
Initlialize(L);
do{
printf("请输入选择方法(1表示头插法,2表示尾插法,0表示结束):
\n");
scanf("%d",&Select);
switch(Select)
{
case1:
printf("按头插法建立线性表:
\n");input(Array,M);CreatlistF(L,Array,M);break;
case2:
printf("按尾插法建立线性表:
\n");input(Array,M);CreatlistR(L,Array,M);break;
}
printf("原线性表数据为:
\n");Displist(L);
Getelem(L,3);Locatelem(L,2);
Inselem(L,5,5);
printf("修改后的线性表数据为:
\n");
//Delelem(L,4);
Displist(L);
}while(Select!
=0);
return0;
}
//运行结果:
实验三栈和队列实验(6学时)
实验目的:
(1)熟练掌握栈和队列的抽象数据类型及其结构特点;
(2)实现基本的栈和队列的基本操作算法程序。
实验内容:
(类C算法的程序实现,任选其一)
(1)设计与实现基本的堆栈和队列结构下的各种操作(如堆栈的PUSH、POP等操作)(必做);
(2)以表达式计算为例,完成一个可以进行算术表达式计算功能的算法设计与实现(选做);
实验准备:
1)计算机设备;2)程序调试环境的准备,如TC环境;3)实验内容的算法分析与代码设计与分析准备。
实验步骤:
1.录入程序代码并进行调试和算法分析;2.编写实验报告。
实验结果:
(1)/*队列存储*/
#include"stdio.h"
typedefintstatus;
#defineQueueSize10
typedefstructsqqueue
{
chardata[QueueSize];
intfront,rear;
}SqQueue;
voidInitQueue(SqQueue&qu)
{
qu.front=qu.rear=0;
}
statusEnQueue(SqQueue&qu,charx)
{
if((qu.rear+1)%QueueSize==qu.front)
return0;
qu.rear=(qu.rear+1)%QueueSize;
qu.data[qu.rear]=x;
return1;
}
statusDeQueue(SqQueue&qu,char&x)
{
if(qu.rear==qu.front)
return0;
qu.front=(qu.front+1)%QueueSize;
x=qu.data[qu.front];
return1;
}
statusGetHead(SqQueuequ,char&x)
{
if(qu.rear==qu.front)
return0;
x=qu.data[(qu.front+1)%QueueSize];
return1;
}
statusQueueEmpty(SqQueuequ)
{
if(qu.rear==qu.front)
return1;
else
return0;
}
voidmain()
{
SqQueuequ;
chare;
InitQueue(qu);
printf("Queue%s\n",(QueueEmpty(qu)==1?
"Empty":
"NotEmpty"));
printf("insera\n");EnQueue(qu,'a');
printf("inserb\n");EnQueue(qu,'b');
printf("inserc\n");EnQueue(qu,'c');
printf("inserd\n");EnQueue(qu,'d');
printf("Queue%s\n",(QueueEmpty(qu)==1?
"Empty":
"NotEmpty"));
GetHead(qu,e);
printf("Queueoftopelemis:
%c\n",e);
printf("showofQueue:
\n");
while(!
QueueEmpty(qu))
{
DeQueue(qu,e);
printf("%c\t",e);
}
printf("\n");
}
实验结果:
(2)/*用栈实现对表达式的求值运算*/
#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"/*数据类型转换库函数*/
#defineTRUE1
#defineFALSE0
#defineOK1
#defineERROR0
#defineINFEASIBLE-1
#defineOVERFLOW-2
#defineSTACK_INIT_SIZE100/*初始分配量*/
#defineSTACKINCREMENT10/*存储空间的分配增量*/
typedefintStatus;
typedefcharElemType;
typedefElemTypeOperandType;/*操作数*/
typedefcharOperatorType;
typedefstruct
{
ElemType*base;
ElemType*top;
intstacksize;
}SqStack;
StatusInitStack(SqStack&S)
{
/*构造一个空栈S*/
S.base=(ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemType));
if(!
S.base)exit(OVERFLOW);/*存储空间失败*/
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
returnOK;
}/*InitStack*/
StatusGetTop(SqStackS)
{
/*若栈不空,则用e返回S的栈顶元素*/
ElemTypee;
if(S.top==S.base)returnERROR;
e=*(S.top-1);
returne;
}/*GetTop*/
StatusPush(SqStack&S,ElemTypee)/*插入元素e为新的栈顶元素*/
{
if(S.top-S.base>=S.stacksize)
{
/*栈满,追加存储空间*/
S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(ElemType));
if(!
S.base)exit(OVERFLOW);/*存储空间失败*/
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
returnOK;
}/*Push*/
StatusPop(SqStack&S,ElemType&e)/*取栈顶元素,用e返回*/
{
/*若栈不空,则删除S的栈顶元素,用e返回其值,并返回OK;否则返回ERROR*/
if(S.top==S.base)returnERROR;
e=*--S.top;
returnOK;
}/*Pop*/
charIn(charc,charOP[])/*判断字符c是否属于运算符*/
{
if(c>=35&&c<=47)
return1;
/*常见操作符(如:
'#'、'('、')'、'+'、'-'、'*'、'\'等)的ASCII码在35到47之间*/
elsereturn0;
}
charOP[8]={'+','-','*','/','(',')','#','\0'};/*定义有所要用到的操作符构成的数组OP[8]*/
intm[7][7]={1,1,2,2,2,1,1,
1,1,2,2,2,1,1,
1,1,1,1,2,1,1,
1,1,1,1,2,1,1,
2,2,2,2,2,0,-1,
1,1,1,1,-1,1,1,
2,2,2,2,2,-1,0};
/*各运算符间优先级别的关系*/
/*以上:
1表示‘>’;2表示‘<’;0表示‘=’;-1表示‘不存在’*/
charPrecede(chari,charj)/*比较数组OP[]中字符i与数组OP中字符j的优先权*/
{
inta,b;char*p;
for(p=OP,a=0;*p!
='\0';p++,a++)
if(*p==i)break;
for(p=OP,b=0;*p!
='\0';p++,b++)
if(*p==j)break;
if(m[a][b]==1)return'>';
elseif(m[a][b]==2)return'<';
elseif(m[a][b]==0)return'=';
elsereturn'O';
}
charOperate(chara,chartheta,charb)/*对运算数a、b按操作符theta进行二元运算*/
{
if(a>47)a=atoi(&a);/*将字符数转化为整型数*/
if(b>47)b=atoi(&b);
switch(theta)
{
case'+':
returna+b;
break;
case'-':
returna-b;
break;
case'*':
returna*b;
break;
case'/':
returna/b;
break;
}
return'1';
}
OperandTypeEvaluateExpression()/*算术表达式求值的算符优先算法*/
{
SqStackOPTR,OPND;/*设OPTR、OPND分别运算符栈和运算数栈*/
OperandTypea,b,c;OperatorTypetheta;
InitStack(OPTR);Push(OPTR,'#');
InitStack(OPND);c=getchar();
while(c!
='#'||GetTop(OPTR)!
='#')
{
if(!
In(c,OP)){Push(OPND,c);c=getchar();}
else
switch(Precede(GetTop(OPTR),c))
{
case'<':
Push(OPTR,c);c=getchar();
break;
case'=':
Pop(OPTR,c);c=getchar();
break;
case'>':
Pop(OPTR,theta);Pop(OPND,b);Pop(OPND,a);
Push(OPND,Operate(a,theta,b));
break;
}
}
returnGetTop(OPND);
}
intmain()
{
printf("(请输入运算表达式:
以#为结束符)\n");
inta;
a=(int)EvaluateExpression();
/*执行函数EvaluateExpression(),将表达式的最终值强制转换为整型,并用a返回*/
printf("%d",a);
getchar();
return0;
}
测试结果为:
①表达式中包含+、-、*的情况;
②表达式中包含()、+、-、*的情况;
③表达式中包含()、+、-、*、/的情况;
④表达式中出现负数的情况;
实验四字符串