数据结构栈和队列的基本操作

前言

因为这一篇是一次性打完的用到相同的define就没有一个个打出来。

#define MAXSIZE 100
#define OVERFLOW 0
#define OK 1

栈

顺序栈的表示和实现

顺序栈的存储结构

#define MAXSIZE 100//顺序栈存储空间的初始分配量
typedef struct
{
    int *base;//栈底指针
    int *top;//栈顶指针
    int stacksize;//栈可用的最大容量
}SqStack;

顺序栈中基本操作的实现

1、顺序栈的初始化

int InitStack(SqStack *S)
{//构造一个空栈S
    S->base=(int*)malloc(MAXSIZE*sizeof(int));
    if(!S->base)exit(OVERFLOW);
    S->top=S->base;
    S->stacksize=MAXSIZE;
    return OK;
}

2、入栈

int Push(SqStack *S,int e)
{
    if(S->top-S->base==S->stacksize)return OVERFLOW;
    *S->top++=e;
    return OK;
}

3、出栈

int pop(SqStack *S)
{
    int e;
    if(S->top==S->base)return OVERFLOW;
    e=*--S->top;
    return e;
}

4、取栈顶元素

int GetTop(SqStack S)
{
    if(S.top!=S.base)
        return *(S.top-1);
}

链栈的表示和实现

链栈的存储结构

typedef struct StackNode
{
    int data;
    struct StackNode *next;
}StackNode,*LinkStack;

链栈中基本操作的实现

1、初始化

int InitStack(LinkStack S)
{
    S=NULL;
    return OK;
}

2、入栈

int Push(LinkStack S,int e)
{
    LinkStack p;
    p=(StackNode*)malloc(sizeof(StackNode));
    p->data=e;
    p->next=S;
    S=p;
    return OK;
}

3、出栈

int pop(LinkStack S)
{
    int e;
    if(S==NULL)return OVERFLOW;
    e=S->data;
    LinkStack p;
    p=S;
    S=S->next;
    free(p);
    return e;
}

4、取栈顶元素

int GetTop(LinkStack S)
{
    if(S!=NULL)
        return S->data;
}

队列

队列的链式表示和实现

链队的存储结构

typedef struct QNode
{
    int data;
    struct QNode *next;
}QNode,*QueuePtr;
typedef struct
{
    QueuePtr front;
    QueuePtr rear;
}LinkQNode;

链队中基本操作的实现

1、链队的初始化

int InitQueue(LinkQNode Q)
{
    Q.front=Q.rear=(QNode*)malloc(sizeof(QNode));
    Q.front->next=NULL;
    return OK;
}

2、入队

int EnQueue(LinkQNode Q,int e)
{
    QueuePtr p;
    p=(QNode*)malloc(sizeof(QNode));
    p->data=e;
    p->next=NULL;Q.rear->next=p;
    Q.rear=p;
    return OK;
}

3、出队

int DeQueue(LinkQNode Q)
{
    if(Q.front==Q.rear)return OVERFLOW;
    QueuePtr p;
    p=Q.front->next;
    int e;
    e=p->data;
    Q.front->next=p->next;
    if(Q.rear==p)Q.rear=Q.front;
    free(p);
    return e;
}

4、取队头元素

int GetHead(LinkQNode Q)
{
    if(Q.front!=Q.rear)
        return Q.front->next->data;
}

循环队列——队列的顺序表示和实现

队列的顺序存储结构

typedef struct
{
    int *base;
    int front;
    int rear;
}SqQueue;

循环队列中基本操作的实现

1、初始化

int InitQueue(SqQueue *Q)
{
    Q->base=(int*)malloc(MAXSIZE*sizeof(int));
    if(!Q->base)exit(OVERFLOW);
    Q->front=Q->rear=0;
    return OK;
}

2、求队列长度

int QueueLength(SqQueue Q)
{
    return (Q.rear-Q.front+MAXSIZE)%MAXSIZE;
}

3、入队

int EnQueue(SqQueue *Q,int e)
{
    if((Q->rear+1)%MAXSIZE==Q->front)
        return OVERFLOW;
    Q->base[Q->rear]=e;
    Q->rear=(Q->rear+1)%MAXSIZE;
    return OK;
}

4、出队

int DeQueue(SqQueue *Q,int *e)
{
    if(Q->front==Q->rear)return OVERFLOW;
    e=Q->base[Q->front];
    Q->front=(Q->front+1)%MAXSIZE;
    return OK;
}

5、取队头元素

int GetHead(SqQueue Q)
{
    if(Q.front!=Q.rear)
        return Q.base[Q.front];
}

结语

完整打下来感觉大部分问题都在上一篇博客里解决了，有很多不懂的小伙伴可以看我上一篇博客。然后可能函数的传参是个难点，容易懵，下一篇专门研究这个问题。已完成函数传参详解。