c0de.docx
《c0de.docx》由会员分享，可在线阅读，更多相关《c0de.docx（18页珍藏版）》请在冰点文库上搜索。
c0de
#include
#include
#defineSTACK_INIT_SIZE100
#defineSTACKINCREMENT10
#defineOVERFLOW-2
#defineOK1
#defineERROR0
typedefintStatus;
typedefintSElemType;
typedefstruct{
SElemType*base;
SElemType*top;
intstacksize;
}SqStack;
StatusDispStack（SqStack&S）{
int*i=S.base;
for（;i!
=S.top;i++）
{
printf（"%d",*i）;
}
return0;
}
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;
returnOK;
}
StatusGetTop（SqStackS,SElemType&e）{
if（S.top==S.base）returnERROR;
e=*（S.top-1）;
returnOK;
}
StatusPush（SqStack&S,SElemTypee）{
if（S.top-S.base>=S.stacksize）{
S.base=（SElemType*）realloc（S.base,（S.stacksize+STACKINCREMENT）*sizeof（SElemType））;
if（!
S.base）exit（OVERFLOW）;
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
returnOK;
}
StatusPop（SqStack&S,SElemType&e）{
if（S.top==S.base）returnERROR;
e=*--S.top;
returnOK;
}
intmain（）{
SqStacks;
InitStack（s）;
inta,i;
SElemTypee=0;
while
（1）{
i=0;
printf（"这有三种操作:
[0]入栈[1]获取栈顶元素[2]出栈\n"）;
printf（"\n请选择想要进行的操作：
"）;
scanf_s（"%d",&a）;
switch（a）{
case0:
i=1;
printf（"请输入PUSH的元素:
"）;
scanf_s（"%d",&e）;
Push（s,e）;
break;
case1:
//if（i==0）{printf（"栈里还没有元素\n"）;break;}
GetTop（s,e）;
printf（"TOP:
%d\n",e）;
break;
case2:
//if（i==0）{printf（"栈里还没有元素\n"）;break;}
printf（"POP:
"）;
Pop（s,e）;
printf（"%d\n",e）;
break;
}
}
}
------------------------------------
#include
#include
#defineSTACK_INIT_SIZE100//定义最初申请的内存的大小]
#defineSTACKINCREMENT10//存储空间分配增量
#defineOK1
#defineERROR0
#defineOVERFLOW-2
typedefintSElemType;
typedefintStatus;
typedefstruct{
SElemType*top;
SElemType*base;
intstacksize;
}SqStack;
/*Init*/
StatusInitStack（SqStack&S）{//构造一个空栈S
//栈底指针S.base指向新分配的STACK_INIT_SIZE个SElemType大小的空间
if（!
（S.base=（SElemType*）malloc（STACK_INIT_SIZE*sizeof（SElemType））））
exit（OVERFLOW）;//存储分配失败
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;//初始栈容量
returnOK;
}
/*GetTop*/
StatusGetTop（SqStackS,SElemType&e）{
if（S.top>S.base）{
e=*（S.top-1）;//因为S.top指向栈顶元素的下一个位置
returnOK;//所以栈顶元素就是e=*（S.top-1）
}
else
returnERROR;
}
/*Push*/
StatusPush（SqStack&S,SElemTypee）{
if（S.top-S.base>=S.stacksize）{//栈满，追加存储空间
S.base=（SElemType*）realloc（S.base,//原栈底指针
（S.stacksize+STACKINCREMENT）*sizeof（SElemType））;//新大小
if（!
S.base）
exit（OVERFLOW）;//存储分配失败
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*（S.top）++=e;//先把e压入栈顶，S.top再增1指向栈顶元素e的下一个位置
returnOK;
}
/*Pop*/
StatusPop（SqStack&S,SElemType&e）{
//若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
if（S.top==S.base）//如果空栈，报错
returnERROR;
e=*--S.top;//S.top先减1指向栈顶元素，再取值，交给e带回
returnOK;
}
/*Judge*/
intIn（charc）{//判断C是否是操作符
switch（c）{
case'+':
case'-':
case'*':
case'/':
case'（':
case'）':
case'#':
returnOK;
break;
default:
returnERROR;
}
}
/*Precede*/
charPrecede（chart1,chart2）{//判断两个运算符的优先级
charf;
switch（t2）{
case'+':
case'-':
if（t1=='（'||t1=='#'）
f='<';
else
f='>';
break;
case'*':
case'/':
if（t1=='*'||t1=='/'||t1=='）'）
f='>';
else
f='<';
break;
case'（':
if（t1=='）'）
{
printf（"ERROR\n"）;
exit（ERROR）;
}
else
f='<';
break;
case'）':
switch（t1）
{
case'（':
f='=';
break;
case'#':
printf（"ERROR\n"）;
exit（ERROR）;
default:
f='>';
}
break;
case'#':
switch（t1）{
case'#':
f='=';
break;
case'（':
printf（"ERROR\n"）;
exit（ERROR）;
default:
f='>';
}
}
returnf;
}
/*Operate*/
intOperate（inta,inttheta,intb）{
intc;
a=a-48;
b=b-48;
switch（theta）
{
case'+':
c=a+b+48;
break;
case'-':
c=a-b+48;
break;
case'*':
c=a*b+48;
break;
case'/':
c=a/b+48;
break;
default:
return0;
}
returnc;
}
/*Main*/
SElemTypeEvaluateExpression（）{//算法3.4
//算术表达式求值的算符优先算法。
设OPTR和OPND分别为运算符栈和运算数栈
SqStackOPTR,OPND;
inta,b,c,x,theta;
InitStack（OPTR）;//构造空栈OPTR，准备装运算符
Push（OPTR,'#'）;//栈OPTR的栈底元素是#
InitStack（OPND）;//构造空栈OPND，准备装操作数
c=getchar（）;
GetTop（OPTR,x）;//取OPTR的栈顶元素交给x
while（c!
='#'||x!
='#'）{
if（In（c））
switch（Precede（x,c））{//比较栈顶元素x、输入字符c的优先权
case'<':
Push（OPTR,c）;//输入字符c入运算符栈OPTR
c=getchar（）;
break;
case'=':
Pop（OPTR,x）;//栈OPTR的栈顶元素出栈，赋给栈顶元素x
c=getchar（）;
break;
case'>':
Pop（OPTR,theta）;//栈顶元素x出运算符栈OPTR，赋给theta
Pop（OPND,b）;//操作数出操作数栈OPND，赋给b
Pop（OPND,a）;//操作数出操作数栈OPND，赋给a
Push（OPND,Operate（a,theta,b））;//运算结果Operate（a,theta,b）入操作数栈OPND
break;
}
elseif（c>='0'&&c<='9'）{//如果c是操作数
Push（OPND,c）;
c=getchar（）;
}
else{//如果c是非法字符
printf（"ERROR\n"）;
exit（ERROR）;
}
GetTop（OPTR,x）;
}//循环结束时，操作数栈OPND的栈顶元素是运算结果
GetTop（OPND,x）;//取操作数栈OPND的栈顶元素赋给x
returnx;
}
intmain（）{
printf（"请输入表达式,以#结束\n"）;
printf（"%c\n",EvaluateExpression（））;//求值
system（"pause"）;
}
------------------------------------
#include
#include
#defineSTACK_INIT_SIZE100
#defineSTACKINCREMENT10
#defineOVERFLOW-2
#defineOK1
#defineERROR0
typedefintStatus;
typedefintQElemType;
typedefstructQNode{
QElemTypedata;
structQNode*next;
}QNode,*QueuePtr;
typedefstruct{
QueuePtrfront;
QueuePtrrear;
}LinkQueue;
StatusDestroyQueue（LinkQueue&Q）{
while（Q.front）{
Q.rear=Q.front->next;
free（Q.front）;
Q.front=Q.rear;
}
returnOK;
}
StatusDispQueue（LinkQueue&Q）{
QueuePtri=Q.front;
while（i!
=Q.rear）{
i=i->next;
printf（"%d",i->data）;
}
returnOK;
}
StatusEnQueue（LinkQueue&Q,QElemTypee）{
QueuePtrp=（QueuePtr）malloc（sizeof（QNode））;
if（!
p）exit（OVERFLOW）;
p->data=e;p->next=NULL;
Q.rear->next=p;
Q.rear=p;
returnOK;
}
StatusDeQueue（LinkQueue&Q,QElemType&e）{
if（Q.front==Q.rear）returnERROR;
QueuePtrp=Q.front->next;
e=p->data;
Q.front->next=p->next;
if（Q.rear==p）Q.rear=Q.front;
free（p）;
returnOK;
}
StatusInitQueue（LinkQueue&Q）{
Q.front=Q.rear=（QueuePtr）malloc（sizeof（QNode））;
if（!
Q.front）exit（OVERFLOW）;
Q.front->next=NULL;
returnOK;
}
intmain（）{
LinkQueuelq;
InitQueue（lq）;
inta;
QElemTypee;
while
（1）{
printf（"\n这有四种操作:
[0]销毁[1]插入[2]删除[3]显示\n"）;
printf（"\n请输入需要的操作:
"）;
scanf_s（"%d",&a）;
switch（a）
{
case0:
DestroyQueue（lq）;
printf（"已成功销毁队列\n再按任意键退出\n"）;
getchar（）;
exit（0）;
break;
case1:
printf（"请输入插入的元素:
"）;
scanf_s（"%d",&e）;
EnQueue（lq,e）;
DispQueue（lq）;
break;
case2:
DeQueue（lq,e）;
DispQueue（lq）;
break;
case3:
printf（"Display:
"）;
DispQueue（lq）;
break;
}
}
}#include
#include
#defineSTACK_INIT_SIZE100
#defineSTACKINCREMENT10
#defineOVERFLOW-2
#defineOK1
#defineERROR0
typedefintStatus;
typedefintQElemType;
typedefstructQNode{
QElemTypedata;
structQNode*next;
}QNode,*QueuePtr;
typedefstruct{
QueuePtrfront;
QueuePtrrear;
}LinkQueue;
StatusDestroyQueue（LinkQueue&Q）{
while（Q.front）{
Q.rear=Q.front->next;
free（Q.front）;
Q.front=Q.rear;
}
returnOK;
}
StatusDispQueue（LinkQueue&Q）{
QueuePtri=Q.front;
while（i!
=Q.rear）{
i=i->next;
printf（"%d",i->data）;
}
returnOK;
}
StatusEnQueue（LinkQueue&Q,QElemTypee）{
QueuePtrp=（QueuePtr）malloc（sizeof（QNode））;
if（!
p）exit（OVERFLOW）;
p->data=e;p->next=NULL;
Q.rear->next=p;
Q.rear=p;
returnOK;
}
StatusDeQueue（LinkQueue&Q,QElemType&e）{
if（Q.front==Q.rear）returnERROR;
QueuePtrp=Q.front->next;
e=p->data;
Q.front->next=p->next;
if（Q.rear==p）Q.rear=Q.front;
free（p）;
returnOK;
}
StatusInitQueue（LinkQueue&Q）{
Q.front=Q.rear=（QueuePtr）malloc（sizeof（QNode））;
if（!
Q.front）exit（OVERFLOW）;
Q.front->next=NULL;
returnOK;
}
intmain（）{
LinkQueuelq;
InitQueue（lq）;
inta;
QElemTypee;
while
（1）{
printf（"\n这有四种操作:
[0]销毁[1]插入[2]删除[3]显示\n"）;
printf（"\n请输入需要的操作:
"）;
scanf_s（"%d",&a）;
switch（a）
{
case0:
DestroyQueue（lq）;
printf（"已成功销毁队列\n再按任意键退出\n"）;
getchar（）;
exit（0）;
break;
case1:
printf（"请输入插入的元素:
"）;
scanf_s（"%d",&e）;
EnQueue（lq,e）;
DispQueue（lq）;
break;
case2:
DeQueue（lq,e）;
DispQueue（lq）;
break;
case3:
printf（"Display:
"）;
DispQueue（lq）;
break;
}
}
}
升级会员 