数据结构栈和队列c语言实现

1.编写函数，采用链式存储实现栈的初始化、入栈、出栈的操作。
2.编写函数，采用顺序存储实现栈的初始化、入栈、出栈的操作。
3.编写函数，采用链式存储实现队列的初始化、入队、出队的操作。
4.编写函数，采用顺序存储实现队列的初始化、入队、出队的操作。
5.编写一个主函数，在主函数中设计一个简单的菜单，分别调试上述算法。

#include<stdio.h>
#include<stdlib.h>
#define Stake_size 50
#define FALSE -1
#define TRUE 1
//采用链式存储实现栈的初始化、入栈、出栈操作
typedef struct node
{
    int data;
    struct node *next;
}LinkStackNode;

typedef LinkStackNode* LinkStack;
//链栈初始化
void InitLinkStack(LinkStack* S)
{
    *S = (LinkStack)malloc(sizeof(LinkStackNode));
    (*S)->next = NULL;
}
//链栈进栈
int PushLinklist(LinkStack S, int x)
{
    LinkStackNode *temp;
    temp = (LinkStackNode*)malloc(sizeof(LinkStackNode));
    if(temp == NULL)
    {
        return (FALSE);
    }
    temp->data = x;
    temp->next = S->next;
    S->next = temp;
    return (TRUE);
}
//链栈出栈
int PopLink(LinkStack S, int* x)
{
    LinkStackNode * temp;
    temp = S->next;
    if(temp==NULL)
    {
        return (FALSE);
    }
    S->next = temp->next;
    *x = temp->data;
    free(temp);
    return(FALSE);
}

//采用顺序存储实现栈的初始化、入栈、出栈操作
typedef struct
{
    int elem[Stake_size];
    int top;
}SeqStack;
//初始化顺序栈
void InitStack(SeqStack *S)
{
    S->top = -1;
}
//顺序栈进栈操作
int Push(SeqStack *S, int x)
{
    if(S->top==Stake_size-1)
    {
        return (FALSE);
    }
    S->top++;
    S->elem[S->top] = x;
    return (TRUE);
}
//顺序栈出栈操作
int Pop(SeqStack *S, int * x)
{
    if(S->top == -1)
    {
        return (FALSE);
    }
    else
    {
        *x = S->elem[S->top];
        S->top--;
        return (TRUE);
    }
}
//返回栈顶元素
int GetTop(SeqStack *S)
{
    if(S->top == -1)
    {
        return(FALSE);
    }
    else
    {
        return S->elem[S->top];
    }
}
//采用链式存储实现队列的初始化、入队、出队操作
typedef struct
{
    int data;
    struct Node *next;
}LinkQueueNode;

