栈与队列--进/出-栈/队

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/z861269429/article/details/51774135

数组栈
完成void Push(Stack S,ElemType x)函数，该函数把数据x进栈，如果栈已满，则什么都不做。
完成void Pop(Stack S)函数，该函数把栈顶数据出栈，如果栈已空，则什么都不做。

typedef int ElemType;
struct StackRecord;
typedef struct StackRecord *Stack;
struct StackRecord
{
    int Capacity; //栈容量
    int Top; //栈顶，初始为1
    ElemType *Array;
};

void Push(Stack S,ElemType x)
{
    if(S‐>Top==S‐>Capacity‐1);
    else
    {
        S‐>Top++;
        S‐>Array[S‐>Top]=x;
    }
}
void Pop(Stack S)
{
    ElemType x;
    if(S‐>Top==‐1);
    else
    {
        x=S‐>Array[S‐>Top];
        S‐>Top‐‐;
    }
}

链栈
完成void Push(Stack S,ElemType x)函数，该函数把数据x进栈，已知S是带头结点的链栈。
完成void Pop(Stack S)函数，该函数把链栈S栈顶元素出栈，如果S已空，则什么都不做。已知S是带头结点的链栈。

typedef int ElemType;
struct Node;
typedef struct Node * PtrToNode;
typedef PtrToNode Stack;
struct Node
{
    ElemType data;
    PtrToNode next;
};

void Push(Stack S,ElemType x)
{
    Stack p=(Stack)malloc(sizeof(Stack));
    p‐>data=x;
    p‐>next=S‐>next;
    S‐>next=p;
}
void Pop(Stack S)
{
    Stack p=NULL;
    if(S‐>next==NULL);
    else
    {
        p=S‐>next;
        S‐>next=p‐>next;
        free(p);
    }
}

数组队列
完成void Enqueue(Queue Q,ElemType X)函数，该函数把数据X进入队列，如果队列已满，则什么都不做，其中Q是基于数组的非循环队列。
完成void Dequeue(Queue Q)函数，该函数将队列Q的队首数据出队，如果队列为空，则什么都不做。其中Q是基于数组的非循环队列。

typedef int ElemType;
struct QueueRecord;
typedef struct QueueRecord * Queue;
struct QueueRecord
{
    int Capacity; //队列总容量
    int Front; //队首 初始值为0
    int Rear; //队尾，初始值为1
    int Size; //队列中数据数，初始值为0
    ElemType *Array;
};

void Enqueue(Queue Q,ElemType X)
{
    if(Q‐>Rear==Q‐>Capacity‐1);
    else
    {
        Q‐>Rear++;
        Q‐>Array[Q‐>Rear]=X;
        Q‐>Size++;
    }
}
void Dequeue(Queue Q)
{
    if(Q‐>Size==0);
    else
    {
        Q‐>Front++;
        Q‐>Size‐‐;
    }
}

链队列
完成void Enqueue(Queue q,ElemType x)函数，该函数将数据x进入队列q，其中q是不带头节点的链表队列。
完成void Dequeue(Queue q)函数，该函数将非空队列q的队首数据出队并释放该数据的空间，其中q是不带头节点的链表队列。

typedef int ElemType;
struct node;
typedef struct node Node;
struct queue;
typedef struct queue * Queue;
struct node
{
    ElemType data;
    Node * next;
};
struct queue
{
    Node * front; //队首
    Node * rear; //队尾
    int size; //队列中数据数
};

void Enqueue(Queue q,ElemType x)
{
    Node *p;
    p=(Node *)malloc(sizeof(Node));
    p‐>data=x;
    p‐>next=NULL;
    if(q‐>front==NULL)
    {
        q‐>front=p;
        q‐>rear=p;
        q‐>size++;
        return;
    } 
    q‐>rear‐>next=p;
    q‐>rear=p;
    q‐>size++;
}
void Dequeue(Queue q)
{
    node *p=q‐>front;
    q‐>front=p‐>next;
    free(p);
    q‐>size‐‐;
}