C语言实现顺序栈 链栈 循环队列 链队列的基本操作

顺序栈

#include 
#include 
#define StackInitSize 10
#define StackIncrement 5
typedef int SElemType;
typedef struct {
	SElemType *base;
	int top;
	int stacksize;
}SqStack;
void InitStack(SqStack &S) {
	S.base=(SElemType*)malloc(StackInitSize * sizeof(SElemType));
	if (!S.base)
		return;
	S.top = 0;
	S.stacksize = StackInitSize;
}
int StackEmpty(SqStack S) {
	if (S.top == 0)
		return 1;
	return 0;
}
int StackLength(SqStack S) {
	return S.top;
}
void Push(SqStack &S, SElemType e) {
	if (S.top >= StackInitSize) {
		S.base = (SElemType*)realloc(S.base,(StackInitSize + StackIncrement) * sizeof(SElemType));
		if (!S.base)
			return;
		S.stacksize = StackInitSize + StackIncrement;
	}
	S.base[S.top] = e;
	S.top++;
}
void pop(SqStack &S, SElemType e) {
	if (S.top == 0)
		return;
	S.top--;
	e = S.base[S.top];
}
void GetElem(SqStack S, SElemType &e){
	if (S.top == 0)
		return;
	e = S.base[S.top - 1];
}

链栈

#include 
#include 
typedef int ElemType;
typedef struct LNode{
	ElemType data;
	struct LNode *next;
}LNode, *LinkList;
void InitStrack(LinkList &LS) {
	LS->next = NULL;
}
int StackEmpty(LinkList LS) {
	if (LS->next == NULL)
		return 1;
	return 0;

}
void push(LinkList &LS, ElemType e) {
	LinkList s= (LinkList)malloc(sizeof(LNode));
	s->data = e;
	s->next = LS;
	LS = s;
}
void pop(LinkList &LS, ElemType &e) {
	if (LS->next == NULL)
		return;
	e = LS->data;
	LinkList s = LS; LS = LS->next;
	free(s);

}
void GetElem(LinkList LS, ElemType e) {
	if (LS->next == NULL)
		return;
	e = LS->data;
	
}

循环队列

#include 
#include 
#define QMAXSIZE 100
typedef int QElemType;
typedef struct {
	QElemType *base;
	int front, rear;
}CqQueue;
void InitQueue(CqQueue &Q) {
	Q.base = (QElemType*)malloc(QMAXSIZE*sizeof(QElemType));
	if (!Q.base)
		return;
	Q.front = Q.rear = 0;
}
int QueueEmpty(CqQueue Q) {
	if (Q.front == Q.rear)
		return 1;
	return 0;
}
int QueueLength(CqQueue Q) {
	return (Q.rear - Q.front + QMAXSIZE) % QMAXSIZE;
}
void EnQueue(CqQueue &Q, QElemType e) {
	if ((Q.rear + 1) % QMAXSIZE == Q.front)
		return;
	Q.base[Q.rear] = e;
	Q.rear = (Q.rear + 1) % QMAXSIZE;

}
void DeQueue(CqQueue &Q, QElemType &e) {
	if (Q.rear== Q.front)
		return;
	e = Q.base[Q.front];
	Q.front = (Q.front + 1) % QMAXSIZE;
}

链队列

#include 
#include 
typedef int QElemType;
typedef struct QNode {
	QElemType data;
	struct QNode *next;
}QNode, *QueuePtr;
typedef struct {
	QueuePtr front;
	QueuePtr rear;
}LinkQueue;
void InitQueue(LinkQueue &Q) {
	Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));
	if (!Q.front)
		return;
	Q.front->next = NULL;

}
int QueueEmpty(LinkQueue Q) {
	if (Q.front = Q.rear)
		return 1;
	return 0;

}
void EnQueue(LinkQueue &Q, QElemType e) {
	QueuePtr s = (QueuePtr)malloc(sizeof(QNode));
	s->data = e; s->next = NULL;
	Q.rear->next = s;
	Q.rear = s;

}
void DeQueue(LinkQueue &Q, QElemType e) {
	if (Q.front == Q.rear)
		return;
	QueuePtr s = (QueuePtr)malloc(sizeof(QNode));
	s = Q.front->next; e = s->data;
	Q.front->next = S.next;  //处理头指针
	if (Q.rear == Q.front->next)	//处理尾指针
		Q.rear = Q.front;
	free(s);
}