三、堆栈和队列

1.堆栈

2.队列

2.1顺序循环队列
1.结构体定义

typedef struct {
	ElemType queue[MaxSize];
	int rear;//队尾下标
	int front;//队头下标
	int count;//计数器
}SeqCQueue;

2.初始化

void QueueInit(SeqCQueue* Q) {
	//初始化，也即删除所有元素
	Q->rear = 0;
	Q->front = 0;
	Q->count = 0;
}//QueueInit

3.入队

int QueueAppend(SeqCQueue *Q, ElemType e) {
	//入队列，将e插入队列尾，成功返回1，否则0
	if (Q->count > 0 && Q->rear == Q->front) {
		printf("队列已满无法插入\n");
		return 0;
	}//if
	else {
		Q->queue[Q->rear] = e;
		Q->rear = (Q->rear + 1) % MaxSize;//队尾指示器加1
		Q->count++;//计数器加一
		return 1;
	}//else
}//QueueAppend

4.出队

ElemType QueueOut(SeqCQueue* Q) {
	//出队列，删除队头元素并赋给e,成功返回1，失败返回0
	ElemType e;
	e = Q->queue[Q->front];
	Q-> front = (Q->front + 1) % MaxSize;//队头指示器加一
	Q->count--;
	return e;
}//QueueOut

5.判空
队列判空有三种方法：
（1）少用一个存储单元：

	//队满
	(Q.rear + 1) % MaxSize = front;
	//队空
	Q.front = Q.rear;

（2）设置一个标志位：初始时flag=0，入队操作成功就置1，出队成功就置0；

	//队满
	Q.front = Q.rear && flag == 1;
	//队空
	Q.front = Q.rear && flag == 0;

（3）设置一个计数器：入队成功，count++;出队成功，count- -;

	//队满
	Q.front = Q.rear && count > 0;
	//队空
	count == 0;

int QueueNotEmpty(SeqCQueue Q) {
	//队列判空否
	if (Q.count != 0) {//队列不为空返回1
		return 1;
	}else{//队列为空
		return 0;
	}//else
}//QueueNotEmpty

6.取队头元素

ElemType QueueGet(SeqCQueue Q) {
	//取队头元素并赋给e
	return Q.queue[Q.front];
}//QueueGet

7.遍历

void QueueTra(SeqCQueue* Q) {
	//队列元素遍历
	int i;
	for (i = Q->front;i < Q->count;i++) {
		printf("%d ", Q->queue[i % MaxSize]);//防止元素下标大于元素个数
	}//for
}//QueueTra

8.综合代码（链接）

#include<stdio.h>
#define MaxSize 10
typedef int ElemType;

typedef struct {
	ElemType queue[MaxSize];
	int rear;//队尾下标
	int front;//队头下标
	int count;//计数器
}SeqCQueue;

void main() {
	//声明
	void QueueInit(SeqCQueue * Q);
	int QueueNotEmpty(SeqCQueue Q);
	int QueueAppend(SeqCQueue * Q, ElemType e);
	int QueueOut(SeqCQueue * Q);
	ElemType QueueGet(SeqCQueue Q);
	void QueueTra(SeqCQueue * Q);

	ElemType e = 0;//需要初始化
	SeqCQueue Q;
	/****1.队列初始化*/
	QueueInit(&Q);//队列初始化
	/****2.入队*/
	ElemType array[] = { 1,2,3,4,5,6,7 };
	int i;
	for (i = 0;i < 7;i++) {
		QueueAppend(&Q, array[i]);//入队列
	}
	printf("font=%d,rear=%d,count=%d\n", Q.front, Q.rear, Q.count);
	/****3.队列判空*/
	if (QueueNotEmpty(Q))
		printf("队列不为空！\n");
	else 
		printf("队列为空!\n");
	/****4.取队头元素*/
	e = QueueGet(Q);//取队头元素
	/****5.出队列*/
	e = QueueOut(&Q);//删除队列
	printf("出队列元素为:%d！\n",e);
	printf("font=%d,rear=%d,count=%d\n", Q.front, Q.rear, Q.count);
	/****6.元素遍历*/
	QueueTra(&Q);
}//main

