第4章 栈与队列

栈(stack)是限定仅在表尾进行插入和删除操作的线性表,即后进先出(LIFO,Last In First Out)。如浏览器上的“后退”按钮。

ADT 栈(stack)
Data
    同线性表。元素具有相同的类型,相邻元素具有前驱和后继关系。
Operation
    Initstack(*S);初始化操作,建立一个空栈S。
    DestroyStack(*S);若栈存在,则销毁它。
    ClearStack(*S);将栈清空。
    StackEmpty(S);若栈为空,返回true;否则返回false。
    GetTop(S,*e);若栈存在且非空,用e返回S的栈顶元素。
    Push(*S,e);若栈S存在,插入新元素e到栈S中并成为栈顶元素。又称:进栈,压栈,入栈。
    Pop(*S,*e);删除栈S中栈顶元素,并用e返回其值。又称:出栈,弹栈。
    StackLength(S);返回栈S的元素个数。
endADT

栈的应用:递归(斐波那契列(Fibonacci)),四则运算表达式求值。

栈的顺序存储结构可使用两栈共享空间,即一个数组存储两个栈(使用数组的两端作为栈底),使用这样的数据结构,通常都是当两个栈的空间需求有相反关系时。

如果栈的使用过程中元素变化不可预料,有时很小,有时非常大,那么最好使用链栈,反之,如果它的变化在可控范围内,建议使用顺序栈会更好一些。

队列(queue)是只允许在一端进行插入操作,而在另一端进行删除操作的线性表,即先进先出(FIFO,First In First Out)。

ADT 队列(queue)
Data
    同线性表。元素具有相同的类型,相邻元素具有前驱和后继关系。
Operation
    InitQueue(*Q);初始化操作,建立一个空队列Q。
    DestroyQueue(*Q);若队列Q存在,则销毁它。
    ClearQueue(*Q);将队列Q清空。
    StackEmpty(Q);若队列Q为空,返回true;否则返回false。
    GetHead(Q,*e);若队列Q存在且非空,用e返回Q的队头元素。
    EnQueue(*Q,e);若队列Q存在,插入新元素e到队列Q中并成为队尾元素。
    DeQueue(*Q,*e);删除队列Q中队头元素,并用e返回其值。
    QueueLength(Q);返回队列Q的元素个数。
endADT

对于队列的顺序存储结构,为了避免数组插入和删除时需要移动数据,于是就引入了循环队列,使得队头和队尾可以在数组中循环变化,使本来插入和删除时O(n)的时间复杂度变为了O(1)。

代码部分:

01顺序栈_Stack.c

#include "stdio.h" //"standard input & output"标准输入输出
#include "stdlib.h"  //"standard library"标准库头文件
#include "io.h"  //主要定义一些和缓冲区相关的读写函数
#include "math.h"  //主要定义一些和数学相关的函数
#include "time.h"//C/C++中的日期和时间头文件

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status;     /* Status是函数的类型,其值是函数结果状态代码,如OK等 */
typedef int SElemType; /* SElemType类型根据实际情况而定,这里假设为int */

/*******************
typedef struct SqStack
功能:定义一个顺序栈结构,并给其起个别名SqStack

参数:
    SElemType data[MAXSIZE]:整型数组,存储数据元素
    int top:用于栈顶指针
*******************/
typedef struct
{
        SElemType data[MAXSIZE];
        int top; /* 用于栈顶指针 */
}SqStack;

/*******************
Status visit(SElemType c)
功能:访问(打印)某一元素

参数:
    ElemType c:要访问的元素

返回值:
    Status型:OK为执行正确,ERROR为出错
*******************/
Status visit(SElemType c)
{
        printf("%d ",c);
        return OK;
}

/*******************
Status InitStack(SqStack *S)
功能:构造一个空栈S

参数:
    SqStack *S:栈S

返回值:
    Status类型:OK为执行正确,ERROR为出错
*******************/
Status InitStack(SqStack *S)
{
        /* S.data=(SElemType *)malloc(MAXSIZE*sizeof(SElemType)); */
        S->top=-1;
        return OK;
}

