04数据结构——栈与队列

偏执的太偏执、 2022-01-09 12:53 235阅读 0赞

## 4.2 栈的定义 ##

*  栈  
    **栈是限定仅在表尾进行插入和删除操作的线性表。**

我们把允许插入和删除的一端称为 **栈顶**，另一端称为 **栈底**，不含任何数据元素的栈称为 **空栈**。栈又称为后进先出的 **线性表**，简称 LIFO 结构。

栈的特殊之处在于它限制了这个线性表的插入和删除位置，它始终`只在栈顶进行`。

*  栈的插入操作，叫作`进栈`，也称`压栈`、`入栈`。
 *  栈的删除操作，叫作`出栈`，也有的叫作`弹栈`。

## 4.3 栈的抽象数据类型 ##

#### ![1542450-20190417101029578-617410486.png][] ####

## 4.4 栈的顺序存储结构及实现 ##

![1542450-20190417101216741-1889753993.png][]

![1542450-20190417101250896-236065112.png][]

![1542450-20190417101355795-313113527.png][]

![1542450-20190417101415528-1988805836.png][]

![1542450-20190417101506405-1813783402.png][]

## 4.6 栈的链式存储结构及实现 ##

![1542450-20190417101820615-2142899612.png][]

![1542450-20190417102002504-1272350373.png][]

![1542450-20190417101930270-665935447.png][]

![1542450-20190417102041558-1997857293.png][]

![1542450-20190417102103305-277924852.png][]![1542450-20190417102117779-1725031617.png][]

![1542450-20190417102307769-521390734.png][]

![1542450-20190417102324673-142824400.png][]

## 4.7 栈的应用 ##

**栈的引入简化了程序设计的问题，划分了不同关注层次，使得思考范围缩小，更加聚焦于我们要解决的问题核心。反之，像数组等，因为要分散精力去考虑数组的下标增减等细节问题，反而掩盖了问题的本质。**

所以现在很多高级语言，比如 Java、C\#等都有对栈结构的封装，你可以不用关注它的实现细节，就可以直接使用 Stack 的 push 和 pop 方法，非常方便。

##### 栈的应用——递归 #####

**在高级语言中，调用自己和其它函数没有本质的不同。我们把一个直接用自己或通过一系列的调用语句间接地调用自己的函数，称作递归函数。**

每个递归函数必须至少有一个条件，满足时递归不再执行，即不再引用自身而是返回值退出。

**递归和迭代的区别是**：迭代使用的是`循环结构`，递归使用的是`选择结构`。 递归能使程序的结构`更清晰、更简洁、更容易让人理解，从而减少读懂代码的时间`。但是大量的递归调用会建立函数的副本，`会耗费大量的时间和内存`。迭代则不需要反复调用函数和占用额外的内存。因此我们应该视不同情况选择不同的代码实现方式。

在前行阶段，对于每一层递归，函数的局部变量、参数值以及返回地址都被压入栈中。在退回阶段，位于栈顶的局部变量、参数值和返回地址被弹出，用于返回调用层次中执行代码的其余部分，也就是恢复了调用的状态。

## 4.10 队列定义 ##

*  队列  
    **队列是只允许在一端进行插入操作、而在另一端进行删除操作的线性表。**

**队列是一种先进先出的线性表，简称 FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。**假设队列是 q = (a1, a2, ……, an)，那么 a1 就是队头元素，而 an 就是队尾元素。我们在删除时，总是从 a1 开始；插入时，列在最后。

## 4.11 队列的抽象数据类型 ##

![1542450-20190417103803757-684830308.png][]

## 4.12 循环队列 ##

解决假溢出的办法就是后面满了，就再从头开始，也就是头尾相接的循环。我们把队列的这种头尾相接的顺序存储结构称为循环队列。

#### 4.12.1 队列顺序存储的不足 ####

![1542450-20190417104355914-563360887.png][] ![1542450-20190417104515924-1056934176.png][]

