栈和队列的基本操作

整理的一些栈和队列的基本操作，废话不多说，上代码

//数组实现栈
#define MaxSize
typedef struct SNode *Stack;
struct SNode
{
	int top;
	ElementType Data[MaxSize];
};

void Push(Stack S,ElementType item)
{
	if(S->top=MaxSize-1){
		printf("堆栈满");
		return;
	}else{
		S->Data[++S->top]=item;
		return;
	}
}

ElementType Pop(Stack S)
{
	if(S->top==-1){
		printf("堆栈空");
		return ERROR;
	}else{
		return S->Data[S->top--];
	}
}

//链表实现栈
typedef struct SNode* Stack;
struct SNode
{
	ElementType Data;
	struct SNode* Next;
}

Stack CraeteStack()
{
	Stack S;
	S=(Stack)malloc(sizeof(struct SNode));
	S->Next=NULL;
	return S;
}

int IsEmpty(Stack S)
{
	return (S->Next==NULL);
}

void Push(Stack S,ElementType item)
{
	struct SNode* Tmpcell;
	Tmpcell=(Stack)malloc(sizeof(struct SNode));
	Tmpcell->Data=item;
	Tmpcell->Next=S->Next;
	S->Next=Tmpcell;
}

void Pop(Stack S)
{
	struct SNode* Firstcell;
	ElementType TopElem;
	if(IsEmpty(S)){
		printf("堆栈空");
		return;
	}else{
		Firstcell=S->Next;
		S->Next=Firstcell->Next;
		TopElem=Firstcell->Data;
		free(Firstcell);
		return TopElem;
	}
}

//数组实现循环队列
#define MaxSize;
typedef struct QNode* Queue;
struct QNode
{
	ElementType Data[MaxSize];
	int rear;
	int front;
};

void AddQ(Queue Q,ElementType item)
{
	if((Q->rear+1)%MaxSize==Q->front){
		printf("队列满");
		return;
	}
	Q->rear=(Q->rear+1)%MaxSize;
	Q->Data[Q->rear]=item;
}

ElementType DeleteQ(Queue Q)
{
	if(Q->front==Q->rear){
		printf("队列空");
		return ERROR;
	}else{
		Q->front=(Q->front+1)%MaxSize;
		return Q->Data[Q->front];
	}
}

//链表实现队列
typedef struct QNode* Queue;
struct Node
{
	ElementType Data;
	struct Node* Next;
};

struct QNode
{
	struct Node* front;
	struct Node* rear;
};
Queue Q;

ElementType Delete(Queue Q)
{
	struct Node* Frontcell;
	ElementType FrontElem;
	if(Q->front==NULL)
	{
		printf("队列空");
		return ERROR;
	}
	Frontcell=Q->front;
	if(Q->front==Q->rear)
		Q->front=Q->rear=NULL;
	else
		Q->front=Q->front->Next;
	FrontElem=Frontcell->Data;
	free(Frontcell);
	return FrontElem;
}

//入队列省略......

practice makes perfect.