内容:
1)编程实现栈的以下基本操作:建栈,取栈顶元素,入栈,出栈
2)编程实现队列的以下基本操作:建队列,取队头元素,入队,出队
实现思路:
① 编写顺序栈的操作。定义顺序栈的数据类型,实现顺序栈初始化、入栈、出栈、取栈顶元素函数
② 编写链栈的操作。定义链栈的数据类型,实现链栈初始化、入栈、出栈、取栈顶元素函数
③ 编写循环队列的操作。定义循环队列数据类型,实现循环队列初始化、求数列长度、入队、出队、取循环队列的队头元素函数。
④ 编写链式队列的操作。定义链式队列数据类型,实现循环队列初始化、入队、出队、取链式队列的队头元素函数。
⑤ 出栈、出队、取栈顶元素、取队头元素记得判空;入栈、入队记得判断是否满。
1、顺序栈
#include <iostream>
using namespace std;
#define MAXSIZE 100 //顺序栈存储空间的初始配量
#define OK 1
#define ERROR 0
typedef int SElemType;
typedef struct
{
SElemType *base; //栈底指针
SElemType *top; //栈顶指针
int stacksiza; //栈可用的最大容量
}SqStack;
int InitStack(SqStack &S) //栈的初始化
{
S.base=new SElemType[MAXSIZE];
if(!S.base)
return ERROR;
S.top=S.base;
S.stacksiza=MAXSIZE;
return OK;
}
int Push(SqStack &S,SElemType e) //入栈
{
if(S.top-S.base==S.stacksiza)
return ERROR;
//*S.top++=e;
*S.top=e;
S.top++;
return OK;
}
int Pop(SqStack &S,SElemType &e) //出栈
{
if(S.top==S.base)
return ERROR;
//e=*--S.top;
S.top--;
e=*S.top;
return OK;
}
SElemType GetTop(SqStack S) //取栈顶元素
{
if(S.base!=S.top)
return *(S.top-1);
return NULL;
}
int main()
{
SqStack S;
cout<<"0 初始化栈"<<endl;
cout<<"1 入栈"<<endl;
cout<<"2 出栈"<<endl;
cout<<"3 取栈顶元素"<<endl;
cout<<" 输入负数退出"<<endl;
while(1)
{
int ip;
cout<<endl;
cout<<endl;
cout<<"============================"<<endl;
cout<<"请输入操作指令:"<<endl;
cin>>ip;
if(ip<0)
break;
else
{
switch(ip)
{
case 0:
{
int flag=InitStack(S);
if(flag)
cout<<"初始化成功!"<<endl;
else
cout<<"初始化失败!"<<endl;
break;
}
case 1:
{
SElemType e;
cout<<"请输入入栈元素:";
cin>>e;
int flag=Push(S,e);
if(flag)
cout<<"元素入栈成功!"<<endl;
else
cout<<"栈元素已满,入栈失败!"<<endl;
break;
}
case 2:
{
SElemType e;
int flag=Pop(S,e);
if(flag)
cout<<"元素出栈成功,出栈元素为:"<<e<<endl;
else
cout<<"空栈,出栈失败!"<<endl;
break;
}
case 3:
{
SElemType e=NULL;
e=GetTop(S);
if(e==NULL)
cout<<"空栈,获取栈顶元素失败!"<<endl;
else
cout<<"栈顶元素为:"<<e<<endl;
break;
}
default:
{
cout<<"操作指令不合法!请重新输入!"<<endl;
break;
}
}
}
}
return 0;
}
2、循环队列
#include <iostream>
using namespace std;
#define MAXQAIZE 100 //队列可能达到的最大长度
typedef int QElemType;
typedef struct
{
QElemType *base; //存储空间的基地址
int front; //头指针
int rear; //尾指针
}SqQueue;
int InitQueue(SqQueue &Q) //初始化
{
Q.base=new QElemType[MAXQAIZE]; //为队列分配一个最大容量为MAXQSIZE的数组空间
if(!Q.base)
return 0;//存储分配失败
Q.front=Q.rear=0; //头指针尾指针置为零,队列为空
return 1;
}
int QueueLength(SqQueue Q) //求数列长度
{
return (Q.rear-Q.front+MAXQAIZE)%MAXQAIZE;
}
int EnQueue(SqQueue &Q,QElemType e) //入队
{
if((Q.rear+1)==Q.front) //谓之神在循环意义上加1后等于头指针,表明队满
return 0;
Q.base[Q.rear]=e; //新元素插入队尾
Q.rear=(Q.rear+1)%MAXQAIZE; //尾指针后移一位
return 1;
}
int DeQueue(SqQueue &Q,QElemType &e) //出队
{
if((Q.rear)==Q.front) //判读队空
return 0;
e=Q.base[Q.front]; //保存队头元素
Q.front=(Q.front+1)%MAXQAIZE; //队头指针后移一位
return 1;
}
QElemType GetHead(SqQueue Q) //取循环队列的队头元素
{
if(Q.front!=Q.rear) //队列非空
return Q.base[Q.front]; //返回队头元素的值,队头指针不变
return NULL;
}
int main()
{
SqQueue Q;
cout<<"0 初始化队列"<<endl;
cout<<"1 入队"<<endl;
cout<<"2 出队"<<endl;
cout<<"3 取队列的对头元素"<<endl;
cout<<" 输入负数退出"<<endl;
while(1)
{
int ip;
cout<<endl;
cout<<endl;
cout<<"============================"<<endl;
cout<<"请输入操作指令:"<<endl;
cin>>ip;
if(ip<0)
break;
else
{
switch(ip)
{
case 0:
{
int flag=InitQueue(Q);
if(flag)
cout<<"初始化成功!"<<endl;
else
cout<<"初始化失败!"<<endl;
break;
}
case 1:
{
QElemType e;
cout<<"请输入入队的元素:";
cin>>e;
int flag=EnQueue(Q,e);
if(flag)
cout<<"元素入队成功!"<<endl;
else
cout<<"队列已满,入队失败!"<<endl;
break;
}
case 2:
{
QElemType e;
int flag=DeQueue(Q,e);
if(flag)
cout<<"元素出队成功,出队元素为:"<<e<<endl;
else
cout<<"空队,出队失败!"<<endl;
break;
}
case 3:
{
QElemType e=NULL;
e=GetHead(Q);
if(e==NULL)
cout<<"空队,获取对头元素失败!"<<endl;
else
cout<<"对头元素为:"<<e<<endl;
break;
}
default:
{
cout<<"操作指令不合法!请重新输入!"<<endl;
break;
}
}
}
}
return 0;
}
3、链栈
#include <iostream>
using namespace std;
#define OK 1
#define ERROR 0
typedef int ElemType;
typedef struct StackNode //链栈的存储结构
{
ElemType data;
struct StackNode *next;
}StackNode,*LinkStack;
void InitStack(LinkStack &S) //链栈的初始化
{
S=NULL;
}
void Push(LinkStack &S,ElemType e)
{
StackNode *p=new StackNode;
p->data=e;
p->next=S;
S=p;
}
int Pop(LinkStack &S,ElemType &e)
{
if(S==NULL)
return ERROR;
e=S->data;
StackNode *p=S;
S=S->next;
delete p;
return OK;
}
ElemType GetTop(LinkStack S)
{
if(S==NULL)
return NULL;
else
return S->data;
}
int main()
{
LinkStack S;
cout<<"0 初始化栈"<<endl;
cout<<"1 入栈"<<endl;
cout<<"2 出栈"<<endl;
cout<<"3 取栈顶元素"<<endl;
cout<<" 输入负数退出"<<endl;
while(1)
{
int ip;
cout<<endl;
cout<<endl;
cout<<"============================"<<endl;
cout<<"请输入操作指令:"<<endl;
cin>>ip;
if(ip<0)
break;
else
{
switch(ip)
{
case 0:
{
InitStack(S);
cout<<"初始化成功!"<<endl;
break;
}
case 1:
{
ElemType e;
cout<<"请输入入栈元素:";
cin>>e;
Push(S,e);
cout<<"元素入栈成功!"<<endl;
break;
}
case 2:
{
ElemType e;
int flag=Pop(S,e);
if(flag)
cout<<"元素出栈成功,出栈元素为:"<<e<<endl;
else
cout<<"空栈,出栈失败!"<<endl;
break;
}
case 3:
{
ElemType e=NULL;
e=GetTop(S);
if(e==NULL)
cout<<"空栈,获取栈顶元素失败!"<<endl;
else
cout<<"栈顶元素为:"<<e<<endl;
break;
}
default:
{
cout<<"操作指令不合法!请重新输入!"<<endl;
break;
}
}
}
}
return 0;
}
4、链式队列
#include <iostream>
using namespace std;
typedef int QElemType;
typedef struct QNode
{
QElemType data;
struct QNode *next;
}QNode, *QueuePtr;
typedef struct
{
QueuePtr front;
QueuePtr rear;
}LinkQueue;
void InitQueue(LinkQueue &Q) //链队的初始化
{
Q.front=Q.rear=new QNode; //生成新节点作为头节点,对头和队尾指针指向此节点
Q.front->next=NULL; //头节点的指针域置空
}
int EnQueue(LinkQueue &Q,QElemType e) //入队
{
QNode *p=new QNode;
p->data=e;
p->next=NULL;
Q.rear->next=p;
Q.rear=p;
return 1;
}
int DeQueue(LinkQueue &Q,QElemType &e) //出队
{
if(Q.front==Q.rear) //判断队空
return 0;
QNode *p=Q.front->next; //p指向队头元素
e=p->data; //e保存队头元素的值
Q.front->next=p->next; //修改头节点的指针域
if(Q.rear==p) //最后一个元素怒被删,队尾指针指向头节点
Q.rear=Q.front;
delete p;
return 1;
}
QElemType GetHead(LinkQueue Q)
{
if(Q.front==Q.rear)
return NULL;
else
return Q.front->next->data;
}
int main()
{
LinkQueue Q;
cout<<"0 初始化队列"<<endl;
cout<<"1 入队"<<endl;
cout<<"2 出队"<<endl;
cout<<"3 取队列的对头元素"<<endl;
cout<<" 输入负数退出"<<endl;
while(1)
{
int ip;
cout<<endl;
cout<<endl;
cout<<"============================"<<endl;
cout<<"请输入操作指令:"<<endl;
cin>>ip;
if(ip<0)
break;
else
{
switch(ip)
{
case 0:
{
InitQueue(Q);
cout<<"初始化成功!"<<endl;
break;
}
case 1:
{
QElemType e;
cout<<"请输入入队的元素:";
cin>>e;
int flag=EnQueue(Q,e);
if(flag)
cout<<"元素入队成功!"<<endl;
else
cout<<"队列已满,入队失败!"<<endl;
break;
}
case 2:
{
QElemType e;
int flag=DeQueue(Q,e);
if(flag)
cout<<"元素出队成功,出队元素为:"<<e<<endl;
else
cout<<"空队,出队失败!"<<endl;
break;
}
case 3:
{
QElemType e=NULL;
e=GetHead(Q);
if(e==NULL)
cout<<"空队,获取对头元素失败!"<<endl;
else
cout<<"对头元素为:"<<e<<endl;
break;
}
default:
{
cout<<"操作指令不合法!请重新输入!"<<endl;
break;
}
}
}
}
return 0;
}