队列和栈的结构

henu队列

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define OK 1
#define False 0
#define True 1
#define Error 0
using namespace std;
typedef int QElemType;
typedef int Status;
typedef struct QNode {
	QElemType data;
	struct QNode* next;
}QNode, * QueuePtr;

typedef struct {
	QueuePtr front;//队头指针 
	QueuePtr rear;//队尾指针 
}LinkQueue;
Status InitQueue(LinkQueue* Q) {
	Q->front = Q->rear = (QueuePtr)malloc(sizeof(QNode));
	if (!Q->front) exit(OVERFLOW);
	Q->front->next = NULL;
	Q->rear->next = NULL;
	return OK;


}
Status DestroyQueue(LinkQueue* Q) {
	while (Q->front) {//从头节点开始向后删除 
		Q->rear = Q->front->next;
		Q->front->data = 0;
		free(Q->front);
		Q->front = Q->rear;
	}
	return OK;
}

Status ClearQueue(LinkQueue* Q) {
	QueuePtr tmp = Q->front;
	Q->front = Q->front->next;
	while (Q->front)
	{
		Q->rear = Q->front->next;
		Q->front->data = 0;
		free(Q->front);
		Q->front = Q->rear;
	}
	Q->front = Q->rear = tmp;
	return  OK;
}
Status QueueEmpty(LinkQueue Q) {
	if (Q.front == Q.rear)
		return True;
	else
		return False;
}

Status GetHead(LinkQueue Q, QElemType* e) {//若队列不空，用e返回队头元素 
	if (Q.front == Q.rear)
		return Error;
	*e = Q.front->next->data;
	return OK;
}
int QueueLength(LinkQueue Q) {
	int length = 0;
	while (Q.front != Q.rear) {
		Q.front = Q.front->next;
		length++;
	}
	return length;
}
Status EnQueue(LinkQueue* Q, QElemType e) {
	QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
	
	if (!p)
		exit(OVERFLOW);
	p->data = e;
	p->next = NULL;
	Q->rear->next = p;
	Q->rear = p;
	return OK;

}//插入元素e为新的队尾元素 

Status DeQueue(LinkQueue* Q, QElemType* e) {//从队头删除一个元素，用e返回 
	if (Q->front == Q->rear)//空队的话无法删除 
		return Error;
	QueuePtr p;
	p = Q->front->next;//p指向队头元素 
	*e = p->data;
	p->data = 0;
 
	if (Q->front->next == Q->rear) {//如果只有一个队内元素的话（除去头节点），删除后为空队 
		Q->rear = Q->front;
		Q->front->next = Q->front->next->next;
	}
	else
	{
		Q->front->next = Q->front->next->next;//p指向的队头元素将被删除，所以原队头指针指向下一个元素 
	}
	free(p);
	return OK;
}
Status visit(LinkQueue Q) {
	while (Q.front != Q.rear) {
		printf("%d\n", Q.front->next->data);
		Q.front = Q.front->next;
	}
	return OK;
}
Status QueueTraverse(LinkQueue Q) {
	visit(Q);
	return OK;
}

int main() {
	LinkQueue Q;
	

	cout << "1.初始化队列" << endl;
	cout << "2.销毁队列" << endl;
	cout << "3.清空队列" << endl;
	cout << "4.队列判空" << endl;
	cout << "5.求队列长度" << endl;
	cout << "6.获取队头元素" << endl;
	cout << "7.插入一个元素" << endl;
	cout << "8.删除一个元素" << endl;
	cout << "9.输出所有元素" << endl;

	cout << "☆☆☆退出，输入一个负数！☆☆☆" << endl;
	int n;
	do {
		cout << "请输入您的选择：";
		cin >> n;
		switch (n)
		{
		case 1:	InitQueue(&Q);
			cout << "初始化成功" << endl; break;
		case 2:DestroyQueue(&Q);
			cout << "销毁成功" << endl;
			break;
		case 3:ClearQueue(&Q);
			cout << "清空成功" << endl;
			break;
		case 4:QueueEmpty(Q);
			if (QueueEmpty(Q) == 1) {
				cout << "队列为空" << endl;
			}
			else {

				cout << "队列不为空" << endl;
			}
			break;
		case 5:

			cout << "长度为：" << QueueLength(Q) << endl;
			break;
		case 6:int elem5;
			GetHead(Q, &elem5);
			cout << "队列头为：" << elem5 << endl;
			break;
		case 7:int elem;
			cin >> elem;
			EnQueue(&Q, elem);
			cout << "队列成功插入" << endl;
			break;
		case 8:int elem4;
			DeQueue(&Q, &elem4);
			cout << "队列成功删除" << endl;
			break;
		case 9:	QueueTraverse(Q); break;
		}
	} while (n != -1);
	return 0;
}

栈

#include<iostream>
#include<stdlib.h>
#define stack_init_size 20
#define stackincrement 10
typedef int elemtype;
using namespace std;