void QueueInit(SeqCQueue* Q) {
	//初始化，也即删除所有元素
	Q->rear = 0;
	Q->front = 0;
	Q->count = 0;
}//QueueInit
int QueueNotEmpty(SeqCQueue Q) {
	//队列判空否
	if (Q.count != 0) {//队列不为空返回1
		return 1;
	}else{//队列为空
		return 0;
	}//else
}//QueueNotEmpty
int QueueAppend(SeqCQueue *Q, ElemType e) {
	//入队列，将e插入队列尾，成功返回1，否则0
	if (Q->count > 0 && Q->rear == Q->front) {
		printf("队列已满无法插入\n");
		return 0;
	}//if
	else {
		Q->queue[Q->rear] = e;
		Q->rear = (Q->rear + 1) % MaxSize;//队尾指示器加1
		Q->count++;//计数器加一
		return 1;
	}//else
}//QueueAppend
ElemType QueueOut(SeqCQueue* Q) {
	//出队列，删除队头元素并赋给e,成功返回1，失败返回0
	ElemType e;
	e = Q->queue[Q->front];
	Q-> front = (Q->front + 1) % MaxSize;//队头指示器加一
	Q->count--;
	return e;
}//QueueDel
ElemType QueueGet(SeqCQueue Q) {
	//取队头元素并赋给e
	return Q.queue[Q.front];
}//QueueGet
void QueueTra(SeqCQueue* Q) {
	//队列元素遍历
	int i;
	for (i = Q->front;i < Q->count;i++) {
		printf("%d ", Q->queue[i % MaxSize]);//防止元素下标大于元素个数
	}//for
}//QueueTra

2.2链式队列
1.定义结构体

typedef struct qnode{//定义结点结构体
	ElemType data;
	struct qnode* next;
}LQNode;

typedef struct {//定义队头队尾指针，方便参数调用
	LQNode* front;//队头指针
	LQNode* rear;//队尾指针
}LQueue;

2.初始化

void QueueInit(LQueue* Q) {
	//初始化
	Q->front = NULL;//定义初始化队头下标值
	Q->rear = NULL;//定义初始化队尾下标值
}//QueueInit

3.入队列

void QueueAppend(LQueue* Q, ElemType e) {
	//将指定元素插入队列
	LQNode* p;
	p = (LQNode*)malloc(sizeof(LQNode));
	p->data = e;
	p->next = NULL;
	if (Q->rear != NULL)//当原队列非空时
		Q->rear->next = p;
	Q->rear = p;
	if (Q->front == NULL)//当原队列为空时
		Q->front = p;
}//QueueAppend

4.判空

int QueueNotEmpty(LQueue Q) {
	//判空
	if (Q.front == NULL)//非空返回1
		return 0;
	else
		return 1;
}//QueueNotEmpty

5.取队头元素

ElemType QueueGet(LQueue* Q) {
	//取队头元素
	ElemType e;
	if (Q->front == NULL) {
		printf("队列已空！\n");
		return 0;
	}//if
	else {
		e = Q->front->data;
		return e;
	}//else
}//QueueGet

6.出队列

ElemType QueueOut(LQueue* Q) {
	//出队列，返回队头元素
	ElemType e;
	LQNode* p;
	if (Q->front == NULL) {
		printf("队列已空！\n");
		return 0;
	}//if
	else {
		e = Q->front->data;
		p = Q->front;
		Q->front = Q->front->next;
		if (Q->front == NULL)//删除最后一个节点后，要置队尾元素为空
			Q->rear = NULL;
		free(p);
		return e;
	}//else
}//QueueOut

7.遍历

void QueueTra(LQueue* Q) {
	//遍历
	LQNode* p, * p1;
	p = Q->front;
	while (p != NULL) {
		printf("%d ", p->data);
		p = p->next;
	}//while
}//QueueTra

8.销毁

void QueueDestroy(LQueue Q) {
	//删除队列
	LQNode* p, *p1;
	p = Q.front;
	while (p != NULL) {
		p1 = p;
		p = p->next;
		free(p1);
	}//while
}//Destroy

9.综合代码（链接）

