《大话数据结构》第四章栈与队列学习笔记

《大话数据结构》第四章栈与队列学习笔记

顺序栈–进栈

/*插入元素e为新的栈顶元素*/
Status Push(SqStack *S, SElemType e)
{
    if(S->top == MAXSIZE －1)  /*栈满*/
    {
       return ERROR;
    }
    S->top++;                  /*栈顶指针增加一*/
    S->data[S->top]=e;         /*将新插入元素赋值给栈顶空间*/
    return OK;
}

顺序栈–出栈

/*若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK;否则返回ERROR*/
Status Pop(SqStack *S, SElemType *e)
{
    if(S->top == －1)  /*空栈*/
    {
       return ERROR;
    }
    *e=S->data[S->top];        /*将要删除的栈顶元素赋值给e*/
    S->top－－;                  /*栈顶指针减一*/
    return OK;
}

两栈共享空间–插入

/*插入元素e为新的栈顶元素*/
Status Push(SqDoubleStack *S, SElemType e， int stackNumber)
{
    if (S->top1+1 == S->top2)     /*栈满*/
    {
       return ERROR;
    }
    if（stackNumber == 1）;       /*栈1有元素进栈*/
      S->data[++S->top1]=e;      /*若栈1则先top1+1后给数组元素赋值*/ 
    else if （stackNumber==2）   /*栈2有元素进栈*/
      S->data[－－S->top2]=e;   /*若栈2则先top2－1后给数组元素赋值*/
    return OK;
}

两栈共享空间–删除

/*若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK;否则返回ERROR*/
Status Pop(SqDoubleStack *S, SElemType *e，int stackNumber)
{
    if  (stackNumber==1)           /*若栈1*/
    {
        if(S->top1==﹣1)
          return ERROR;            /*栈1为空栈，溢出*/ 
        *e=S->data[S->top1－－]；  /*栈1栈顶元素出栈*/  
    }
    else if （stackNumber==2）
    {
        if (S->top2==MAXSIZE)
          return ERROR;           /*栈2为空栈，溢出*/
        *e=S->data[S->top2++];    /*栈2栈顶元素出栈*/
    }
    return OK;
}

链栈–进栈

/*插入元素e为新的栈顶元素*/
Status Push(LinkStack *S, SElemType e)
{
    LinkStackPtr s=（LinkStackPtr）malloc（sizeof
    （StackNode））;             
    s->data=e;                 /*生成新结点s并赋值为e*/
    s->next=S->top;            /*把当前的栈顶元素赋值给新结点的直接后继*/
    S->top=s;                   /*将新结点s赋值给栈顶指针*/
    S->count++;
    return OK;
}

链栈–出栈

/*若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK;否则返回ERROR*/
Status Pop(LinkStack *S, SElemType *e)
{
    LinkStackPtr p;
    if(StackEmpty(*S))
       return ERROR;
    *e=S->top->data;
    p=S->top;                   /*将栈顶结点赋值给p*/
    s->top=S->top->next;        /*使得栈顶指针下移一位*/
    free（p）;                  /*释放结点p*/
    S->count－－;
    return OK;
}

栈的递归–斐波那契函数

/*斐波那契的递归函数*/
int Fbi（int i）
{
   if（i<2）
      return i == 0 ? 0 : 1;
   return Fbi(i－1)+ Fbi（i－2）;
}
int main()
{
    int i;
    for(int i = 0;i < 40;i++)
       printf("%d",Fbi(i));
    return 0;
}

循环队列–入队

/*若队列未满，则插入元素e为Q新的队尾元素*/
Status EnQueue(SqQueue *Q,QElemType e)
{
    if((Q->rear+1)%MAXSIZE == Q->front)    /*队列满的判断*/
      return ERROR;
    Q->data[Q->rear]=e;                    /*将元素e赋值给队尾*/
    Q->rear=(Q->rear+1)%MAXSIZE;           /*rear指针后移一位，若到最后则转到数组头部*/

    return OK;
}

循环队列–出队

/*若队列不空，则删除Q中队头元素，用e返回其值*/
Status DeQueue(SqQueue *Q,QElemType *e)
{
    if(Q->rear == Q->front)          /*队列空的判断*/
      return ERROR;
    *e=Q->data[Q->front];            /*将队头元素赋值给e*/
    Q->front=(Q->front+1)%MAXSIZE;   /*front指针后移一位，若到最后则转到数组头部*/

    return OK;
}

链式队列–入队

/*插入元素e为Q的新的队尾元素*/
Status EnQueue(LinkQueue *Q,QElemType e)
{
    QueuePtr s=(QueuePtr)malloc(sizeof(QNode)); 
    if(!s)                        /*存储分配失败*/
       exti(OVERFLOW);
    s->data=e;
    s->next=NULL;
    Q->rear->next=s;              /*将结点s赋值给原队尾结点的后继*/
    Q->rear=s;                    /*把结点s设置为队尾结点*/

    return OK;
}

链式队列–出队

/*若队列不空，删除Q的队头元素，用e返回其值，并返回OK,否则返回ERROR*/
Status DeQueue(LinkQueue *Q,QElemType *e)
{
    QueuePtr p
    if(Q->front==Q->rear) 
       return ERROR;   
    p=Q->front->next;             /*将欲删除的队头结点暂存给p*/                     
    *e=p->data;                   /*将欲删除队头结点的值赋值给e*/
   Q->front->next=p->next;        /*将p的后继赋值给头结点后继*/
   if（Q->rear==p）
       Q->rear=Q->front;          /*若队头是队尾，则删除后rear指向头结点*/
   free(p);       

    return OK;
}