栈，队列与循环队列的实现（c）

数据结构栈（C语言实现）
栈是限定在表尾进行插入删除操作的线性表，表尾又叫栈顶，表头又称栈底，又称后进先出结构（LIFO结构），栈分为顺序栈和链式栈两种`

//顺序
typedef struct Snode* stack;
struct Snode {
	int Data[initSize];
	int top;    //初始等于-1
	int size;
};
//链式
struct Lnode
{
	int val;
	struct Lnode* next;
};
typedef struct Lnode* list;

链式存储为了方便进行pop和push操作，将栈顶设置在头节点后的第一个节点处；

//初始化顺序栈 
stack create() {
	stack s ;
	s = (stack)malloc(initSize * sizeof(struct Snode));
	s->size = initSize;
	s->top = -1;
	return s;
}
//初始化链式栈,即创造一个头节点
list listCreate() {
	list l;
	l = (list)malloc(sizeof(struct Lnode));
	l->next = NULL;
	l->val = 0;
	return l;
}
//链式栈push操作
void pushlist(list l, int x) {
	if (l->next == NULL) {
		list s = (list)malloc(sizeof(struct Lnode));
		s->val = x;
		s->next = NULL;
		l->next = s;
		return ;
	}
	list s = (list)malloc(sizeof(struct Lnode));
	s->val = x;
	list n = l->next;
	l->next = s;
	s->next = n;
	
}
	
//顺序存储push操作 
void push(stack s, int x) {
	if (s->top == s->size - 1) {//栈满 
		return;
	}
	s->Data[++s->top] = x;
}
//顺序存储的pop操作
int pop(stack s) {
	if (s->top == -1) {//空栈 
		return -1;
	}
	else {
		return s->Data[(s->top--)];
	}
}
//链式存储的pop操作
int poplist(list l) {
	if (l->next == NULL) {
		return -1;
	}
	list s = l->next;
	l->next = s->next;
	int z = s->val;
	free(s);
	return z;
}

队列：
队列也是一种特殊的线性表，只允许在一端进行插入一端进行删除，先进先出，允许插入的一端称为队尾，删除的一端称为队头，

#include<stdio.h>
#include<stdlib.h>
#define Maxsize 20
struct Qnode {
	int data[Maxsize];
	int rear;
	int front;
};
typedef struct Qnode* quene;
//构造空队列
quene create() {
	quene s;
	s = (quene)malloc(sizeof(struct Qnode));
	s->rear = -1;
	s->front = -1;
	return s;
}
//判断是否为空
int isempty(quene s) {
	if (s->rear - s->front == 0) {
		return 1;
	}
	return 0;
}
//插入
void insert(quene s, int x) {
	if (s->rear == Maxsize-1 ) {
		printf("已满");
		return;
	}
	s->data[++s->rear] = x;
}

int deletex(quene s) {
	if (s->rear == s->front) {
		printf("已空");
		return -1;
	}
	return s->data[++s->front];
}

由队列可以看到，当队列删除时，前面的front指针往后移动，会造成空间浪费，由此可以用循环队列实现，

#define Maxsize 2
struct Qnode {
	int data[Maxsize];
	int rear;
	int front;
};
typedef struct Qnode* quene;
//构造空循环队列
quene create() {
	quene s;
	s = (quene)malloc(sizeof(struct Qnode));
	s->rear = 0;
	s->front = 0;
	return s;
}
//插入
void insert2(quene s, int x) {
	if (s->front - s->rear == 1||(s->front==0&&s->rear==Maxsize)) {
		printf("已满");
		return;
	}
	if (s->rear == Maxsize ) s->rear = 0;
	s->data[s->rear++] = x;
}
//删除
int deletex(quene s) {
	if (s->rear == s->front) {
		printf("已空");
		return -1;
	}
	if ( s->front == Maxsize) {
		s->front = 0;
	}
	return s->data[s->front++];
}