#include<stdio.h>
#define MaxSize 10
typedef int ElemType;
typedef struct qnode{//定义结点结构体
	ElemType data;
	struct qnode* next;
}LQNode;
typedef struct {//定义队头队尾指针，方便参数调用
	LQNode* front;//队头指针
	LQNode* rear;//队尾指针
}LQueue;
void main() {
	//声明
	void QueueInit(LQueue * Q);
	int QueueNotEmpty(LQueue Q);
	void QueueAppend(LQueue * Q, ElemType e);
	ElemType QueueOut(LQueue * Q);
	ElemType QueueGet(LQueue * Q);
	void QueueTra(LQueue * Q);
	void QueueDestroy(LQueue Q);

	LQueue Q;
	ElemType e;
	/*1.初始化*/
	QueueInit(&Q);//初始化
	/*2.入队列*/
	ElemType array[] = { 1,2,3,4,5,6,7,8 };
	int i;
	for (i = 0;i < 8;i++) {
		QueueAppend(&Q, array[i]);//入队列
	}//for
	/*3.判空*/
	if (QueueNotEmpty(Q))
		printf("队列非空！\n");
	else
		printf("队列为空！\n");
	/*4.取队头元素*/
	e = QueueGet(&Q);
	printf("e=%d\n", e);
	/*5.出队列*/
	QueueDel(&Q);
	/*6.遍历*/
	QueueTra(&Q);
	/*7.销毁队列*/
	QueueDestroy(Q);
	if (QueueNotEmpty(Q))
		printf("队列非空！\n");
	else
		printf("队列为空！\n");
}//main
void QueueInit(LQueue* Q) {
	//初始化
	Q->front = NULL;//定义初始化队头下标值
	Q->rear = NULL;//定义初始化队尾下标值
}//QueueInit
int QueueNotEmpty(LQueue Q) {
	//判空
	if (Q.front == NULL)//非空返回1
		return 0;
	else
		return 1;
}//QueueNotEmpty
void QueueAppend(LQueue* Q, ElemType e) {
	//将指定元素插入队列
	LQNode* p;
	p = (LQNode*)malloc(sizeof(LQNode));
	p->data = e;
	p->next = NULL;
	if (Q->rear != NULL)//当原队列非空时
		Q->rear->next = p;
	Q->rear = p;
	if (Q->front == NULL)//当原队列为空时
		Q->front = p;
}//QueueAppend
ElemType QueueOut(LQueue* Q) {
	//出队列，返回队头元素
	ElemType e;
	LQNode* p;
	if (Q->front == NULL) {
		printf("队列已空！\n");
		return 0;
	}//if
	else {
		e = Q->front->data;
		p = Q->front;
		Q->front = Q->front->next;
		if (Q->front == NULL)//删除最后一个节点后，要置队尾元素为空
			Q->rear = NULL;
		free(p);
		return e;
	}//else
}//QueueOut
ElemType QueueGet(LQueue* Q) {
	//取队头元素
	ElemType e;
	if (Q->front == NULL) {
		printf("队列已空！\n");
		return 0;
	}//if
	else {
		e = Q->front->data;
		return e;
	}//else
}//QueueGet
void QueueDestroy(LQueue Q) {
	//删除队列
	LQNode* p, *p1;
	p = Q.front;
	while (p != NULL) {
		p1 = p;
		p = p->next;
		free(p1);
	}//while
}//Destroy
void QueueTra(LQueue* Q) {
	//遍历
	LQNode* p, * p1;
	p = Q->front;
	while (p != NULL) {
		printf("%d ", p->data);
		p = p->next;
	}//while
}//QueueTra

2.3优先级队列
1.定义结构体

typedef struct {//数据元素结构体
	int priorty;//优先级
	ElemType elem;//数据元素
}DataType;//顺序优先级队列

typedef struct {
	DataType queue[MaxSize];//队列数组
	int size;//元素个数
}SeqPQueue;//优先级队列结构体

2.初始化

void QueueInit(SeqPQueue* Q) {
	//初始化队列
	Q->size = 0;
}//QueueInit

3.入队

int QueueAppend(SeqPQueue* Q, DataType d) {
	//入队列
	if (Q->size >= MaxSize) {
		printf("队列已满！\n");
		return 0;
	}//if
	else {
		Q->queue[Q->size] = d;
		Q->size++;
		return 1;
	}//else
}//QueueAppend

4.判空

int QueueNotEmpty(SeqPQueue Q) {
	//判空
	if (Q.size <= 0)
		return 0;
	else
		return 1;
}//QueueNotEmpty

5.去队头元素

DataType QueueGet(SeqPQueue* Q) {
	//取优先级最高元素并返回
	DataType min,d = { 0,0 };
	int minIndex, i;
	if (Q->size <= 0) {
		printf("队列已空！\n");
		return d;
	}//if
	else {
		min = Q->queue[0];
		minIndex = 0;
		for (i = 1;i < Q->size;i++) {
			if (Q->queue[i].priorty < min.priorty) {
				min = Q->queue[i];
				minIndex = i;
			}//if
		}//for
		d = Q->queue[minIndex];
		return d;
	}//else
}//QueueGet

6.出队