typedef struct {
	elemtype* base;
	elemtype* top;
	int stacksize;
}stack;
void initstack(stack& s) {
	s.base = (elemtype*)malloc(stack_init_size*sizeof(elemtype));
	s.top = s.base;
	s.stacksize = stack_init_size;
}//1.初始化栈
void destroystack(stack& s) {
	{
		s.stacksize = 0;
		s.base = NULL;
		s.top = NULL;
		free(s.base);
		free(s.top);
	}
}//2.销毁栈
void clearstack(stack& s) {
	s.stacksize = 0;
	s.top = s.base;
}//3.清空栈
int stackempty(stack s) {
	if(s.base == s.top)
	{
		return 0;//栈为空。 
	}
	else
	{
	return 1;//栈不为空。 
	}
}//4.栈判空
int stacklength(stack s) {
	elemtype* p = s.top;
	int i = 0;
	while (s.top!=s.base)
	{
		p--;
		i++;
	}
	return i;
}//5.求栈长度
elemtype gettop(stack s) {
	return *(s.top - 1);
}//6.获取栈顶元素
void push(stack& s, elemtype e) {
	*s.top = e;
	s.top++;
}//7.插入一个元素
elemtype pop(stack& s) {
	s.top--;
	return *s.top;
}//8.删除一个元素
elemtype stackvisit(stack& s, int i) {
	elemtype* p = s.top;
	while (p!=s.base)
	{
		p--;
		cout << *p << " ";
	}
	return *p;
}//9.输出所有元素
//void conversion(stack& jinzhi, int choose, int num);//10.进制转换
int main() {
	stack zhan;
	zhan.base = NULL;
	zhan.top = NULL;
	elemtype yuansu;

	int in = 1;
	cout << endl;
	cout << "☆☆☆欢迎使用顺序栈小程序！☆☆☆" << endl;
	cout << "author---henan university.software engineering." << endl << endl;
	while (in == 1)
	{
		cout << "1.初始化栈" << endl;
		cout << "2.销毁栈" << endl;
		cout << "3.清空栈" << endl;
		cout << "4.栈判空" << endl;
		cout << "5.求栈长度" << endl;
		cout << "6.获取栈顶元素" << endl;
		cout << "7.插入一个元素" << endl;
		cout << "8.删除一个元素" << endl;
		cout << "9.输出所有元素" << endl;
		cout << "10.进制转换" << endl;
		cout << "☆☆☆退出，输入一个负数！☆☆☆" << endl;
		int select;
		cout << "请输入您的选择：";
		cin >> select;
		switch (select)
		{
		case 1://1.初始化栈.
			system("cls");
			initstack(zhan);
			if (!zhan.base)
			{
				cout << "存储空间分配失败，请重新操作！" << endl;
			}
			else
			{
				cout << "您已经成功初始化一个栈!" << endl;
			}
			cout << endl;
			break;
		case 2://2.销毁栈
			system("cls");
			if (zhan.base == NULL)
			{
				cout << "还未初始化栈，请您先初始化！" << endl;
			}
			else
			{
				destroystack(zhan);
				cout << "您已成功销毁栈！" << endl;
			}
			cout << endl;
			break;
		case 3://3.清空栈
			system("cls");
			if (zhan.base == NULL)
			{
				cout << "还未初始化栈，请您先初始化！" << endl;
			}
			else
			{
				if (zhan.base == zhan.top)
				{
					cout << "栈为空，不用清空！" << endl;
				}
				else
				{
					clearstack(zhan);
					cout << "已经成功清空栈！" << endl;
				}
			}
			cout << endl;
			break;
		case 4://4.栈判空
			system("cls");
			if (zhan.base == NULL)
			{
				cout << "还未初始化栈，请您先初始化！" << endl;
			}
			else
			{
				if (stackempty(zhan) == 0)
				{
					cout << "栈为空！" << endl;
				}
				else
				{
					cout << "栈不为空！" << endl;
				}
			}
			cout << endl;
			break;
		case 5://5.求栈长度
			system("cls");
			if (zhan.base == NULL)
			{
				cout << "还未初始化栈，请您先初始化！" << endl;
			}
			else
			{
				cout << "栈的长度为：" << stacklength(zhan) << endl;
			}
			cout << endl;
			break;
		case 6://6.获取栈顶元素
			system("cls");
			if (zhan.base == NULL)
			{
				cout << "还未初始化栈，请您先初始化！" << endl;
			}
			else
			{
				if (zhan.base == zhan.top)
				{
					cout << "这是一个空栈，不存在元素！" << endl;
				}
				else
				{
					cout << "栈顶元素为：" << gettop(zhan) << endl;
				}
			}
			cout << endl;
			break;
		case 7://7.插入一个元素
			system("cls");
			if (zhan.base == NULL)
			{
				cout << "还未初始化栈，请您先初始化！" << endl;
			}
			else
			{
				cout << "请输入您要插入的元素：";
				cin >> yuansu;
				if (zhan.top - zhan.base >= zhan.stacksize)//栈满，追加存储空间。 
				{
					//zhan.base = (elemtype*)realloc(zhan.base, (zhan.stacksize + stackincrement) * sizeof(elemtype));
					if (!zhan.base) {
						cout << "存储空间分配失败！请重新操作。" << endl;
					}
					else
					{
						zhan.top = zhan.base + zhan.stacksize;
						zhan.stacksize += stackincrement;
						cout << "内存空间分配成功！" << endl;
					}
				}
				push(zhan, yuansu);
				cout << "入栈成功！" << endl;
			}
			cout << endl;
			break;
		case 8://8.删除一个元素
			system("cls");
			if (zhan.base == NULL)
			{
				cout << "还未初始化栈，请您先初始化！" << endl;
			}
			else
			{
				if (zhan.base == zhan.top)
				{
					cout << "栈为空，没有元素可以出栈！" << endl;
				}
				else
				{
					cout << "元素" << pop(zhan) << "出栈成功！" << endl;
				}
			}
			cout << endl;
			break;
		case 9://9.输出所有元素
			system("cls");
			if (zhan.base == NULL)
			{
				cout << "还未初始化栈，请您先初始化！" << endl;
			}
			else
			{
				if (zhan.base == zhan.top)
				{
					cout << "栈为空，没有元素可以输出！" << endl;
				}
				else
				{
					cout << "栈中的元素（从栈底到栈顶）为：";
					for (int i = zhan.top - zhan.base; i > 0; i--)
					{
						cout << stackvisit(zhan, i) << " ";
					}

				}
			}
			cout << endl << endl;
			break;
		}
	}
}