栈和队列的基本操作

栈

//顺序栈

#include<cstdio>
#define max 10
typedef struct {
	int data[max];
	int top;
}Sqstack;

void InitStack(Sqstack&S)//初始化
{
	S.top = -1;
}

void Print(Sqstack &S)
{
	for (int i = S.top; i >= 0; i--)
		printf("%d\n", S.data[i]);
}

bool Push(Sqstack& S, int e) {//入栈
	if (S.top == max - 1) return false;
	S.top++;
	S.data[S.top] = e;
	return true;
}

bool Pop(Sqstack& S, int& e) {//出栈
	if (S.top == -1) return false;
	e = S.data[S.top];
	S.top--;
	return true;
}
int main()
{
	Sqstack S;
	InitStack(S);
	int e;
	for (int i = 0; i < 4; i++) {//入栈
		scanf_s("%d", &e);
		if (Push(S, e))
		{
			printf("栈内为：\n");
			Print(S);
		}
		else printf("error");
	}
	for (int i = 0; i < 4; i++) {//出栈
		if (Pop(S, e))
		{
			printf("栈内为：\n");
			Print(S);
		}
		else printf("error");
	}
}

//链栈

#include<cstdio>
#include<cstdlib>

typedef struct Linknode {
	int data;
	struct Linknode* next;
}Linknode,*LiStack;

void PrintList(LiStack L)
{
	LiStack p;
	p = L->next;
	printf("栈内元素如下：\n");
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

void InitStack(LiStack &L) {
	L = (LiStack)malloc(sizeof(Linknode));
	L->next = NULL;
}

bool Pop(LiStack& L,int e)
{
	    Linknode* s;
		s = (LiStack)malloc(sizeof(Linknode));
		s->data = e;
		s->next = L->next;
		L->next = s;
	return true;
}

bool Push(LiStack& L, int& e) {//出栈
		LiStack p;
		p = L->next;
		e = p->data;
		L->next = p->next;
		free(p);
	return true;
}

int main()
{
	LiStack L;
	InitStack(L);
	int x;
	scanf_s("%d", &x);
	while (x != 999) {
		if (Pop(L, x)) PrintList(L);
		else printf("error\n");
		scanf_s("%d", &x);
	}
	int e = -1;//带回元素
	while(L->next != NULL) {
		if (Push(L, e)) PrintList(L);
		else printf("error");
	}
}

 队列

//顺序队列
#include<cstdio>
#define max 20
typedef struct {
	int data[max];
	int front,rear;//队头指针和队尾指针
}SqQueue;
//队列长度(Q.rear-Q.front+max)%max

void InitSqQueue(SqQueue&Q) {//初始化
	Q.front = Q.rear = 0;
	for (int i = 0; i < max; i++) {
		Q.data[i] = -1;
	}
}

void Print(SqQueue Q) {
	printf("当前队列元素\n");
	while (Q.front!=Q.rear) {
		printf("%4d", Q.data[Q.front]);
		Q.front = (Q.front + 1) % max;
	}
	printf("\n");
}
bool EnQueue(SqQueue&Q,int x){//入队
	if ((Q.rear + 1) % max == Q.front)
		return false;
		Q.data[Q.rear] = x;
		Q.rear=(Q.rear+1)%max;
		return true;	
}

bool DeQueue(SqQueue& Q, int& x) {
	if (Q.rear == Q.front) return false;
	x = Q.data[Q.front];
	Q.front = (Q.front + 1) % max;
	return true;
}

int main()
{
	SqQueue Q;
	InitSqQueue(Q);
	int a;
	scanf_s("%d", &a);
	while (a != 999) {
		if (EnQueue(Q, a))
			Print(Q);
		else printf("error");
		scanf_s("%d", &a);
	}
	int e = -1;//带回删除的值
	if (DeQueue(Q, e)) {
		printf("此次出队的是%d", e);
		Print(Q);
	}
	else printf("error");
	return 0;
}

//链队
#include<cstdio>
#include<cstdlib>
typedef int elmenttype;
typedef struct LinkNode {//链式队列节点
	elmenttype data;
	struct LinkNode* next;
}LinkNode;
typedef struct {//链式队列
	LinkNode* rear, * front;
}LinkQueue;

void InitQueue(LinkQueue& Q)//初始化
{
	Q.front = Q.rear = (LinkNode*)malloc(sizeof(LinkNode));//建立头节点
	Q.front->next = NULL;
}

void Print(LinkQueue Q) {//打印队列
	LinkNode* p = Q.front->next;
	while (p != NULL)
	{
		printf("%4d", p->data);
		p = p->next;
	}
	printf("\n");
}

void EnQueue(LinkQueue& Q, elmenttype e)//入队
{
	LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode));
	s->data = e;
	s->next = NULL;
	Q.rear->next = s;
	Q.rear = s;
}

bool DeQueue(LinkQueue& Q, elmenttype& e)//出队
{
	if (Q.rear == Q.front) return false;//判空
	LinkNode* p = Q.front->next;
	e = p->data;
	Q.front->next = p->next;
	if (p == Q.rear)//最后一个节点出队
		Q.front = Q.rear;
	free(p);
	return true;
}

int main()
{
	int i;
	LinkQueue Q;
	InitQueue(Q);
	printf("输入入队元素，输入-1结束\n");
	scanf_s("%d", &i);
	while (i != -1) {
		EnQueue(Q, i);
		scanf_s("%d", &i);
	}
	Print(Q);
	int e = -1;//带回出队的值
	while (Q.rear != Q.front) {//所有元素出队
		if (DeQueue(Q, e))
			printf("%d出队成功\n", e);
	}
	return 0;
}