DataType QueueOut(SeqPQueue* Q) {
	//出队列
	DataType min, d = {0,0};
	int minIndex, i;
	if (Q->size <= 0) {
		printf("队列已空！\n");
		return d;
	}//if
	else {
		min = Q->queue[0];//假设第一个元素优先级最高
		minIndex = 0;//记录优先级最高元素的下标
		for (i = 1;i < Q->size;i++) {//通过遍历比较寻找真正的优先级最高元素
			if (Q->queue[i].priorty < min.priorty) {
				min = Q->queue[i];
				minIndex = i;
			}//if

		}//for
		d = Q->queue[minIndex];
		for (i = minIndex + 1;i < Q->size;i++) {//将数据元素一次前移
			Q->queue[i - 1] = Q->queue[i];
		}//for
		Q->size--;//数据元素个数减一
		return d;
	}//else

}//QueueOut

7.遍历

void QueueTra(SeqPQueue* Q) {
	//遍历
	int i;
	for (i = 0;i < Q->size;i++) {
		printf("priorty=%d,elem=%d;", Q->queue[i].priorty, Q->queue[i].elem);
	}//for
	printf("\n");
}//QueueTra

8.综合代码（链接）

#include<stdio.h>
#define MaxSize 10
typedef int ElemType;
typedef struct {//数据元素结构体
	int priorty;//优先级
	ElemType elem;//数据元素
}DataType;//顺序优先级队列
typedef struct {
	DataType queue[MaxSize];//队列数组
	int size;//元素个数
}SeqPQueue;//优先级队列结构体
void main() {
	void QueueInit(SeqPQueue * Q);
	int QueueNotEmpty(SeqPQueue Q);
	int QueueAppend(SeqPQueue * Q, DataType d);
	DataType QueueOut(SeqPQueue * Q);
	DataType QueueGet(SeqPQueue * Q);
	void QueueTra(SeqPQueue *Q);
	SeqPQueue Q;
	DataType d;
	/*1.初始化*/
	QueueInit(&Q);
	/*2.入队列*/
	DataType array[] = { {1,5},{2,4},{3,3},{0,6},{6,2} };
	int i;
	for (i = 0;i < 5;i++) {
		QueueAppend(&Q, array[i]);
	}//for
	/*3.判空*/
	if (QueueNotEmpty(Q))
		printf("非空！\n");
	else
		printf("空\n");
	/*4.取队头元素*/
	d = QueueGet(&Q);
	printf("d=%d\n", d.elem);
	/*5.出队列*/
	d = QueueOut(&Q);
	printf("d=%d\n", d.elem);
	/*6.遍历*/
	QueueTra(&Q);

}//main
void QueueInit(SeqPQueue* Q) {
	//初始化队列
	Q->size = 0;
}//QueueInit
int QueueNotEmpty(SeqPQueue Q) {
	//判空
	if (Q.size <= 0)
		return 0;
	else
		return 1;
}//QueueNotEmpty
int QueueAppend(SeqPQueue* Q, DataType d) {
	//入队列
	if (Q->size >= MaxSize) {
		printf("队列已满！\n");
		return 0;
	}//if
	else {
		Q->queue[Q->size] = d;
		Q->size++;
		return 1;
	}//else
}//QueueAppend
DataType QueueOut(SeqPQueue* Q) {
	//出队列
	DataType min, d = {0,0};
	int minIndex, i;
	if (Q->size <= 0) {
		printf("队列已空！\n");
		return d;
	}//if
	else {
		min = Q->queue[0];//假设第一个元素优先级最高
		minIndex = 0;//记录优先级最高元素的下标
		for (i = 1;i < Q->size;i++) {//通过遍历比较寻找真正的优先级最高元素
			if (Q->queue[i].priorty < min.priorty) {
				min = Q->queue[i];
				minIndex = i;
			}//if

		}//for
		d = Q->queue[minIndex];
		for (i = minIndex + 1;i < Q->size;i++) {//将数据元素一次前移
			Q->queue[i - 1] = Q->queue[i];
		}//for
		Q->size--;//数据元素个数减一
		return d;
	}//else

}//QueueOut
DataType QueueGet(SeqPQueue* Q) {
	//取优先级最高元素并返回
	DataType min,d = { 0,0 };
	int minIndex, i;
	if (Q->size <= 0) {
		printf("队列已空！\n");
		return d;
	}//if
	else {
		min = Q->queue[0];
		minIndex = 0;
		for (i = 1;i < Q->size;i++) {
			if (Q->queue[i].priorty < min.priorty) {
				min = Q->queue[i];
				minIndex = i;
			}//if
		}//for
		d = Q->queue[minIndex];
		return d;
	}//else
}//QueueGet
void QueueTra(SeqPQueue* Q) {
	//遍历
	int i;
	for (i = 0;i < Q->size;i++) {
		printf("priorty=%d,elem=%d;", Q->queue[i].priorty, Q->queue[i].elem);
	}//for
	printf("\n");
}//QueueTra