![1542450-20190417105127648-605737227.png][]

![1542450-20190417105258744-1327254623.png][]

![1542450-20190417105314768-880366425.png][]

![1542450-20190417105405006-406450862.png][]

![1542450-20190417105616559-366450638.png][]

![1542450-20190417105637632-2051783425.png][]

![1542450-20190417105738885-1622739119.png][]

![1542450-20190417105824162-414762260.png][]

![1542450-20190417105846080-1239908866.png][]

![1542450-20190417105939402-307215860.png][]

![1542450-20190417110011376-1458097249.png][]

![1542450-20190417110029568-498181541.png][]

![1542450-20190417110046266-1218071236.png][]

## 4.13 队列的链式存储结构及实现 ##

![1542450-20190417110933622-1434314415.png][]

![1542450-20190417110959710-22977476.png][]

![1542450-20190417111606370-1861508865.png][]

![1542450-20190417111622092-625406827.png][]

![1542450-20190417111636621-1872930378.png][]

![1542450-20190417111701394-1801288239.png][]

![1542450-20190417111715844-1899761129.png][]

![1542450-20190417111732469-556870158.png][]![1542450-20190417111753060-76076516.png][]

## **代码实现** ##

#### 01顺序栈 ####

![1542450-20190417123917363-2062409905.png][]

#### 02链栈 ####

#include "stdio.h"    
    #include "stdlib.h"   
    #include "io.h"  
    #include "math.h"  
    #include "time.h"
    
    #define OK 1
    #define ERROR 0
    #define TRUE 1
    #define FALSE 0
    #define MAXSIZE 20 /* 存储空间初始分配量 */
    
    typedef int Status; 
    typedef int SElemType; /* SElemType类型根据实际情况而定，这里假设为int */
    
    
    /* 链栈结构 */
    typedef struct StackNode
    {
            SElemType data;
            struct StackNode *next;
    }StackNode,*LinkStackPtr;
    
    
    typedef struct
    {
            LinkStackPtr top;
            int count;
    }LinkStack;
    
    Status visit(SElemType c)
    {
            printf("%d ",c);
            return OK;
    }
    
    /*  构造一个空栈S */
    Status InitStack(LinkStack *S)
    { 
            S->top = (LinkStackPtr)malloc(sizeof(StackNode));
            if(!S->top)
                    return ERROR;
            S->top=NULL;
            S->count=0;
            return OK;
    }
    
    /* 把S置为空栈 */
    Status ClearStack(LinkStack *S)
    { 
            LinkStackPtr p,q;
            p=S->top;
            while(p)
            {  
                    q=p;
                    p=p->next;
                    free(q);
            } 
            S->count=0;
            return OK;
    }
    
    /* 若栈S为空栈，则返回TRUE，否则返回FALSE */
    Status StackEmpty(LinkStack S)
    { 
            if (S.count==0)
                    return TRUE;
            else
                    return FALSE;
    }
    
    /* 返回S的元素个数，即栈的长度 */
    int StackLength(LinkStack S)
    { 
            return S.count;
    }
    
    /* 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR */
    Status GetTop(LinkStack S,SElemType *e)
    {
            if (S.top==NULL)
                    return ERROR;
            else
                    *e=S.top->data;
            return OK;
    }
    
    /* 插入元素e为新的栈顶元素 */
    Status Push(LinkStack *S,SElemType e)
    {
            LinkStackPtr s=(LinkStackPtr)malloc(sizeof(StackNode)); 
            s->data=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;
    }
    
    Status StackTraverse(LinkStack S)
    {
            LinkStackPtr p;
            p=S.top;
            while(p)
            {
                     visit(p->data);
                     p=p->next;
            }
            printf("\n");
            return OK;
    }
    
    int main()
    {
            int j;
            LinkStack s;
            int e;
            if(InitStack(&s)==OK)
                    for(j=1;j<=10;j++)
                            Push(&s,j);
            printf("栈中元素依次为：");
            StackTraverse(s);
            Pop(&s,&e);
            printf("弹出的栈顶元素 e=%d\n",e);
            printf("栈空否：%d(1:空 0:否)\n",StackEmpty(s));
            GetTop(s,&e);
            printf("栈顶元素 e=%d 栈的长度为%d\n",e,StackLength(s));
            ClearStack(&s);
            printf("清空栈后，栈空否：%d(1:空 0:否)\n",StackEmpty(s));
            return 0;
    }

