栈和队列的基本操作代码实现

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 100
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFESIBLE -1
#define OVERFLOW -2
typedef int status;
typedef char SElemType;
typedef char QElemType;
//顺序栈
typedef struct 
{
    SElemType *base;
    SElemType *top;
    int stacksize;   //栈可用最大容量
}SqStack;
//初始化
status InitStack(SqStack *S){
    S->base =(SElemType*)malloc(sizeof(SElemType)*MAXSIZE);
    if(!S->base)exit (OVERFLOW);  //分配失败
    S->top = S->base;
    S->stacksize = MAXSIZE;
    return OK;
}
//判断栈空
status  IsEmptyStack(SqStack S){
    if(S.base == S.top) return TRUE;
    else return FALSE;
}
//求栈长
int StackLength(SqStack S){
    return S.top-S.base;
}
//清空栈 栈还存在
static ClearStack(SqStack *S){
    if(S->base) S->top == S->base;
    return OK;
}
//销毁栈 栈不存在
status DestroyStack(SqStack *S){
    if(S->base){
        free(S->base);
        S->stacksize = 0;
        S->base = S->top = NULL;
    }
    return OK;
}
//入栈
status PushStack(SqStack *S,SElemType e){
    if(S->top-S->base == S->stacksize) return ERROR;   //判断是否栈满;
    *S->top = e;    //等价于 *S.top++ = x; 
    S->top++;
    return OK;
}
//出栈
status PopStack(SqStack *S,SElemType e){
    if(S->top == S->base)return ERROR; //判断是否 空栈
    S->top--;          // e = *--S.top;
    e = *S->top;
    return OK;
}
//取栈顶元素
status GetTopStack(SqStack S,SElemType e){
    if(S.base == S.top)return ERROR;
    return *(S.top-1);  //返回栈顶元素的值,栈顶指针不变
}
//----------------------------------------------------------------------------------------
//链栈
typedef struct StackNode
{
    SElemType data;
    struct StackNode *Next;
}StackNode,*LinkStack;
//初始化
status InitLinkStack(LinkStack S){
    S = NULL;
    return OK;
}
//判空
status IsEmptyLinkStack(LinkStack S){
    if(S == NULL) return TRUE;
    else return FALSE;
}
//入栈
status PushLinkStack(LinkStack S,SElemType e){
    LinkStack P = (StackNode*)malloc(sizeof(StackNode));
    P->data = e;
    P->Next = S;
    S = P;
    return OK;
}
//出栈
status POPLinkStack(LinkStack S,SElemType e){
    if(S == NULL) return ERROR;
    e = S->data;
    LinkStack P;   //用p临时保存栈顶元素空间, 以备释放;
    P = S;
    S = S->Next;
    free(P);
    return OK;
}
//取栈顶元素;
SElemType GetLinkStackTop(LinkStack S){  
    if(S == NULL)return ERROR;
    return S->data;  
}
//----------------------------------------------------------------------------------------
//顺序队列
typedef struct 
{
    QElemType *base;
    int front;
    int rear;
}SqQueue;
//初始化
status InitQueue(SqQueue *Q){  
    Q->base = (QElemType *)malloc(sizeof(QElemType)*MAXSIZE);
    if(!Q) exit(OVERFLOW);
    Q->front = Q->rear = 0;
    return OK;
}
//求长度
int LengthQueue(SqQueue Q){
    return ((Q.rear-Q.front+MAXSIZE)%MAXSIZE);
}
//入队
status EnQueue(SqQueue *Q,QElemType e){
    if((Q->rear+1)%MAXSIZE == Q->front) exit(OVERFLOW);  //判满
    Q->base[Q->rear] = e;
    Q->rear = (Q->rear+1)%MAXSIZE;    //达到maxsize又回到零;
    return 0;
}
//出队
status OutQueue(SqQueue *Q,QElemType e){
    if(Q->rear == Q->front) return ERROR;
    e = Q->base[Q->front];
    Q->front = (Q->front+1)%MAXSIZE;
    return OK;
}
status GetQueueFront(SqQueue Q,QElemType e){
    if(Q.front != Q.rear)return (Q.base[Q.rear]);  //队列非空则返回对头元素,队头指针不变;
}
//--------------------------------------------------------------------------------



//链队列
typedef struct QNode
{
    QElemType data;
    struct QNode *NEXt;
}QNode,*QueuePtr;

typedef struct 
{
    QueuePtr front;
    QueuePtr rear;
}LinkQueue;
//初始化
status InitLinkQueue(LinkQueue *Q){
    Q->front = Q->rear =(LinkQueue*)malloc(sizeof(QNode));
    if(!Q->front) return ERROR;
    Q->front->NEXt = NULL;
    return OK;
}
//销毁
 status DestroyQueue(LinkQueue *Q){
    while (Q->front)   //只要队头不为空,则一直循环.
    {
        LinkQueue *P = Q->front->NEXt;
        free(Q->front);
        Q->front = P;
    }
 }
 //入队
 status EnLinkQueue(LinkQueue *Q,QElemType e){
    QueuePtr P = (QueuePtr*)malloc(sizeof(QNode));
    P->data = e; 
    P->NEXt = NULL;
    Q->rear->NEXt = P;     //将新结点插到 队尾
    Q->rear = P;           //修改队尾指针 
 }
 //出队
 status OutLinkQueue(LinkQueue *Q,QElemType e){
    QueuePtr P;
    if(Q->front == Q->rear)return ERROR;
    P = Q->front->NEXt;
    e = Q->front->data;
    Q->front->NEXt=P->NEXt;
    if(Q->rear == P) Q->rear == Q->front;
    free(Q->front);
    return OK;
 }
 //取队头元素
 status GetLINkQueue(LinkQueue Q,QElemType e){
    if(Q.front == Q.rear)return ERROR;
    return (Q.front->NEXt->data);
 }