/*******************
Status ClearStack(SqStack *S)
功能:把S置为空栈

参数:
    SqStack *S:栈S

返回值:
    Status类型:OK为执行正确,ERROR为出错
*******************/
Status ClearStack(SqStack *S)
{
        S->top=-1;
        return OK;
}

/*******************
Status StackEmpty(SqStack S)
功能:
    检测是否为空栈

限制:

参数:
    SqStack S:栈S

返回值:
    Status类型:TRUE表示S为空栈,否则返回FALSE
*******************/
Status StackEmpty(SqStack S)
{
        if (S.top==-1)
                return TRUE;
        else
                return FALSE;
}

/*******************
int StackLength(SqStack S)
功能:
    获取S的元素个数,即栈的长度

限制:

参数:
    SqStack S:栈S

返回值:
    int型:返回S中元素个数
*******************/
int StackLength(SqStack S)
{
        return S.top+1;
}

/*******************
Status GetTop(SqStack S,SElemType *e)
功能:
    用e返回S的栈顶元素,并返回OK;否则返回ERROR

限制:

参数:
    SqStack S:栈S
    SElemType *e:栈顶元素

返回值:
    Status型:若为空栈,返回ERROR,否则返回OK
*******************/
Status GetTop(SqStack S,SElemType *e)
{
        if (S.top==-1)
                return ERROR;
        else
                *e=S.data[S.top];
        return OK;
}

/*******************
Status Push(SqStack *S,SElemType e)
功能:
    插入元素e为新的栈顶元素

限制:

参数:
    SqStack *S:栈S
    SElemType e:栈顶元素

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

/*******************
Status Pop(SqStack *S,SElemType *e)
功能:
    删除S的栈顶元素,用e返回其值

限制:

参数:
    SqStack *S:栈S
    SElemType *e:栈顶元素

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

/*******************
Status StackTraverse(SqStack S)
功能:
    从栈底到栈顶依次对栈中每个元素显示

限制:

参数:
    SqStack S:栈S

返回值:
    Status型:OK为执行正确,ERROR为出错
*******************/
Status StackTraverse(SqStack S)
{
        int i;
        i=0;
        while(i<=S.top)
        {
                visit(S.data[i++]);
        }
        printf("\n");
        return OK;
}

int main()
{
        int j;
        SqStack 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;
}

02两栈共享空间_DoubleStack.c

#include "stdio.h"  //"standard input & output"标准输入输出
#include "stdlib.h"   //"standard library"标准库头文件
#include "io.h"  //主要定义一些和缓冲区相关的读写函数
#include "math.h"  //主要定义一些和数学相关的函数
#include "time.h"//C/C++中的日期和时间头文件

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status; /* Status是函数的类型,其值是函数结果状态代码,如OK等 */
typedef int SElemType; /* SElemType类型根据实际情况而定,这里假设为int */

/*******************
typedef struct SqDoubleStack
功能:定义一个共享栈结构,并给其起个别名SqDoubleStack

参数:
    SElemType data[MAXSIZE]:整型数组,存储数据元素
    int top1:栈1栈顶指针
    int top2:栈2栈顶指针
*******************/
typedef struct
{
        SElemType data[MAXSIZE];
        int top1;   /* 栈1栈顶指针 */
        int top2;   /* 栈2栈顶指针 */
}SqDoubleStack;

/*******************
Status visit(SElemType c)
功能:访问(打印)某一元素

参数:
    ElemType c:要访问的元素

返回值:
    Status型:OK为执行正确,ERROR为出错
*******************/
Status visit(SElemType c)
{
        printf("%d ",c);
        return OK;
}

