DataType*s;
};
typedefstructDSeqStack*PDSeqStack;//双端顺序栈类型的指针类型
//创建一个空栈
PDSeqStackcreateEmptyStack_dseq（intn）;
//判断栈是否为空
intisEmptyStack_dseq（PDSeqStackpdstack）;
//进栈（在栈中压入一个元素x）
voidpush_dseq（PDSeqStackpdstack,DataTypex,stringdir）;
//出栈（删除栈顶元素）
voidpop_dseq（PDSeqStackpdstack,stringdir）;
//取栈顶元素（当pastack所指的栈不为空时，求栈顶元素的值）
DataTypetop_dseq（PDSeqStackpdstack,stringdir）;
/*
*算法题：
假设以循环链表表示队列，并且只有一个指针指向队尾元素结点（注意不设队头指针），
*试编写相应的创建空队列、入队列和出队列的算法。
*我又加了取队头元素和判断是否为空队列的算法。
*在出队时候注意一个结点的情况。
*/
structCLinkQueue//循环链表链接队列类型定义
{
PNoder;//尾指针
};
typedefCLinkQueue*PCLinkQueue;//循环链表链接队列类型的指针类型
//创建一个空队列
PCLinkQueuecreateEmptyQueue_clink（）;
//判断循环链表表示队列是否为空队
intisEmptyQueue_clink（PCLinkQueuepclqu）;
//入队
voidenQueue_clink（PCLinkQueuepclqu,DataTypex）;
//出队
voiddeQueue_clink（PCLinkQueuepclqu）;
//取队列头部结点的值
DataTypefrontQueue_clink（PCLinkQueuepclqu）;
/*
*算法题：
假设以数组sequ[m]存放循环队列的元素，
*同时设置变量rear和quelen分别指示循环队列中队尾元素的位置和内含元素个数。
*试给出此循环队列的队满条件，并写出相应的入队列和出队列的算法（在出队列算法中要返回队头元素）。
*/
structASeqQueue
{
intMAXNUM;//队列中最大元素个数
intrear,quelen;
DataType*sequ;
};
typedefASeqQueue*PASeqQueue;//顺序队列类型的指针类型
//创建一个空队列
PASeqQueuecreateEmptyQueue_aseq（intm）;
//判断队列是否为空
intisEmptyQueue_aseq（PASeqQueuepasqu）;
//入队（在队尾插入元素x）
voidenQueue_aseq（PASeqQueuepasqu,DataTypex）;
//出队（删除队列头部元素）
intdeQueue_aseq（PASeqQueuepasqu）;
//取队列的头元素
DataTypefrontQueue_aseq（PASeqQueuepasqu）;
//应用题：
Fibonacci数列的递归及非递归算法。
感觉非递归纯属瞎搞，没啥意思。
intfibRecur（intn）;
intfib（intn）;
//应用题：
Hanoi问题的递归算法，非递归没写，貌似比较麻烦。
voidHanoi（charA,charB,charC,intn）;
//应用题：
后缀表达式求值
intpostExpre（stringstr）;
==============================================
==============================================
StackQueue.cpppart1
==============================================
#include"StackQueue.h"
//算法题：
创建一个空栈
PSeqStackcreateEmptyStack_seq（intm）
{
PSeqStackpastack=（PSeqStack）malloc（sizeof（structSeqStack））;//分配结构SeqStack的存储空间
if（pastack!
=NULL）
{
pastack->s=（DataType*）malloc（sizeof（DataType）*m）;//分配pastack->s的存储空间
if（pastack->s!
=NULL）
{
pastack->MAXNUM=m;
pastack->t=-1;//t初始为-1
return（pastack）;
}
else
free（pastack）;
}
printf（"Outofspace!
\n"）;//存储分配失败
return（NULL）;
}
//算法题：
判断栈是否为空
intisEmptyStack_seq（PSeqStackpastack）
{
if（pastack==NULL||pastack->t==-1）
return
（1）;
else
return（0）;
}
//进栈（在栈中压入一个元素x）
voidpush_seq（PSeqStackpastack,DataTypex）
{
if（pastack->t>=pastack->MAXNUM-1）
printf（"Overflow!
\n"）;
else
{
++pastack->t;
pastack->s[pastack->t]=x;
}
}
//出栈（删除栈顶元素）
voidpop_seq（PSeqStackpastack）
{
if（pastack->t==-1）
printf（"Underflow!
\n"）;
else
--pastack->t;
}
//取栈顶元素（当pastack所指的栈不为空时，求栈顶元素的值）
DataTypetop_seq（PSeqStackpastack）
{
if（pastack->t==-1）
{
printf（"Stackisempty!
\n"）;
return（NULL）;
}
else
return（pastack->s[pastack->t]）;
}
//创建一个空链栈
PLinkStackcreateEmptyStack_link（）
{
PLinkStackplstack;
plstack=（PLinkStack）malloc（sizeof（structLinkStack））;
if（plstack!
=NULL）
plstack->top=NULL;
else
printf（"Outofspace!
\n"）;//创建失败
return（plstack）;
}
//判断单链形式栈是否为空栈
intisEmptyStack_link（PLinkStackplstack）
{
return（plstack->top==NULL）;
}
//进栈（在栈中压入一个元素）
voidpush_link（PLinkStackplstack,DataTypex）
{
PNodep;
p=（PNode）malloc（sizeof（structNode））;
if（p==NULL）
printf（"Outofspace!
\n"）;
else
{
p->info=x;
p->link=plstack->top;
plstack->top=p;
}
}
//出栈
voidpop_link（PLinkStackplstack）
{
PNodep;
if（isEmptyStack_link（plstack））
printf（"Emptystackpop!
\n"）;
else
{
p=plstack->top;
plstack->top=plstack->top->link;
free（p）;
}
}
//取栈顶元素
DataTypetop_link（PLinkStackplstack）
{
if（plstack->top==NULL）
{
printf（"Stackisempty!
\n"）;
return（NULL）;
}
else
return（plstack->top->info）;
}
//创建一个空队列
PSeqQueuecreateEmptyQueue_seq（intm）
{
PSeqQueuepaqu=（PSeqQueue）malloc（sizeof（structSeqQueue））;//分配结构SeqQueue的存储空间
if（paqu!
=NULL）
{
paqu->q=（DataType*）malloc（sizeof（DataType）*m）;//分配paqu->q的存储空间
if（paqu->q!
=NULL）
{
paqu->MAXNUM=m;
paqu->f=0;//f、r初始为
paqu->r=0;
return（paqu）;
}
else
free（paqu）;
}
printf（"Outofspace!
\n"）;//存储分配失败
return（NULL）;
}
//判断队列是否为空
intisEmptyQueue_seq（PSeqQueuepaqu）
{
return（paqu->f==paqu->r）;
}
//入队（在队尾插入元素x）
voidenQueue_seq（PSeqQueuepaqu,DataTypex）
{
if（（paqu->r+1）%paqu->MAXNUM==paqu->f）
printf（"Fullqueue!
\n"）;
else
{
paqu->q[paqu->r]=x;
paqu->r=（paqu->r+1）%paqu->MAXNUM;
}
}
//出队（删除队列头部元素）
voiddeQueue_seq（PSeqQueuepaqu）
{
if（paqu->f==paqu->r）
printf（"EmptyQueue!
\n"）;
else
paqu->f=（paqu->f+1）%paqu->MAXNUM;
}
//取队列的头元素
DataTypefrontQueue_seq（PSeqQueuepaqu）
{
if（paqu->f==paqu->r）
{
printf（"EmptyQueue!
\n"）;
return（NULL）;
}
else
return（paqu->q[paqu->f]）;
}
//创建一个空队列
PLinkQueuecreateEmptyQueue_link（）
{
PLinkQueueplqu;
plqu=（PLinkQueue）malloc（sizeof（structLinkQueue））;
if（plqu!
=NULL）
{
plqu->f=NULL;
plqu->r=NULL;
}
else
printf（"Outofspace!
\n"）;
return（plqu）;
}
//判断链接表示队列是否为空队
intisEmptyQueue_link（PLinkQueueplqu）
{
return（plqu->f==NULL）;
}
//入队
voidenQueue_link（PLinkQueueplqu,DataTypex）
{
PNodep;
p=（PNode）malloc（sizeof（structNode））;//申请新结点空间
if（p==NULL）
printf（"Outofspace!
\n"）;//申请新结点失败
else
{
p->info=x;//填写新结点信息
p->link=NULL;
if（plqu->f==NULL）//插入前是空队列
plqu->f=p;
else
plqu->r->link=p;//将新结点插入
plqu->r=p;//修改队尾指针
}
}
//出队
voiddeQueue_link（PLinkQueueplqu）
{
PNodep;
if（plqu->f==NULL）//队列已空
printf（"Emptyqueue!
\n"）;
else
{
p=plqu->f;
plqu->f=p->link;//修改队头指针
free（p）;//释放已删除结点空间
}
}
//取队列头部结点的值
DataTypefrontQueue_link（PLinkQueueplqu）
{
if（plqu->f==NULL）//队列已空
{
printf（"Emptyqueue!
\n"）;
return（NULL）;
}
else
return（plqu->f->info）;
}
//算法题：
写一个递归算法把整数字符串转换为整数
intcharToInt（char*pChar,intlen）//len为数组中最后一个元素的下标
{
if（len==0）//递归到第一个元素，直接返回数
return（pChar[len]-'0'）;
if（pChar[len]-'0'<0||pChar[len]-'0'>9）//元素要在与之间
{
printf（"Inputarrayisnotanumberarray.\n"）;
return（-1）;
}
return（charToInt（pChar,len-1）*10+pChar[len]-'0'）;//递归调用
}
//算法题：
编写一个算法，对于输入的十进制整数，将它的二进制表示打印出来
voiddecToBinary（intx）
{
PLinkStackplstack=createEmptyStack_link（）;//用栈来存储余数
if（x<0）
x=-x;
for（inti=x;i!
=0;i/=2）
push_link（plstack,i%2）;//余数进栈
while（!
isEmptyStack_link（plstack））
{
x=top_link（plstack）;//取栈顶元素，打印，出栈
printf（"%d",x）;
pop_link（plstack）;
}
printf（"\n"）;
}
//算法题：
写一个算法从一个栈创建一个队列，使栈顶为队列的头，栈底为队列的尾，算法的最后要求使栈成为空栈
PLinkQueuestackToQueue（PLinkStackplstack）
{
PLinkQueueplqu=createEmptyQueue_link（）;
DataTypei;
while（!
isEmptyStack_link（plstack））
{
i=top_link（plstack）;
enQueue_link（plqu,i）;
pop_link（plstack）;
}
return（plqu）;
}
//算法题：
写一个算法从一个队列创建一个栈，使队列的头为栈顶，队列的尾为栈底，算法的最后要求使队列保持不变
PLinkStackqueueToStack（PLinkQueueplqu）
{
PLinkStackplstack=createEmptyStack_link（）;
PLinkStackplstackA=createEmptyStack_link（）;
PLinkQueueplquA=createEmptyQueue_link（）;
DataTypei;
while（!
isEmptyQueue_link（plqu））
{
i=frontQueue_link（plqu）;//取队列plqu头元素i并出队
deQueue_link（plqu）;
enQueue_link（plquA,i）;//将i在plquA入队
push_link（plstackA,i）;//将i入栈plstackA
}
while（!
isEmptyStack_link（plstackA））//将plstackA的元素依次出栈并入plstack栈
{
i=top_link（plstackA）;
pop_link（plstackA）;
push_link（plstack,
升级会员 