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;
}
测试结果为：
①表达式中包含+、-、*的情况；
②表达式中包含（）、+、-、*的情况；
③表达式中包含（）、+、-、*、/的情况；
④表达式中出现负数的情况；
实验四字符串实验（2学时）
实验
升级会员 