/*******************
Status InitStack(SqDoubleStack *S)
功能:构造一个空栈S

参数:
    SqDoubleStack *S:栈S

返回值:
    Status类型:OK为执行正确,ERROR为出错
*******************/
Status InitStack(SqDoubleStack *S)
{
        S->top1=-1;
        S->top2=MAXSIZE;
        return OK;
}

/*******************
Status ClearStack(SqDoubleStack *S)
功能:把S置为空栈

参数:
    SqDoubleStack *S:栈S

返回值:
    Status类型:OK为执行正确,ERROR为出错
*******************/
Status ClearStack(SqDoubleStack *S)
{
        S->top1=-1;
        S->top2=MAXSIZE;
        return OK;
}

/*******************
Status StackEmpty(SqDoubleStack S)
功能:
    检测是否为空栈

限制:

参数:
    SqDoubleStack S:栈S

返回值:
    Status类型:TRUE表示S为空栈,否则返回FALSE
*******************/
Status StackEmpty(SqDoubleStack S)
{
        if (S.top1==-1 && S.top2==MAXSIZE)
                return TRUE;
        else
                return FALSE;
}

/*******************
int StackLength(SqDoubleStack S)
功能:
    获取S的元素个数,即栈的长度

限制:

参数:
    SqDoubleStack S:栈S

返回值:
    int型:返回S中元素个数
*******************/
int StackLength(SqDoubleStack S)
{
        return (S.top1+1)+(MAXSIZE-S.top2);
}

/*******************
Status Push(SqDoubleStack *S,SElemType e,int stackNumber)
功能:
    为栈stackNumber插入元素e为新的栈顶元素

限制:

参数:
    SqStack *S:栈S
    SElemType e:栈顶元素
    int stackNumber:栈序号

返回值:
    Status型:若满栈,返回ERROR,否则OK
*******************/
Status Push(SqDoubleStack *S,SElemType e,int stackNumber)
{
        if (S->top1+1==S->top2) /* 栈已满,不能再push新元素了 */
                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;
}

/*******************
Status Pop(SqDoubleStack *S,SElemType *e,int stackNumber)
功能:
    删除S的栈顶元素,用e返回其值

限制:

参数:
    SqStack *S:栈S
    SElemType *e:栈顶元素
    int stackNumber:栈序号

返回值:
    Status型:若为空栈,返回ERROR;否则返回OK
*******************/
Status Pop(SqDoubleStack *S,SElemType *e,int stackNumber)
{
        if (stackNumber==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;
}

/*******************
Status StackTraverse(SqDoubleStack S)
功能:
    从栈底到栈顶依次对栈中每个元素显示

限制:

参数:
    SqDoubleStack S:栈S

返回值:
    Status型:OK为执行正确,ERROR为出错
*******************/
Status StackTraverse(SqDoubleStack S)
{
        int i;
        i=0;
        while(i<=S.top1)
        {
                visit(S.data[i++]);
        }
        i=S.top2;
        while(i<MAXSIZE)
        {
                visit(S.data[i++]);//栈2为倒着显示
        }
        printf("\n");
        return OK;
}

int main()
{
        int j;
        SqDoubleStack s;
        int e;
        if(InitStack(&s)==OK)
        {
                for(j=1;j<=5;j++)
                        Push(&s,j,1);
                for(j=MAXSIZE;j>=MAXSIZE-2;j--)
                        Push(&s,j,2);
        }

        printf("栈中元素依次为:");
        StackTraverse(s);

        printf("当前栈中元素有:%d \n",StackLength(s));

        Pop(&s,&e,2);
        printf("弹出的栈顶元素 e=%d\n",e);
        printf("栈空否:%d(1:空 0:否)\n",StackEmpty(s));

        for(j=6;j<=MAXSIZE-2;j++)
                Push(&s,j,1);

        printf("栈中元素依次为:");
        StackTraverse(s);

        printf("栈满否:%d(1:否 0:满)\n",Push(&s,100,1));

        ClearStack(&s);
        printf("清空栈后,栈空否:%d(1:空 0:否)\n",StackEmpty(s));

        return 0;
}

03链栈_LinkStack.c

#include "stdio.h"    //"standard input & output"标准输入输出
#include "stdlib.h"   //"standard library"标准库头文件
#include "io.h"   //主要定义一些和缓冲区相关的读写函数
#include "math.h"   //主要定义一些和数学相关的函数
#include "time.h"  //C/C++中的日期和时间头文件

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status; /* Status是函数的类型,其值是函数结果状态代码,如OK等 */
typedef int SElemType; /* SElemType类型根据实际情况而定,这里假设为int */

/*******************
typedef struct StackNode
功能:定义一个链栈结构的结点,并给其起个别名StackNode

参数:
    ElemType data:结点的数据信息
    struct StackNode *next:指向下一个结点的指针
*******************/
typedef struct StackNode
{
        SElemType data;
        struct StackNode *next;
}StackNode,*LinkStackPtr;

/*******************
typedef struct LinkStack
功能:定义一个链栈结构,并给其起个别名LinkStack

参数:
    LinkStackPtr top;:指向栈顶结点的指针
    int count:节点数
*******************/
typedef struct
{
        LinkStackPtr top;
        int count;
}LinkStack;

/*******************
Status visit(ElemType c)
功能:访问(打印)某一元素

参数:
    ElemType c:要访问的元素

返回值:
    Status类型:OK为执行正确,ERROR为出错
*******************/
Status visit(SElemType c)
{
        printf("%d ",c);
        return OK;
}

/*******************
Status InitList(LinkList *L)
功能:构造一个空栈S

参数:
    LinkStack *S:链栈S

返回值:
    Status类型:OK为执行正确,ERROR为出错
*******************/
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;
}

