数据结构——栈与队列

一、栈与队列的概念

栈：是一种特殊的线性表，即限制在表的一端进行插入和删除操作。简单来说就是后进先出。

队列：只能对表尾进行插入，对表头结点删除。是一种先进先出的数据结构（就像生活中排队打饭一样）。

二、栈的操作与实现

栈的顺序存储——顺序栈

栈的链式存储——链式栈

1、顺序栈

头文件是stack1.h

#pragma once
#include<iostream>
#include<malloc.h>
#define MaxSize 100
using namespace std;
typedef int Elemtype;
typedef int status;

typedef struct {
	Elemtype *base;		//栈底的指针
	Elemtype* top;	//栈顶的指针
	int StackSize;	//栈可以容纳的最大值
}sqstack;

//栈的初始化
void Initstack(sqstack &S) {	//sqstack 是栈的类型，S则表示栈的名字
	S.base = (Elemtype*)malloc(sizeof(int) * MaxSize);	//分配空间
	//或者S.base = new Elemtype[MaxSize];
	if (!S.base) {
		cout << "error";
	}//存储分配失败
	S.top = S.base;	//栈顶的指针等于栈底的指针
	S.StackSize = MaxSize;
}
//判断栈是否为空
void StackEmpty(sqstack S) {
	if (S.top == S.base)
		cout<<"true";
	else
		cout<<"false";
}
//求栈的长度
status StackLength(sqstack S) {
	return  S.top - S.base;
}
//清空栈
void ClearStack(sqstack& S) {
	if (S.base) {
		S.top =S.base;
		cout << "ok";
	}
}
//销毁栈
void Deletestack(sqstack& S) {
	if (S.base) {
		delete S.base;
		S.StackSize = 0;
		S.base = S.top = NULL;
	}
	cout << "ok";
}
//入栈
/*算法思想
1）判断栈是否满
2）元素进入栈顶
3）S.top加1
*/
void addstack(sqstack& S, Elemtype e) {
	if (S.top - S.base == S.StackSize)	//这是栈满的情况
		cout << "error";
	*S.top++ = e;
		//*S.top=e;
		//S.top++;
	cout << "ok";
}
//出栈
/*算法思想
1）判断栈是否为空
2）获取元素
3）栈顶指针减一
*/
status OutStack(sqstack &S, Elemtype &e) {	
	if (S.top == S.base) {
		cout << "error";	//判断栈是否为空
	}
	--S.top;	//如果不空，则删除栈顶元素,返回e
	e = *S.top;
	//或者e=*--top;
	return e;
}

//遍历
void Travalstack(sqstack& S) {
	if (S.top == S.base) {
		cout << "error";	//空栈
	}
	for (int i = S.top - S.base; i > 0; i--) {
		S.top--;
		cout << *S.top<<" ";
	}
}

源文件：Filestack.cpp

#include"stack1.h"
int main() {
	sqstack S;
	Initstack(S);
	StackEmpty(S);
	cout << "\n";
	addstack(S, 11);
	addstack(S, 12);
	addstack(S, 33);
	addstack(S, 71);
	cout << "\n";
	int n;
	cin >> n;
	OutStack( S, n);
	Travalstack(S);
}

2.链栈

头文件：Lstack2.h

#pragma once
#include<iostream>
#include<malloc.h>
using namespace std;
typedef int LElemtype;
typedef int Lstatus;
//定义链栈的节点
typedef struct stackNode {
	LElemtype data;
	stackNode* next;
}stackNode,*Lstack;	//stackNode是指向结构体,*Lstack是指针类型
Lstack Ls;	//定义链栈Ls,或者是stackNode*Ls

