码迷，mamicode.com
首页 > 其他好文 > 详细

第4章 栈与队列

时间：2015-08-28 17:48:01      阅读：233      评论：0      收藏：0      [点我收藏+]

标签：栈   队列   数据结构   

栈（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;
}

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

第4章 栈与队列

标签：栈   队列   数据结构   

原文地址：http://blog.csdn.net/nnnnnnnnnnnny/article/details/48053373
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！