/*******************
Status ListEmpty(LinkStack S)
功能:
    检测是否为空栈

限制:

参数:
    LinkStack S:链栈

返回值:
    Status类型:TRUE表示S为空栈,否则返回FALSE
*******************/
Status StackEmpty(LinkStack S)
{
        if (S.count==0)
                return TRUE;
        else
                return FALSE;
}

/*******************
int StackLength(LinkStack S)
功能:
    返回S的元素个数,即栈的长度

限制:

参数:
    LinkStack S:链栈

返回值:
    int类型:S的元素个数
*******************/
int StackLength(LinkStack S)
{
        return S.count;
}

/*******************
Status GetTop(LinkStack S,SElemType *e)
功能:
    用e返回S的栈顶元素

限制:

参数:
    LinkStack S:链栈
    SElemType *e:栈顶元素

返回值:
    Status类型:若为空栈,返回ERROR;否则OK
*******************/
Status GetTop(LinkStack S,SElemType *e)
{
        if (S.top==NULL)
                return ERROR;
        else
                *e=S.top->data;
        return OK;
}

/*******************
Status Push(LinkStack *S,SElemType e)
功能:
    插入元素e为新的栈顶元素

限制:

参数:
    LinkStack *S:链栈
    SElemType e:新的栈顶元素

返回值:
    Status类型:执行正确,返回OK
*******************/
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;
}

/*******************
Status Push(LinkStack *S,SElemType e)
功能:
    删除的栈顶元素,用e返回其值

限制:

参数:
    LinkStack *S:链栈
    SElemType *e:栈顶元素

返回值:
    Status类型:若为空栈,返回ERROR;否则OK
*******************/
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)
功能:
    依次对S的每个数据元素输出

限制:

参数:
    LinkStack S:链栈

返回值:
    Status类型:OK表示执行正确,ERROR为出错
*******************/
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;
}

04斐波那契函数_Fibonacci.c

#include "stdio.h"  //"standard input & output"标准输入输出      

/*******************
int Fbi(int i)
功能:
    斐波那契的递归函数

参数:
    ElemType c:要访问的元素

返回值:
    int类型:斐波那契数列第i个的函数值
*******************/
int Fbi(int i)
{
    if( i < 2 )
        return i == 0 ? 0 : 1;
    return Fbi(i - 1) + Fbi(i - 2);  /* 这里Fbi就是函数自己,等于在调用自己 */
}  

