73.有关栈队列的算法实现

承接上次状态不佳整理的有关栈队列的总结
https://www.cnblogs.com/gaodiyuanjin/p/18424324
作补充 关于算法的实现 主要就是栈和队列的顺序存储和链式存储

顺序栈

初始化栈顶指针：
S.top=-1; //S.top=0
//入栈
bool Push(SqStack &S,ElemType x){
    if(S.top==MaxSize-1)       //栈满
        return false;
    S.data[++S.top]=x; //S.data[S.top++]=x;
    return true;
}
//出栈
bool Pop(SqStack &S,ElemType x){
    if(S.top==-1)       //栈空
        return false;
    x=S.data[S.top--];  //x=S.data[--S.top];  
    return true;
}

链栈

不带头结点的链栈
// 入栈操作
bool Push(Stack *S, ElemType x) {
    Node *p = (Node *)malloc(sizeof(Node));
    p->data = x;
    p->next = S->top;
    S->top = p;
    return true;
}
// 出栈操作
bool Pop(Stack *S, ElemType x) {
    if (S->top == NULL) {  //栈空
        return false;
    }
    Node *p = S->top;
    x = p->data;
    S->top = p->next;
    free(p);
    return true;
}

带头结点的链栈
// 入栈操作
bool Push(Stack *S, ElemType x) {
    Node *p = (Node *)malloc(sizeof(Node));
    p->data = x;
    p->next = S->header->next;
    S->header->next = p;
    return true;
}
// 出栈操作
bool Pop(Stack *S, ElemType x) {
    if (S->header->next == NULL) {  //栈空
        return false;
    }
    Node *p = S->header->next;
    x = p->data;
    S->header->next = p->next;
    free(p);
    return true;
}

队列的顺序存储

// 入队操作
bool Enqueue(SeqQueue *Q, ElemType x) {
    if ((Q->rear + 1) % MaxSize == Q->front) {  //队满
        return false;
    }
    Q->data[Q->rear] = x;
    Q->rear = (Q->rear + 1) % MaxSize;
    return true;
}

// 出队操作
bool Dequeue(SeqQueue *Q, ElemType x) {
    if (Q->front == Q->rear) {  //队空
        return false;
    }
    x = Q->data[Q->front];
    Q->front = (Q->front + 1) % MaxSize
    return true;
}

循环队列的顺序存储

初始化：
Q.rear=Q.front=0;
//入队
bool EnQueue(SqQueue &Q,ElemType x){
    if((Q.rear+1)%MaxSize==Q.front)    //队满
        return false;
    Q.data[Q.rear]=x;
    Q.rear=(Q.rear+1)%MaxSize;
    return true;
}
//出队
bool DeQueue(SqQueue &Q,ElemType &x){
    if(Q.rear==Q.front)     //队空
        return false;
    x=Q.data[Q.front];
    Q.front=(Q.front+1)%MaxSize;
    return true;
}

队列的链式存储

带头结点
初始化：
Q.front=Q.rear=(LinkNode*)malloc(sizeof(LinkNode));
Q.front->next=NULL;
//入队
void EnQueue(LinkQueue &Q,ElemType x){
    LinkNode *s=(LinkNode*)malloc(sizeof(LinkNode));
    s->data=x;
    s->next=NULL;
    Q.rear->next=s;
    Q.rear=s;
}
//出队
bool DeQueue(LinkQueue &Q,ElemType x){
    if(Q.front==Q.rear)     //空队
        return false;
    LinkNode *p=Q.front->next;
    x=p->data;
    Q.front->next=p->next;
    if(Q.rear==p)  //队列只有一个结点 删除后变为空
        Q.rear=Q.front;
    free(p);
    return true;
}

不带头结点
初始化：
Q.front = NULL;
Q.rear = NULL;
//入队
void EnQueue(LinkQueue &Q,ElemType x){
    LinkNode *s=(LinkNode*)malloc(sizeof(LinkNode));
    s->data=x;
    s->next=NULL;
    if(Q.rear == NULL){  //队空
        Q.front = s;
        Q.rear = s;
    }else{
        Q.rear->next=s;
        Q.rear=s;
    }
}
//出队
bool DeQueue(LinkQueue &Q,ElemType x){
    if(Q.front==NULL)     //空队
        return false;
    LinkNode *p=Q.front;
    x=p->data;
    Q.front=p->next;
    if(Q.front==NULL)  //队列变为空
        Q.rear=NULL;
    free(p);
    return true;
}