18版考研数据结构天勤课后习题代码-栈和队列【完】

#include 
using namespace std;
#define maxSize 101
//括号匹配 天勤P61 例3-1
/*
char data[101];
int top=-1;
int match(char exp[],int n)
{
    for(int i=0;i>n;
    for(int i=0;i>exp[i];
    }
    int d=match(exp,n);
    cout<=0&&exp[i]-'0'<=9)
        {
            data[++top]=exp[i]-'0';
        }
        else if(exp[i]=='*')
        {
            int a=data[top--];
            int b=data[top--];
            int c=a*b;
            data[++top]=c;
        }
        else if(exp[i]=='+')
        {
            int a=data[top--];
            int b=data[top--];
            int c=a+b;
            data[++top]=c;
        }
        else if(exp[i]=='-')
        {
            int a=data[top--];
            int b=data[top--];
            int c=b-a;
            data[++top]=c;
        }
        else if(exp[i]=='/')
        {
            int a=data[top--];
            int b=data[top--];
            int c=b/a;
            if(a==0)
            {
                return 0;
            }
            else
            {
                data[++top]=c;
            }
        }
        //cout<>exp[j];
        //cout<next=NULL;
    p->data=d;
    p->next=list;
    list=p;
}
int pop(struct LNode *&list)
{
    if(IsEmpty(list))
    {
        return 0;
    }
    else
    {
        int d;
        d=list->data;
        struct LNode *p;
        p=list;
        list=p->next;
        free(p);
        return d;
    }
}
int main()
{
    struct LNode *list;
    InitStack(list);
    push(list,1);
    push(list,2);
    int d1=pop(list);
    int d2=pop(list);
    cout<top==maxSize)
        return;
    else
    {
        s->top++;
        s->data[s->top]=d;
    }

}
void pop(SqList *&s,int &d)  //出栈
{
    if(s->top==-1)
        return;
    else
    {
        d=s->data[s->top];
        s->top--;
    }
}
int isEmpty(SqList *s)
{
    if(s->top==-1)
        return 1;
    else
    {
        return 0;
    }
}
void enQueue(SqList *&s1,SqList *&s2,int p)
{
    if(s1->top==maxSize)
    {
        if(s2->top==maxSize)
            return;
        else
        {
            while(s1->top!=-1)
            {
                int d;
                pop(s1,d);
                push(s2,d);
            }
            push(s1,p);
        }
    }
    else
    {
        push(s1,p);
    }
}
void deQueue(SqList *&s1,SqList *&s2,int &p)
{
    if(s2->top!=-1)
    {
        p=s2->data[s2->top];
        s2->top--;
    }
    else
    {
        while(s1->top!=-1)
        {
            int d;
            pop(s1,d);
            push(s2,d);
        }
        pop(s2,p);
    }
}
int isQueueEmpty(SqList *s1,SqList *s2)
{
    if(s1->top==-1&&s2->top==-1)
        return 1;
    else
        return 0;
}
int main()
{
    SqList *s1=(SqList* )malloc(sizeof(SqList));
    s1->top=-1;
    SqList *s2=(SqList* )malloc(sizeof(SqList));
    s2->top=-1;
    for(int i=0;i<5;i++)
    enQueue(s1,s2,i);
    int x;
    for(int i=0;i<4;i++)
    {
        if(!isQueueEmpty(s1,s2))
        {
            deQueue(s1,s2,x);
        }
        cout<>n;
    for(int i=0;i>ch[i];
    }
    int flag=Judge(ch,n);
    cout<data=d;
    p->next=rear->next;
    rear->next=p;
    rear=p;
    //cout<next!=rear)
    {
        LQueue *q=rear->next;
        LQueue *s=rear->next->next;
        //cout<data;
        q->next=s->next;
        //cout<next;
        free(s);
    }
}
int main()
{
    LQueue *q=(LQueue*)malloc(sizeof(LQueue));
    q->next=q;
    EnQueue(q,3);
    EnQueue(q,5);
    EnQueue(q,6);
    int d=0;
    DeQueue(q,d);
    DeQueue(q,d);
    DeQueue(q,d);
    cout<rear+1!=q->front)
    {
        q->front=(q->front-1+maxSize)%maxSize;
        q->data[q->front]=d;
    }
}
void DeQueue(Queue *&q,int &d)
{
    if(q->front!=q->rear)
    {
        q->rear=(q->rear-1+maxSize)%maxSize;
        d=q->data[q->rear];
    }
}
int main()
{
    Queue *q=(Queue*)malloc(sizeof(Queue));
    q->rear=q->front=1;
    int d;
    EnQueue(q,1);
    EnQueue(q,2);
    EnQueue(q,3);
    DeQueue(q,d);
    cout<front==q->rear&&q->tag==1) {
        return;
    }
    else{
        q->data[q->rear]=d;
        q->rear=(q->rear+1)%maxSize;
        q->tag=1;
    }
}
void DeQueue(Queue *&q,int &d)
{
    if(q->front==q->rear&&q->tag==0)
    {
        return;
    }
    else
    {
        d=q->data[q->front];
        q->front=(q->front+1)%maxSize;
        if(q->front==q->rear)
        {
            q->tag=0;
        }
    }
}
int main()
{
    Queue *q=(Queue*)malloc(sizeof(Queue));
    q->front=q->rear=0;
    q->tag=0;
    EnQueue(q,1);
    EnQueue(q,2);
    EnQueue(q,3);
    int d;
    DeQueue(q,d);
    cout<
int Calu(int N)
{
    stacks;
    int k=0;
    while(N!=0)
    {
        s.push(N%2);
        N=N/2;
    }
    while(!s.empty())
    {
        int x=s.top();
        s.pop();
        k=k*10+x;
    }
    return k;
}
int main()
{
    int n;
    cin>>n;
    int a[101];
    int k=0;
    k=Calu(n);
   cout<