int main()
{
    int i;
    int a[40];
    printf("迭代显示斐波那契数列:\n");
    a[0]=0;
    a[1]=1;
    printf("%d ",a[0]);
    printf("%d ",a[1]);
    for(i = 2;i < 40;i++)
    {
        a[i] = a[i-1] + a[i-2];
        printf("%d ",a[i]);
    }
    printf("\n");

    printf("递归显示斐波那契数列:\n");
    for(i = 0;i < 40;i++)
        printf("%d ", Fbi(i));
    return 0;
}

05顺序队列_Queue.c

#include "stdio.h"    //"standard input & output"标准输入输出
#include "stdlib.h"   //"standard library"标准库头文件
#include "io.h"  //主要定义一些和缓冲区相关的读写函数
#include "math.h"  //主要定义一些和数学相关的函数
#include "time.h"   //C/C++中的日期和时间头文件

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status;     /* Status是函数的类型,其值是函数结果状态代码,如OK等 */
typedef int QElemType; /* QElemType类型根据实际情况而定,这里假设为int */

/*******************
typedef struct SqQueue
功能:循环队列的顺序存储结构

参数:
    QElemType data[MAXSIZE]:整型数组,存储数据元素
    int front:线性表当前长度
    int rear:尾指针
*******************/
typedef struct
{
    QElemType data[MAXSIZE];
    int front;      /* 头指针 */
    int rear;       /* 尾指针,若队列不空,指向队列尾元素的下一个位置 */
}SqQueue;

/*******************
Status visit(ElemType c)
功能:访问(打印)某一元素

参数:
    ElemType c:要访问的元素

返回值:
    Status类型:OK为执行正确,ERROR为出错
*******************/
Status visit(QElemType c)
{
    printf("%d ",c);
    return OK;
}

/*******************
Status InitQueue(SqQueue *Q)
功能:初始化一个空队列Q

参数:
    SqQueue *Q:队列Q

返回值:
    Status类型:OK为执行正确,ERROR为出错
*******************/
Status InitQueue(SqQueue *Q)
{
    Q->front=0;
    Q->rear=0;
    return  OK;
}

/*******************
Status ClearList(SqList *L)
功能:
    将Q清为空队列

限制:

参数:
    SqQueue *Q:队列Q

返回值:
    Status类型:OK表示执行正确
*******************/
Status ClearQueue(SqQueue *Q)
{
    Q->front=Q->rear=0;
    return OK;
}

/*******************
Status QueueEmpty(SqQueue Q)
功能:
    检测是否为空队列

限制:

参数:
    SqQueue Q:队列Q

返回值:
    Status类型:若队列Q为空队列,则返回TRUE,否则返回FALSE
*******************/
Status QueueEmpty(SqQueue Q)
{
    if(Q.front==Q.rear) /* 队列空的标志 */
        return TRUE;
    else
        return FALSE;
}

/*******************
int QueueLength(SqQueue Q)
功能:
    获取Q中数据元素个数,也就是队列的当前长度

限制:

参数:
    SqQueue Q:队列Q

返回值:
    int类型:返回Q的元素个数
*******************/
int QueueLength(SqQueue Q)
{
    return  (Q.rear-Q.front+MAXSIZE)%MAXSIZE;//队列长度公式
}

/*******************
Status GetHead(SqQueue Q,QElemType *e)
功能:
    用e返回Q的队头元素

限制:

参数:
    SqQueue Q:队列Q
    QElemType *e:队头元素

返回值:
    Status类型:若队列Q不空,则返回OK,否则返回ERROR
*******************/
Status GetHead(SqQueue Q,QElemType *e)
{
    if(Q.front==Q.rear) /* 队列空 */
        return ERROR;
    *e=Q.data[Q.front];
    return OK;
}