![1542450-20190417124024756-623836991.png][]

#### 03顺序队列 ####

#include "stdio.h"    
    #include "stdlib.h"   
    #include "io.h"  
    #include "math.h"  
    #include "time.h"
    
    #define OK 1
    #define ERROR 0
    #define TRUE 1
    #define FALSE 0
    #define MAXSIZE 20 /* 存储空间初始分配量 */
    
    typedef int Status; 
    typedef int QElemType; /* QElemType类型根据实际情况而定，这里假设为int */
    
    /* 循环队列的顺序存储结构 */
    typedef struct
    {
        QElemType data[MAXSIZE];
        int front;        /* 头指针 */
        int rear;        /* 尾指针，若队列不空，指向队列尾元素的下一个位置 */
    }SqQueue;
    
    Status visit(QElemType c)
    {
        printf("%d ",c);
        return OK;
    }
    
    /* 初始化一个空队列Q */
    Status InitQueue(SqQueue *Q)
    {
        Q->front=0;
        Q->rear=0;
        return  OK;
    }
    
    /* 将Q清为空队列 */
    Status ClearQueue(SqQueue *Q)
    {
        Q->front=Q->rear=0;
        return OK;
    }
    
    /* 若队列Q为空队列,则返回TRUE,否则返回FALSE */
    Status QueueEmpty(SqQueue Q)
    { 
        if(Q.front==Q.rear) /* 队列空的标志 */
            return TRUE;
        else
            return FALSE;
    }
    
    /* 返回Q的元素个数，也就是队列的当前长度 */
    int QueueLength(SqQueue Q)
    {
        return  (Q.rear-Q.front+MAXSIZE)%MAXSIZE;
    }
    
    /* 若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR */
    Status GetHead(SqQueue Q,QElemType *e)
    {
        if(Q.front==Q.rear) /* 队列空 */
            return ERROR;
        *e=Q.data[Q.front];
        return OK;
    }
    
    /* 若队列未满，则插入元素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->front == Q->rear)            /* 队列空的判断 */
            return ERROR;
        *e=Q->data[Q->front];                /* 将队头元素赋值给e */
        Q->front=(Q->front+1)%MAXSIZE;    /* front指针向后移一位置， */
                                        /* 若到最后则转到数组头部 */
        return  OK;
    }
    
    /* 从队头到队尾依次对队列Q中每个元素输出 */
    Status QueueTraverse(SqQueue Q)
    { 
        int i;
        i=Q.front;
        while((i+Q.front)!=Q.rear)
        {
            visit(Q.data[i]);
            i=(i+1)%MAXSIZE;
        }
        printf("\n");
        return OK;
    }
    
    int main()
    {
        Status j;
        int i=0,l;
        QElemType d;
        SqQueue Q;
        InitQueue(&Q);
        printf("初始化队列后，队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
    
        printf("请输入整型队列元素(不超过%d个),-1为提前结束符: ",MAXSIZE-1);
        do
        {
            /* scanf("%d",&d); */
            d=i+100;
            if(d==-1)
                break;
            i++;
            EnQueue(&Q,d);
        }while(i<MAXSIZE-1);
    
        printf("队列长度为: %d\n",QueueLength(Q));
        printf("现在队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
        printf("连续%d次由队头删除元素,队尾插入元素:\n",MAXSIZE);
        for(l=1;l<=MAXSIZE;l++)
        {
            DeQueue(&Q,&d);
            printf("删除的元素是%d,插入的元素:%d \n",d,l+1000);
            /* scanf("%d",&d); */
            d=l+1000;
            EnQueue(&Q,d);
        }
        l=QueueLength(Q);
    
        printf("现在队列中的元素为: \n");
        QueueTraverse(Q);
        printf("共向队尾插入了%d个元素\n",i+MAXSIZE);
        if(l-2>0)
            printf("现在由队头删除%d个元素:\n",l-2);
        while(QueueLength(Q)>2)
        {
            DeQueue(&Q,&d);
            printf("删除的元素值为%d\n",d);
        }
    
        j=GetHead(Q,&d);
        if(j)
            printf("现在队头元素为: %d\n",d);
        ClearQueue(&Q);
        printf("清空队列后, 队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
        return 0;
    }

![1542450-20190417124301777-2083628189.png][]

![1542450-20190417124331542-534065751.png][]

#### 04链式队列 ####

#include "stdio.h"    
    #include "stdlib.h"   
    #include "io.h"  
    #include "math.h"  
    #include "time.h"
    
    #define OK 1
    #define ERROR 0
    #define TRUE 1
    #define FALSE 0
    #define MAXSIZE 20 /* 存储空间初始分配量 */
    
    typedef int Status; 
    
    typedef int QElemType; /* QElemType类型根据实际情况而定，这里假设为int */
    
    typedef struct QNode    /* 结点结构 */
    {
       QElemType data;
       struct QNode *next;
    }QNode,*QueuePtr;
    
    typedef struct            /* 队列的链表结构 */
    {
       QueuePtr front,rear; /* 队头、队尾指针 */
    }LinkQueue;
    
    Status visit(QElemType c)
    {
        printf("%d ",c);
        return OK;
    }
    
    /* 构造一个空队列Q */
    Status InitQueue(LinkQueue *Q)
    { 
        Q->front=Q->rear=(QueuePtr)malloc(sizeof(QNode));
        if(!Q->front)
            exit(OVERFLOW);
        Q->front->next=NULL;
        return OK;
    }
    
    /* 销毁队列Q */
    Status DestroyQueue(LinkQueue *Q)
    {
        while(Q->front)
        {
             Q->rear=Q->front->next;
             free(Q->front);
             Q->front=Q->rear;
        }
        return OK;
    }
    
    /* 将Q清为空队列 */
    Status ClearQueue(LinkQueue *Q)
    {
        QueuePtr p,q;
        Q->rear=Q->front;
        p=Q->front->next;
        Q->front->next=NULL;
        while(p)
        {
             q=p;
             p=p->next;
             free(q);
        }
        return OK;
    }
    
    /* 若Q为空队列,则返回TRUE,否则返回FALSE */
    Status QueueEmpty(LinkQueue Q)
    { 
        if(Q.front==Q.rear)
            return TRUE;
        else
            return FALSE;
    }
    
    /* 求队列的长度 */
    int QueueLength(LinkQueue Q)
    { 
        int i=0;
        QueuePtr p;
        p=Q.front;
        while(Q.rear!=p)
        {
             i++;
             p=p->next;
        }
        return i;
    }
    
    /* 若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR */
    Status GetHead(LinkQueue Q,QElemType *e)
    { 
        QueuePtr p;
        if(Q.front==Q.rear)
            return ERROR;
        p=Q.front->next;
        *e=p->data;
        return OK;
    }
    
    
    /* 插入元素e为Q的新的队尾元素 */
    Status EnQueue(LinkQueue *Q,QElemType e)
    { 
        QueuePtr s=(QueuePtr)malloc(sizeof(QNode));
        if(!s) /* 存储分配失败 */
            exit(OVERFLOW);
        s->data=e;
        s->next=NULL;
        Q->rear->next=s;    /* 把拥有元素e的新结点s赋值给原队尾结点的后继，见图中① */
        Q->rear=s;        /* 把当前的s设置为队尾结点，rear指向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->next赋值给头结点后继，见图中② */
        if(Q->rear==p)        /* 若队头就是队尾，则删除后将rear指向头结点，见图中③ */
            Q->rear=Q->front;
        free(p);
        return OK;
    }
    
    /* 从队头到队尾依次对队列Q中每个元素输出 */
    Status QueueTraverse(LinkQueue Q)
    {
        QueuePtr p;
        p=Q.front->next;
        while(p)
        {
             visit(p->data);
             p=p->next;
        }
        printf("\n");
        return OK;
    }
    
    int main()
    {
        int i;
        QElemType d;
        LinkQueue q;
        i=InitQueue(&q);
        if(i)
            printf("成功地构造了一个空队列!\n");
        printf("是否空队列？%d(1:空 0:否)  ",QueueEmpty(q));
        printf("队列的长度为%d\n",QueueLength(q));
        EnQueue(&q,-5);
        EnQueue(&q,5);
        EnQueue(&q,10);
        printf("插入3个元素(-5,5,10)后,队列的长度为%d\n",QueueLength(q));
        printf("是否空队列？%d(1:空 0:否)  ",QueueEmpty(q));
        printf("队列的元素依次为：");
        QueueTraverse(q);
        i=GetHead(q,&d);
        if(i==OK)
         printf("队头元素是：%d\n",d);
        DeQueue(&q,&d);
        printf("删除了队头元素%d\n",d);
        i=GetHead(q,&d);
        if(i==OK)
            printf("新的队头元素是：%d\n",d);
        ClearQueue(&q);
        printf("清空队列后,q.front=%u q.rear=%u q.front->next=%u\n",q.front,q.rear,q.front->next);
        DestroyQueue(&q);
        printf("销毁队列后,q.front=%u q.rear=%u\n",q.front, q.rear);
        
        return 0;
    }

![1542450-20190417124421951-1224502196.png][]

转载于:https://www.cnblogs.com/xinmomoyan/p/10722320.html

[1542450-20190417101029578-617410486.png]: /images/20220109/90fc5a54aef148c5b8f182814f1a4659.png
[1542450-20190417101216741-1889753993.png]: /images/20220109/d6076aba25a34ad6aa15a716766e79fd.png
[1542450-20190417101250896-236065112.png]: /images/20220109/8079d74e49424ad69683326f74146289.png
[1542450-20190417101355795-313113527.png]: /images/20220109/f9fe7d62ffb94739b49b6af19f9acc8d.png
[1542450-20190417101415528-1988805836.png]: /images/20220109/618f1c108efa4208a622e8ac3722a80f.png
[1542450-20190417101506405-1813783402.png]: /images/20220109/233a02d42cb340b884685f3370d38ff1.png
[1542450-20190417101820615-2142899612.png]: /images/20220109/d69b9db6fafd49eb9d03d4612bee4d21.png
[1542450-20190417102002504-1272350373.png]: /images/20220109/e884814d087e446a9ec4e23fda03ade4.png
[1542450-20190417101930270-665935447.png]: /images/20220109/bc556fd051e846e6b21fdb804d1c0cae.png
[1542450-20190417102041558-1997857293.png]: /images/20220109/484d3ca61bf1499d95d2648854c08fa9.png
[1542450-20190417102103305-277924852.png]: https://img2018.cnblogs.com/blog/1542450/201904/1542450-20190417102103305-277924852.png
[1542450-20190417102117779-1725031617.png]: /images/20220109/440365f4b05746809e1d694f863dbb6d.png
[1542450-20190417102307769-521390734.png]: /images/20220109/10f0e3e2a1054be09d208a9af957b8bb.png
[1542450-20190417102324673-142824400.png]: /images/20220109/1d4dd03e55114e5b9c4848b153959fab.png
[1542450-20190417103803757-684830308.png]: /images/20220109/0459515936d043bcbac510a58ec35c05.png
[1542450-20190417104355914-563360887.png]: https://img2018.cnblogs.com/blog/1542450/201904/1542450-20190417104355914-563360887.png
[1542450-20190417104515924-1056934176.png]: /images/20220109/ece513cf93dc4b15b614f06c3600dd09.png
[1542450-20190417105127648-605737227.png]: /images/20220109/6e98621001fc4b2f8c12fd77b84a558d.png
[1542450-20190417105258744-1327254623.png]: /images/20220109/6e007453da1c4757853313439334886b.png
[1542450-20190417105314768-880366425.png]: /images/20220109/ff64b64c245d482692d1d0bc9b9022e4.png
[1542450-20190417105405006-406450862.png]: /images/20220109/8950716ef35c46d5a55eb7eca9f67912.png
[1542450-20190417105616559-366450638.png]: /images/20220109/926cecd0efa5457facaabe2d4a3ac6a9.png
[1542450-20190417105637632-2051783425.png]: /images/20220109/fabd7cc0e6df45f7972678f61b67b576.png
[1542450-20190417105738885-1622739119.png]: /images/20220109/114ae3f5d2d04e6599d822cb7f3a5abb.png
[1542450-20190417105824162-414762260.png]: /images/20220109/e0e12eaa8fd84c5a8acfa46a0468de3e.png
[1542450-20190417105846080-1239908866.png]: /images/20220109/46cc9e30300a4009ab6b7c12849badd3.png
[1542450-20190417105939402-307215860.png]: /images/20220109/3796571459a64cd5b5c776fe964a2615.png
[1542450-20190417110011376-1458097249.png]: /images/20220109/231148d7b423484d8932290e31383231.png
[1542450-20190417110029568-498181541.png]: /images/20220109/92c3949b97754a1e838ec9c61b3c33da.png
[1542450-20190417110046266-1218071236.png]: /images/20220109/3dc27ceb54f24ce0bc96daccbd5708cb.png
[1542450-20190417110933622-1434314415.png]: /images/20220109/7123a03ee12548d38622d12cb8d06306.png
[1542450-20190417110959710-22977476.png]: /images/20220109/91ba5561faa74735ade10c179cdf73e7.png
[1542450-20190417111606370-1861508865.png]: /images/20220109/26b48136364948f69708911721ac24c7.png
[1542450-20190417111622092-625406827.png]: /images/20220109/f51eb921ce3044fbbd96cafcae94c752.png
[1542450-20190417111636621-1872930378.png]: /images/20220109/754f061b70aa4dbe9f39ea5bae76e478.png
[1542450-20190417111701394-1801288239.png]: /images/20220109/c4f6e13b524f43af832dcb2627cb3b3b.png
[1542450-20190417111715844-1899761129.png]: /images/20220109/fd4e2ad90b484725b9e6b97ff25a80e4.png
[1542450-20190417111732469-556870158.png]: https://img2018.cnblogs.com/blog/1542450/201904/1542450-20190417111732469-556870158.png
[1542450-20190417111753060-76076516.png]: /images/20220109/56d461def86b4c6b9a7b54735f02c8f1.png
[1542450-20190417123917363-2062409905.png]: /images/20220109/546bec021af148aab785eb0bfbb0e86f.png
[1542450-20190417124024756-623836991.png]: /images/20220109/7cfe6c4c506f4b41903352fc2af97274.png
[1542450-20190417124301777-2083628189.png]: /images/20220109/25264f0f2bf5442abf25b1091580a914.png
[1542450-20190417124331542-534065751.png]: /images/20220109/2766cfed76d1402d85e1cc22e92266ba.png
[1542450-20190417124421951-1224502196.png]: /images/20220109/582035a5052642469a1b87a541f46551.png