//链栈的初始化
void InitLstack(Lstack& Ls) {
	Ls = (Lstack)malloc(sizeof(stackNode));
	Ls= NULL;	//不用头结点
}
//判断链栈是否为空
void LstackEmpty(Lstack& Ls) {
	if (Ls == NULL)
		cout << "Yes";
	else
		cout << "No";
}
//链栈的入栈
void Pushstack(Lstack &Ls, LElemtype e) {
	Lstack p=new stackNode;
	//Lstack p = (Lstack)malloc(sizeof(stackNode));
	p->data=e;
	p->next = NULL;
	if (Ls == NULL)
		Ls = p;
	else {
		p->next = Ls;
		Ls = p;
	}
}
//链栈的长度
int LstackLength(Lstack Ls) {
	int num = 0;
	Lstack p = Ls;
	while (p != NULL) {
		num++;
		p = p->next;
	}
	return num;
}
//出栈
void Popstack(Lstack& Ls, LElemtype& e) {
	if (Ls == NULL)
		cout << "error";
	else {
		Lstack p = new stackNode;
		p = Ls;
		e = p->data;
		Ls = Ls->next;
		delete p;
		cout << "ok";
	}
}
//取栈顶的元素
void GetElem(Lstack Ls) {
	if (Ls != NULL) {
		cout<<Ls->data;
	}
}
//销毁链栈
void Deletestack(Lstack& Ls) {
	Lstack p;
	while (Ls) {
		p = Ls;
		Ls = Ls->next;
		delete p;
	}
	Ls = NULL;
	cout << "ok";
}

源文件：

#include"Lstack2.h"
int main() {
	InitLstack(Ls);
	LstackEmpty(Ls);
	cout << "\n";
	Pushstack(Ls, 2);
	Pushstack(Ls, 4);
	Pushstack(Ls, 6);
	int a=LstackLength(Ls);
	cout << a<<"\n";
	GetElem( Ls);
	int number;
	cin >> number;
	Popstack(Ls, number);
	cout<< LstackLength(Ls);
	return 0;
}

三、队列的操作与实现

队列的存储方式也有两种即顺序队列（一维数组）和链式队列

/*这里我就写顺序队列*/

头文件：sqQueue1.h

#pragma once
#include<iostream>
#define MaxSize 50
using namespace std;
typedef int Elemtype;

typedef struct {
	Elemtype* base;	//动态分配存储空间
	int front;	//头指针，若队列不空，指向队列头元素
	int rear;	//尾指针，若队列不空，指向队列尾元素
}sqQ;
//队列初始化
void InitQueue(sqQ& Q) {
	Q.base = new Elemtype[MaxSize];	//分配数组空间
	//Q.base=(Elemtype *)malloc(sizeof(Elemtype)*MaxSize);

	if (!Q.base)
		cout << "error";	//存储分配失败
	else
		Q.front = Q.rear = 0;	//头指针与尾指针为0，队列为空。
	cout << "ok";
}
//求队列的长度
void Queuelength(sqQ Q) {
	int num = (Q.rear - Q.front + MaxSize) % MaxSize;
	cout << num;
}
//入队
void EnterOueue(sqQ& Q, Elemtype e) {
	if ((Q.rear + 1) % MaxSize == Q.front)
		cout << "error";	//队满
	Q.base[Q.rear] = e;		//新元素加入队尾；
	Q.rear = (Q.rear + 1) % MaxSize;	//队尾指针+1
}
//出队
void OutQueue(sqQ& Q, Elemtype& e) {
	if (Q.front == Q.rear)
		cout << "error";	//队空
	e = Q.base[Q.front];	//保留队头元素
	Q.front = (Q.front + 1) % MaxSize;	//队头指针+1
	cout << "ok";
}
//取队头元素
void GetHead(sqQ Q) {
	if (Q.rear != Q.front) {	//队列不为空
		cout<<Q.base[Q.front];	//返回队头指针元素的值，队头指针不变
	}
}

源文件

#include"sqQueue1.h"
int main() {
	sqQ Q;
	InitQueue(Q);
	EnterOueue(Q, 7);
	EnterOueue(Q, 9);
	EnterOueue(Q, 11);
	cout << "\n";
	GetHead(Q);
	int num;
	cin >> num;
	OutQueue(Q,num);
	cout << "\n";
	Queuelength(Q);
	return 0;

}

//以上是我假期看网课总结的，希望对你们有帮助。