【C++】栈和队列

顺序栈

#include <iostream>
#include <stdlib.h>
using namespace std;
#define MAXSIZE 100    //顺序栈初始化时分配的存储空间长度

typedef struct{
	char *base;   //栈底指针,栈中元素为字符
	char *top;    //栈顶指针
	int stacksize;   //栈可用的最大容量
}SqStack;       //顺序栈结构


//初始化顺序栈S
void InitStack(SqStack &S)
{
	S.base  =(char *)malloc(MAXSIZE*sizeof(char));   //为S分配存储空间,也可以使用下面注释掉的语句
	//S.base =new char[MAXSIZE];
	if(!S.base) exit(-1);
	S.top  =S.base ;        //空栈时，s.top和s.base均指向栈底
	S.stacksize =MAXSIZE;   //初始化栈的最大容量为MAXSIZE
}


//入栈操作，向顺序栈S的栈顶处插入新元素e，插入成功，返回true,插入失败，返回false
bool Push(SqStack &S, char e)
{
	//请同学们在此处把该操作补充完整，并调试
	if(S.top-S.base==S.stacksize) return false;
	
	*(S.top++)=e;
	return true;

}

//出栈操作，删除顺序栈S的栈顶元素，被删元素用参数e返回，删除成功，函数返回true,删除失败，函数返回false
bool Pop(SqStack &S,char &e)
{
	//请同学们在此处把该操作补充完整，并调试
	if(S.top==S.base) return false;
	
	e=*(S.top-1);
	S.top--;
	return true;
}

//取顺序栈S的栈顶元素，用参数e返回取得的栈顶元素
bool GetTop(SqStack S,char &e)
{
	//请同学们在此处把该操作补充完整，并调试
	if(S.top==S.base) return false;
	
	e=*(S.top-1);
	return true;
}

//求顺序栈S的长度
int StackLength(SqStack S)
{
	//请同学们在此处把该操作补充完整，并调试
	return S.top-S.base;
}

//输出顺序栈S中的元素（从栈顶到栈顶的顺序输出）
void PrintStack(SqStack S)
{
	char *p;   
	for(p=S.base ;p<S.top ;p++)   //用指针p依次指向栈中的元素，将其输出
	{
		cout<<*p<<"  ";   //元素之间用两个空格分隔
	}
	cout<<endl;
}

//操作菜单
void showmenu()
{	
	cout<<"*****************************************************************"<<endl;
	cout<<"1、入栈          2、出栈         3、输出栈中元素"<<endl;
	cout<<"4、取栈顶元素    5、退出"<<endl;
}


int main()
{
	SqStack S;       //定义顺序栈变量S
	int k; 
	char e;
	bool flag;
	InitStack(S);    //初始化顺序栈S
	cout<<"顺序栈S初始化成功"<<endl;

	//循环显示菜单，完成顺序栈的一系列操作
	do{
		showmenu();    
		cout<<"请选择要执行的操作序号"<<endl;
		cin>>k;    //k表示用户选择的操作序号
		switch(k)
		{
		case 1:    //执行入栈操作
			cout<<"请输入入栈元素的值"<<endl;
			cin>>e;      //输入要插入到栈顶处的值
			flag=Push(S,e);   //执行入栈操作，,flag表示入栈操作结果，或为true,或为false
			if(flag)       //若入栈操作成功
				cout<<"入栈操作成功"<<endl;
			else
				cout<<"栈已满，入栈操作失败！"<<endl;
			break;
		case 2:   //执行出栈操作
			flag=Pop(S,e);     //执行出栈操作，被删栈顶元素的值用e返回，flag表示出栈操作结果，或为true,或为false
			if(flag)       //若出栈操作成功
				cout<<"出栈操作成功，被删栈顶元素为："<<e<<endl;  //输出被删栈顶元素的值
			else
				cout<<"栈已空，不能执行出栈操作！"<<endl;
			break;
		case 3:   //输出顺序栈的长度及栈中的元素
			cout<<"当前栈的长度为："<<StackLength(S)<<",栈中元素为（从栈底到栈顶方向）："<<endl;
			PrintStack(S);      //输出循环队列Q中的元素
			break;

		case 4:    //输出栈顶元素
			if(GetTop(S,e))
				cout<<"栈顶元素为："<<e<<endl;
			else
				cout<<"栈已空，没有栈顶元素"<<endl;
			break;
		
		}//switch

	}while(k<5);
	
	return 0;
}

循环队列

主要完成循环队列基本操作的实现，循环队列中的元素类型为字符型（char）
需要实现的基本操作为：

1. 循环队列的初始化
2. 入队操作
3. 出队操作
4. 取队头元素
5. 取队尾元素
6. 求循环队列的长度
7. 输出循环队列中的元素

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
using namespace std;
#define MAXSIZE 5    //循环队列初始化时分配的存储空间长度
typedef struct{
	char *base;   //存储空间基址，队列中存储的元素是字符
	int front;    //队头指针
	int rear;   //队尾指针
}SqQueue;       //循环队列结构