/*******************
Status EnQueue(SqQueue *Q,QElemType e)
功能:
    插入元素e为Q新的队尾元素

限制:

参数:
    SqQueue *Q:队列Q
    QElemType e:要插入的队尾元素

返回值:
    Status类型:若执行正确,则返回OK,否则队列已满,返回ERROR
*******************/
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;
}

/*******************
Status DeQueue(SqQueue *Q,QElemType *e)
功能:
    删除Q中队头元素,用e返回其值

限制:

参数:
    SqQueue *Q:队列Q
    QElemType *e:队头元素

返回值:
    Status类型:若队列Q不空,则返回OK,否则返回ERROR
*******************/
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;
}

/*******************
Status QueueTraverse(SqQueue Q)
功能:
    从队头到队尾依次对队列Q中每个元素输出

限制:

参数:
    SqQueue Q:SqList结构体类型的变量

返回值:
    Status类型:OK表示执行正确,ERROR为出错
*******************/
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;
}

06链队列_LinkQueue.c

#include "stdio.h" //"standard input & output"标准输入输出
#include "stdlib.h"  //字符串处理的头文件
#include "io.h"  //主要定义一些和缓冲区相关的读写函数
#include "math.h"  //主要定义一些和数学相关的函数
#include "time.h"  //C/C++中的日期和时间头文件

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status; /* Status是函数的类型,其值是函数结果状态代码,如OK等 */
typedef int QElemType; /* QElemType类型根据实际情况而定,这里假设为int */

/*******************
typedef struct QNode
功能:定义队列的一个结点结构,并给其起个别名QNode

参数:
    QElemType data:结点的数据信息
    struct QNode *next:指向下一个结点的指针
*******************/
typedef struct QNode
{
   QElemType data;
   struct QNode *next;
}QNode,*QueuePtr;

/*******************
typedef struct LinkQueue
功能:队列的链表结构

参数:
    QueuePtr front,rear:队头、队尾指针
*******************/
typedef struct
{
   QueuePtr front,rear;     /* 队头、队尾指针 */
}LinkQueue;

/*******************
Status visit(ElemType c)
功能:访问(打印)某一元素

参数:
    ElemType c:要访问的元素

返回值:
    Status类型:OK为执行正确,ERROR为出错
*******************/
Status visit(QElemType c)
{
    printf("%d ",c);
    return OK;
}

/*******************
Status InitQueue(LinkQueue *Q)
功能:构造一个空队列Q

参数:
    LinkQueue *Q:队列Q

返回值:
    Status类型:OK为执行正确,ERROR为出错
*******************/
Status InitQueue(LinkQueue *Q)
{
    Q->front=Q->rear=(QueuePtr)malloc(sizeof(QNode));
    if(!Q->front)
        exit(OVERFLOW);     //退出程序,溢出
    Q->front->next=NULL;
    return OK;
}

/*******************
Status DestroyQueue(LinkQueue *Q)
功能:
    销毁队列Q

限制:

参数:
    LinkQueue *Q:队列Q

返回值:
    Status类型:OK表示执行正确
*******************/
Status DestroyQueue(LinkQueue *Q)
{
    while(Q->front)
    {
         Q->rear=Q->front->next;
         free(Q->front);
         Q->front=Q->rear;
    }
    return OK;
}

/*******************
Status ClearQueue(LinkQueue *Q)
功能:
    将Q清为空队列

限制:

参数:
    LinkQueue *Q:队列Q

返回值:
    Status类型:OK表示执行正确
*******************/
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;
}

/*******************
Status ClearQueue(LinkQueue *Q)
功能:
    检测是否为空队列

限制:

参数:
    LinkQueue Q:队列Q

返回值:
    Status类型:若Q为空队列,则返回TRUE,否则返回FALSE
*******************/
Status QueueEmpty(LinkQueue Q)
{
    if(Q.front==Q.rear)
        return TRUE;
    else
        return FALSE;
}

