栈与队列

1、栈

栈底：表头端；

栈顶：表尾端；

后进先出

主要操作：插入、删除

栈的结构与基本操作

（1）顺序存储与操作

#define MAXSIZE 100
//栈的结构 
typedef struct{
	int *Base;
	int *top;
	int stacksize;
}Stack;

//初始化
Stack init_S(Stack S)
{
	S.Base = new int[MAXSIZE];
	if(!S.Base) exit(0);
	S.top = S.Base;
	S.stacksize = MAXSIZE;
	return S;
 } 
 
//入栈
bool Push(Stack S,int e)
{
	if(*S.top - *S.Base == S.stacksize) return false;
	*(S.top++)=e;
	return true;
 } 
 
//出栈
bool Pop(Stack S)
{
	if(S.top == S.Base) return false;
	*(--S.top) ;
	return true;
} 

//取栈顶
int Top(Stack S)
{
	if(S.top == S.Base) return -1;
	return *(S.top-1);
}
 

（2）链式存储与操作

//链栈的结构
typedef struct SNode{
	int data;
	struct SNode* next;
}*Stack; 

//链栈的初始化
Stack Init(Stack S)
{
	S = NULL;
	return S;
}

//入栈
bool Push(Stack S,int e)
{
	Stack p = new struct SNode;
	p->data = e;
	p->next = S;
	S = p;
	return true;
 } 
 
//出栈
bool Pop(Stack S)
{
	Stack p = S;
	if(S == NULL) return false;
	S = S->next;
	delete p;
	return true;
} 

//取栈顶
int Top(Stack S)
{
	if(S == NULL) return -1;
	int e = S->data;
	return e;
}

（其实一般用不到，有s现成的tack类函数）

2、队列

队头：删除的一端；

队尾：插入的一端；

先进先出

队列的顺序存储与实现

采用采用循环队列的方式

#define MAXQUEUE 100
typedef struct QNode{
	int* base;
	int front;
	int rear;
}*Queue;

//初始化
Queue Init(Queue Q) 
{
	Q->base = new int[MAXQUEUE];
	Q->front = Q->rear =0;
	return Q;
}

//入队
bool Push(Queue Q,int e)
{
	if((Q->rear+1) % MAXQUEUE == Q->front) return false;
	Q->base[(Q->rear+1) % MAXQUEUE] = e;
	Q->rear = (Q->rear + 1) % MAXQUEUE;
	return true;
}

//出队
bool Pop(Queue Q)
{
	if(Q->front == Q->rear) return false;
	Q->front = (Q->front + 1) % MAXQUEUE;
	return true; 
} 

//取头结点
int Top(Queue Q)
{
	if(Q->front != Q->rear) return Q->base[Q->front];
}