//初始化循环队列Q
void InitQueue(SqQueue &Q)
{
	Q.base=new char[MAXSIZE];
	if(!Q.base) exit(-1);
	Q.front=Q.rear=0;
	
}

//入队操作，向循环队列Q的队尾插入新元素e，插入成功，返回true,插入失败，返回false
bool EnQueue(SqQueue &Q, char e)
{
  if((Q.rear+1)%MAXSIZE==Q.front)
    return false;
    else{
		Q.base[Q.rear]=e;
    	Q.rear=(Q.rear+1)%MAXSIZE;
		return true;
	}
	

}

//出队操作，删除循环队列Q的队头元素，被删元素用参数e返回，删除成功，函数返回true,删除失败，函数返回false
bool DeQueue(SqQueue &Q,char &e)
{
	if(Q.front==Q.rear)
	return false;
	else
	{
		e=Q.base[Q.front];
		Q.front=(Q.front+1)%MAXSIZE;
    	return true;
	}
}

//取循环队列Q的队头元素，用参数e返回取得的队头元素
bool GetHead(SqQueue Q,char &e)
{
   if(Q.rear==Q.front)
   return false;
   else
   {
		e=Q.base[Q.front];
    	return true;
   }
	
}

//取循环队列Q的队尾元素，用参数e返回取得的队尾元素
bool GetTail(SqQueue Q,char &e)
{
   if(Q.rear==Q.front)
    	return false;
   else
   {
		e=Q.base[(Q.rear-1+MAXSIZE)%MAXSIZE];
		return true;
   }
}


//输出循环队列Q中的元素（从队头到队尾的顺序输出）
void PrintQueue(SqQueue Q)
{
	if(Q.rear==Q.front)
	cout<<" 队列为空 "<<endl;
	else if(Q.rear>Q.front)
		for(int t=Q.front;t<=Q.rear;t++)
        	cout<<Q.base[t]<<"  ";
    else for(int t=Q.front;t!=Q.rear;t=(t+1)%MAXSIZE)
       	cout<<Q.base[t]<<"  ";
 } 
    


//求循环队列Q的长度
int QueueLength(SqQueue Q)
{
	
	int length;
	
	if(Q.rear>Q.front)
		length=Q.rear-Q.front;
	else if(Q.rear<Q.front)
	{
		length=MAXSIZE-(Q.front-Q.rear);
	}
	else length=0;
	return length;
}

//操作菜单
void showmenu()
{	
	cout<<"*****************************************************************"<<endl;
	cout<<"1、入队          2、出队         3、输出队列元素"<<endl;
	cout<<"4、取队头元素    5、取队尾元素   6、退出"<<endl;
}

int main()
{
	SqQueue Q;       //定义循环队列Q
	int k; 
	char e;
	bool flag;
	InitQueue(Q);    //初始化循环队列Q
	cout<<"循环队列Q初始化成功"<<endl;
	
	//循环显示菜单，完成循环队列的一系列操作
	do{
		showmenu();    
		cout<<"请选择要执行的操作序号"<<endl;
		rewind(stdin);
		cin>>k;    //k表示用户选择的操作序号
		switch(k)
		{
		case 1:    //执行入队操作
			cout<<"请输入入队元素的值"<<endl;
			cin>>e;      //输入要插入到队尾处的值
			flag=EnQueue(Q,e);   //执行入队操作，,flag表示入栈操作结果，或为true,或为false
			if(flag)       //若入队操作成功
				cout<<"入队操作成功"<<endl;
			else
				cout<<"队列已满，入队操作失败！"<<endl;
			break;
		case 2:   //执行出队操作
			flag=DeQueue(Q,e);     //执行出队操作，被删队头元素的值用e返回，flag表示出栈操作结果，或为true,或为false
			if(flag)       //若出队操作成功
				cout<<"出队操作成功，被删队头元素为："<<e<<endl;  //输出被删队头元素的值
			else
				cout<<"队列已空，不能执行出队操作！"<<endl;
			break;
		case 3:   //输出队列的长度及队列中的元素
			cout<<"当前队列长度为："<<QueueLength(Q)<<",队中元素为（从队头到队尾方向）："<<endl;
			PrintQueue(Q);
			cout<<endl;      //输出循环队列Q中的元素
			break;

		case 4:    //输出队头元素
			if(GetHead(Q,e))
				cout<<"队头元素为："<<e<<endl;
			else
				cout<<"当前队列为空队列，没有队头元素"<<endl;
			break;
		case 5:   //输出队尾元素
			if(GetTail(Q,e))
				cout<<"队尾元素为："<<e<<endl;
			else
				cout<<"当前队列为空队列，没有队尾元素"<<endl;
			break;
		}//switch

	}while(k<6);	
	return 0;
}