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

数组栈

完成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‐‐;
}