栈与队列的基本操作

//顺序栈进栈操作
bool puch(SqStack &S,ElemType x){
    if(s.top==s.length){
        return false;
    }
    S.data[++S.top]=x;//指针先加一元素再入栈
    return true;
}
//顺序栈出栈
bool pop(SqStack &S,ElemType &x){
    if(S.top==-1){
        return false;
    }
    x=S.data[s.top--];//先出栈，指针在减一
    return true;
}
//读取栈顶元素

bool gettop(SqStack &S,ElemType &x){
     if(S.top==-1){
        return false;
    }
    x=S.data[s.top];
    return true;
}

//链栈操作   采用链式存储结构便于结点的插入与删除，链栈的操作和链表类似，入栈和出栈的操作都是链表的表头进行
//链栈没有头结点
//入栈
bool Push(LinkStack &s,int x){
    if(s==NULL){//空栈    则此时入栈即为第一个元素
        s=(LinkStack)malloc(sizeof(LSNode));
        s->data=x;
        s->next=NULL;
        return true;
    }

    LSNode *p=(LSNode *)malloc(sizeof(LSNode));
    //偷天换日  用后插的方法来实现前插，即实现入栈
    p->data=s->data;
    p->next=s->next;
    s->next=p;
    s->data=x;
    return true;
}
//出栈
bool Pop(LinkStack &s,int &x){
    if(s==NULL){
        printf("s==NULL\n");
        return false;
    }
    LSNode *p=s;
    s=s->next;
    x=p->data;
    free(p);
    p=NULL;
    return true;
}
//读取栈顶元素
bool GetTop(LinkStack s, int &x){
    if(s==NULL){
        printf("空栈\n");
        return false;
    }
    x=s->data;
    return true;
}
//输出栈里的元素
bool PrintStack(LinkStack s){
    if(s==NULL){
        return false;
    }
    LSNode *p=s;
    while(p!=NULL){
        printf("%d ",p->data);
        p=p->next;
    }
    return true;
}


//顺序结构共享栈的基本操作
//入栈
int push(int i,int x){//入栈操作。i表示栈号。入栈成功返回1，失败返回0
    if(i<0||i>1){//输入栈号错误
        return 0;
    }
    if(s.top[1]-s.top[0]==1){
        return 0;//栈满
    }
    switch(i){
        case 0:s.data[++s.top[0]]=x; return 1; break;
        case 1:s.data[--s.top[1]]=x; return 1; 
    }

}

//出栈
int pop(int i){
     if(i<0||i>1){
        return 0;
    }
    switch (i)
    {
    case 0:
        if(s.top[0]==-1){
            return 0;
        }else
            return s.data[s.top[0]--];
    case 1:
        if(s.top[1]==maxsize){
            return 0;
        }else
            return s.data[s.top[1]++];
    }
}


//循环队列（顺序结构）的操作
//入队
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;  //队尾指针加1
    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;  //队尾指针加1
    return true;
}

//在循环队列的类型结构中，增设一个tag的整型变量，进队时置tag为1，出队置为0；
//设“tag”法的循环队列入队操作
bool EnQueue(SqQueue &Q,ElemType x){
    if(Q.rear==Q.front&&Q.tag==1)  //队满报错
    return false;
    Q.data[Q.rear]=x;
    Q.rear=(Q.rear+1)%maxsize;  //队尾指针加1
    Q.tag==1;//可能队满
    return true;
}
//设“tag”法的循环队列出队操作
bool DeQueue(SqQueue &Q,ElemType &x){
    if(Q.rear==Q.front&&Q.tag==0)  //队空报错
    return false;
    x=Q.data[Q.front];
    Q.front=(Q.front+1)%maxsize;  //队尾指针加1
    Q.tag==0;
    return true;
}

//链式队列的基本操作（带头结点）
//入队
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.rear==Q.front)  //队空
    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;
}