/*******************
int QueueLength(LinkQueue Q)
功能:
    求队列的长度

限制:

参数:
    LinkQueue Q:队列Q

返回值:
    int类型:返回Q中数据元素个数
*******************/
int QueueLength(LinkQueue Q)
{
    int i=0;
    QueuePtr p;
    p=Q.front;
    while(Q.rear!=p)
    {
         i++;
         p=p->next;
    }
    return i;
}

/*******************
Status GetHead(LinkQueue Q,QElemType *e)
功能:
    用e返回Q的队头元素

限制:

参数:
    LinkQueue Q:队列Q
    QElemType *e:队头元素e

返回值:
    Status型:若队列不空,则返回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;
}

/*******************
Status EnQueue(LinkQueue *Q,QElemType e)
功能:
    插入元素e为Q的新的队尾元素

限制:

参数:
    LinkQueue *Q:队列Q
    QElemType e:队头元素e

返回值:
    Status型:若操作正确,返回OK
*******************/
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;
}

/*******************
Status DeQueue(LinkQueue *Q,QElemType *e)
功能:
    删除Q的队头元素,用e返回其值

限制:

参数:
    LinkQueue *Q:队列Q
    QElemType e:队头元素e

返回值:
    Status型:若队列不空,则返回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;
}

/*******************
Status QueueTraverse(LinkQueue Q)
功能:
    从队头到队尾依次对队列Q中每个元素输出

限制:

参数:
    LinkQueue Q:队列Q

返回值:
    Status型:若执行正确,返回OK;否则返回ERROR
*******************/
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;
}

版权声明:本文为博主原创文章,未经博主允许不得转载。

时间: 2024-11-05 22:46:46

第4章 栈与队列的相关文章

第04章 栈和队列

栈 队列 优先级队列 本章涉及到的三种存储数据类型:栈 队列 优先级队列 本章涉及到的存储数据类型是算法构思的辅助工具,而不仅仅是存储数据的工具.数据结构的生命周期比较短,在程序结束时,对应的数据结构的生命周期随之结束. 栈 队列 优先级队列是比较抽象的数据结构,通过接口对三种数据结构进行定义和实现,而实现的过程对用户来说是屏蔽的. 栈 (后进先出) 栈只允许访问一个数据项,即最后插入的项,当最后一项被移除时,才能对倒数第二项进行操作,依次类推. 栈的操作有两种,入栈和出栈,push  pop.

Java数据结构与算法(第四章栈和队列)

本章涉及的三种数据存储类型:栈.队列和优先级队列. 不同类型的结构 程序员的工具 数组是已经介绍过的数据存储结构,和其他结构(链表.树等等)一样,都适用于数据应用中作数据记录. 然而,本章要讲解的是数据结构和算法更多的是作为程序员的工具来运用.它们组要作为构思算法的辅助工具,而不是完全的数据存储工具.这些数据结构的生命周期比那些数据库类型的结构要短的多.在程序操作执行期间它们才被创建,通常它们去执行某项特殊的任务,当完成之后,它们就被销毁. 受限访问 在数组中,只要知道下标就可以访问数据项.或顺

数据结构期末复习第三章栈和队列

第三章:栈和队列 栈的特性:后进先出(LIFO) 1.  输入序列为ABC,可以变为CBA时,经过的栈操作为( B )A. push, pop, push, pop, push, popB. push, push, push, pop, pop, popC. push, push, pop, pop, push, popD. push, pop, push, push, pop, pop 解析: ABC经过push,push,push操作后,从栈顶到栈底元素为CBA,经过pop,pop,pop出

《数据结构》第3章-栈与队列的学习总结