typedef struct
{
    LinkQueueNode *front;
    LinkQueueNode *rear;
}LinkQueue;
//链队列初始化
int InitLinkQueue(LinkQueue *Q)
{
    Q->front = Q->rear = (LinkQueueNode*)malloc(sizeof(LinkQueueNode));
    if(Q->front!=NULL)
    {
        Q->rear = Q->front;
        Q->front->next =NULL;
        return (TRUE);
    }
    else
        return (FALSE);
}
//链队列入队
int EnterLinkQueue(LinkQueue*Q,int x)
{
    LinkQueueNode *NewNode;
    NewNode = (LinkQueueNode*)malloc(sizeof(LinkQueue));
    if(NewNode!=NULL)
    {
        NewNode->data = x;
        NewNode->next = NULL;
        Q->rear->next = NewNode;
        Q->rear = NewNode;
        return (TRUE);
    }
    else
    {
        return(FALSE);
    }
}
//链队列出队
int DeletLinkQueue(LinkQueue *Q, int * x)
{
    LinkQueueNode * p;
    if(Q->front==Q->rear)
    {
        return (FALSE);
    }
    p = Q->front->next;
    Q->front->next = p->next;
    *x = p->data;
    free(p);
    return (TRUE);
}
//采用顺序存储实现队列的初始化、入队、出队操作
typedef struct SeqQueue
{
    int data[Stake_size];
    int front,rear;
}SeqQueue;
//初始化
void InitQueue(SeqQueue*Q)
{
    Q->front = Q->rear = 0;
    for(int i=0;i<Stake_size;i++){
            Q->data[i]=0;
    }
}
//入队
int EnterQueue(SeqQueue *Q, int x)
{
    if((Q->rear+1)%Stake_size==Q->front)
    {
        return (FALSE);//队满
    }
    Q->data[Q->rear] = x;
    Q->rear=(Q->rear+1)%Stake_size;
    return(TRUE);
}
//出队
int DeletQueue(SeqQueue *Q, int*x)
{
    if(Q->front==Q->rear)
    {
        return (FALSE);//队空
    }
    *x = Q->data[Q->front];
    Q->data[Q->front] = 0;
    Q->front = (Q->front+1)%Stake_size;
    return (TRUE);
}
int main()
{
    int*a,*b,*c,*d;
    a = b = c = d = (int*)malloc(sizeof(int));
    int m;
    int z;
    //顺序队列
    SeqQueue t;
    //链队列
    LinkQueue * r;
    r = (LinkQueue*)malloc(sizeof(LinkQueue));
    //顺序栈
    SeqStack * s;
    s = (SeqStack*)malloc(sizeof(SeqStack));
    //链栈
    LinkStack q;
    InitQueue(&t);
    InitStack(s);
    InitLinkQueue(r);
    InitLinkStack(&q);
    while(1)
    {
        printf("--------------1.顺序队列------------------\n");
        printf("--------------2.顺序栈--------------------\n");
        printf("--------------3.链队列--------------------\n");
        printf("--------------4.链栈----------------------\n");
        printf("--------------5.退出----------------------\n");
        printf("请输入需要进行的操作:\n");
        scanf("%d",&m);
        if(m==1)
        {
            printf("--------------1.入队----------------------\n");
            printf("--------------2.出队----------------------\n");
            printf("--------------3.初始化----------------------\n");
            printf("请输入进行的操作\n");
            scanf("%d",&m);
            if(m==1)
            {
                printf("请输入入队元素\n");
                scanf("%d",&z);
                EnterQueue(&t,z);
            }
            else if (m==2)
            {
                DeletQueue(&t, c);
                printf("出队元素为:%d\n",*c);
            }
            else if(m==3)
            {
                InitQueue(&t);
            }
            else
            {
                printf("输入错误\n");
                break;
            }
        }
        else if (m==2)
        {
            printf("--------------1.入栈----------------------\n");
            printf("--------------2.出栈----------------------\n");
            printf("--------------3.初始化----------------------\n");
            printf("请输入进行的操作\n");
            scanf("%d",&m);
            if(m==1)
            {
                printf("请输入入栈元素\n");
                scanf("%d",&z);
                Push(s,z);
            }
            else if(m==2)
            {
                Pop(s,b);
                printf("出栈元素为%d\n",*b);
            }
            else if (m==3)
            {
                InitStack(s);
            }
            else
            {
                printf("输入错误\n");
                break;
            }
        }
        else if (m==3)
        {
            printf("--------------1.入队----------------------\n");
            printf("--------------2.出队----------------------\n");
            printf("--------------3.初始化----------------------\n");
            printf("请输入进行的操作\n");
            scanf("%d",&m);
            if (m==1)
            {
                printf("请输入入队元素\n");
                scanf("%d",&z);
                EnterLinkQueue(r,z);
            }
            else if(m==2)
            {
                DeletLinkQueue(r,c);
                printf("出队元素为:%d\n",*c);
            }
            else if(m==3)
            {
                InitLinkQueue(r);
            }
            else
            {
                printf("输入错误\n");
                break;
            }
        }
        else if (m==4)
        {
            printf("--------------1.入栈----------------------\n");
            printf("--------------2.出栈----------------------\n");
            printf("--------------3.初始化----------------------\n");
            printf("请输入进行的操作\n");
            scanf("%d",&m);
            if (m==1)
            {
                printf("请输入入栈元素\n");
                scanf("%d",&z);
                PushLinklist(q,z);
            }
            else if(m==2)
            {
                PopLink(q,d);
                printf("出栈元素为:%d\n",*d);
            }
            else if(m==3)
            {
                InitLinkStack(&q);
            }
            else
            {
                printf("输入错误\n");
                break;
            }
        }
        else if(m==5)
        {
            printf("退出成功\n");
            break;
        }
        else
        {
            printf("输入错误\n");
            break;
        }
    }
    return 0;
}