堆栈和队列的数据结构和相关操作总结

一、栈的操作

1、栈结构的顺序存储定义：

typedef struct Sqstack{
	int data[MAXSIZE];
	int top; //top为指向栈的顶层的数组下标
};

入栈操作：

#define OK 1;
#define ERROR 0;
#define MAXSIZE 20;
int Push(Sqstack *s, int e){
	if (s->top == MAXSIZE - 1)  //满栈
		return ERROR;
	s->top++;
	s->data[s->top] = e;
	return OK;
}

出栈操作；

int Pop(Sqstack *s, int *e){
	if (s->top == -1) //空栈
		return ERROR;
	*e = s->data[s->top]；
		s->top--;
	return OK;
}

两个栈共享空间（即用两个top指针且共用一个数组空间）

typedef struct Sqdoublestack{
	int data[MAXSIZE];
	int top1;
	int top2;
};

其余操作类似，只需判别top1和top2是否重叠即可

2、栈的链式存储结构

typedef struct StackNode{   //定义栈结点结构
	int data;
	struct StackNode *next;
}*LinkPtr; 
typedef struct LinkStack{  //定义链栈结构
	LinkPtr top;  //定义栈顶指针top
	int count;   //定义栈长度；
};

入栈

nt Push(LinkStack *s, int e){
	LinkPtr p = (LinkPtr)malloc(sizeof(StackNode));
	if (!p)
		exit(OVERFLOW);  //内存满
	p->data = e;
	p->next = s->top;
	s->top = p;
	s->count++;
	return OK;

出栈

int Pop(Linkstack *s, int *e){
	LinkPtr p;
	if (s->top == NULL)  //空栈
		return ERROR;
	*e = s->top->data;
	p = s->top;
	s->top = p->next;
	free(p);
	s->count--;
	return OK;
}

二、循环队列的操作

循环队列是存储空间可以从后面的位置满了之后，可以循环存储到前面的空位置的队列。因此就需要有两个指针front和rear来指向头和尾部。

1、顺序存储结构定义：

//循环队列的顺序存储结构
typedef struct SqQueue{
	int data[MAXSIZE];
	int front; //指向队列头位置的数组下标,出队列时候其值改变
	int rear; //指向队列尾元素的下一个空位置的数组下标，入队列时候改变其位置
};

初始化：

#define OK 1;
#define ERROR 0;
#define MAXSIZE 20;
//初始化队列
int IniQueue(SqQueue *Q){
	Q->front = 0;
	Q->rear = 0;
	return OK;

入队列：

int EnQueue(SqQueue *Q, int e){
	if((Q->rear+1)%MAXSIZE==Q->front)  //满队列
		return ERROR;
	Q-data[Q-rear]=e;
	Q->rear=(Q->rear+1)%MAXISIZE;
	return OK;

出队列：

int DeQueue(SqQueue *Q, int *e){
	if (Q->front==Q->rear) //空队列
		return ERROR;
	*e=Q->data[Q-front]；
	Q->front=(Q->front+1)%MASIZE;
	return OK;
}

2、链式队列结构定义

typedef struct QNode{   //定义队列结点结构
	int data;
	struct QNode *next;
}*QPtr; 
typedef struct LinkQueue{  //定义链式队列结构
	QPtr front;  //这里的front指针指向的是头结点，头结点没有data信息
	QPtr rear;   //这里的rear指针不再是指向下一个空位置，而是指向链式队列的尾元素
};

入队列：

int EnQueue(LinkQueue *Q, int e){
	QPtr p = (QkPtr)malloc(sizeof(QNode));
	if (!p)
		exit(OVERFLOW);  //内存满
	p->data = e;
	Q->rear->next=p;  //把之前队尾元素和新创建节点链接起来
	Q->rear = p;   //把rear指向队尾元素
	p->next=NULL;
	return OK;

出队列：

int DeQueue(LinkQueue *Q, int *e){
	QPtr p;
	if (Q->front == Q->rear)  //空队列
		return ERROR;
	p = Q->front->next;
	*e = p->data;
	Q->front->next=p->next;
	if (Q->rear == p)
		Q->rear = Q->front;  //若只有一个元素，出队列后，队头是队尾，则将rear指向头结点
	free(p);
	return OK;
}