我之前有接触过栈和队列,当时就觉得很好奇,那是以怎样的存储结构存储数据的呢?拨开重重迷雾,终于学到基础知识了. 学习<栈和队列>有两个星期了,有了前面两个章节的思维基础,我觉得栈和队列学习起来还是很好理解的,通过一些实际应用例子,让我有了更进一步的理解.现在我梳理一下知识,下面总结这一章我所学习到的东西. 一.栈(后进先出:LIFO) 1.顺序栈 这是顺序栈的存储结构: typedef struct { int *base;//栈底指针 int *top; //栈顶指针 int size; /

【知识强化】第三章 栈和队列 3.1 栈

在第三章我们将继续学习三种非常重要的线性结构,分别是栈和队列的这样的受限线性表.我们将从它们的基本概念.存储结构以及相关应用这三方面进行详细的学习.最后我们将学习数组的相关知识,大家要注意一下这里的数组指的是一种线性结构,与我们之前在程序设计语言当中提到的数组类型是不同的概念.好,数组我们会学习它的定义以及它的存储结构,还有用数组来实现矩阵的压缩存储.最后还会提一个特殊的矩阵叫做稀疏矩阵.好,这就是本章所要学习的重要考点.本章所学习的知识点其实并不难,它常常出现在选择题当中,但是在之后我们解决一

C语言数据结构——第三章 栈和队列

三.栈和队列 栈和队列是两种重要的线性结构.从数据结构的角度来看,栈和队列也是线性表,它的特殊性在于栈和队列的基本操作是线性表操作的子集,它们的操作相对于线性表来说是受到限制的,因此,可以称其为限定性的数据结构. 从数据类型的角度看,它们是和线性表大不相同的两种重要的抽象数据类型,在面向对象的程序设计中,它们是多型数据类型. 3.1-栈 3.1.1-抽象数据类型栈的定义 栈:是限定仅在表尾进行插入或删除操作的线性表,又可以称为后进先出的线性表. 栈顶:栈的表尾端 栈底:栈的表头端 空栈:不含元素

第四章 栈与队列

一.栈的定义 栈(stack)是限定尽在表尾进行插入和删除操作的线性表. 我们把允许插入和删除的一端成为栈顶(top),另一端成为栈底(bottom),不含任何数据元素的栈称为空栈.栈又称为后进先出(LIFO)的线性表. 图示出栈入栈操作: 二.栈的抽象数据类型 图示栈的各项操作: 由于栈本身就是一个线性表,那么上一章我们讨论了线性表的顺序存储和链式存储,对于栈来说也是同样适用的. 三.栈的顺序存储结构及实现 来看一下栈的结构定义: 若存储栈的长度为StackSize,则栈顶位置top必须小于S

《大话数据结构》--- 第四章 栈与队列

栈(Stack)是限定仅在表尾进行插入和删除操作的线性表. 把允许插入和删除的一端称为栈顶,另一端称为栈底,不含任何数据元素的栈称为空栈.栈又称为后进先出的线性表,简称LIFO结构. 栈的插入操作,叫做进栈,也称压栈.入栈. 栈的删除操作,叫做出栈,也称弹栈. 当两个栈一个占用内存可能太大 但内容较少 另一个占用内存可能有剩余 可以考虑使用一个数组来存两个栈,一个底端从下标0开始,另一个底端从下标n-1开始,只要两个栈不碰头 就可以实现空间的有效利用. 栈的链式存储结构称为栈链. 如果栈的使用过

数据结构-王道2017-第3章 栈和队列-栈和队列的应用

1.前中后缀表达式的转换: 举例说明将自然表达式转换成二叉树: a×(b+c)-d ① 根据表达式的优先级顺序,首先计算(b+c),形成二叉树 ②然后是a×(b+c),在写时注意左右的位置关系 ③最后在右边加上 -d 然后最这个构造好的二叉树进行遍历,三种遍历的顺序分别是这样的: ① 前序遍历:根-左-右 ② 中序遍历:左-根-右 ③ 后序遍历:左-右-根 前缀表达式:-*a+bcd 中缀表达式:a*b+c-d 后缀表达式:abc+*d- 2.队列在层次遍历二叉树中起作用,且在计算机系统中应用非