数据结构——栈与队列（顺序栈、链栈、循环队列、链队列）

最新推荐文章于 2022-09-04 02:36:36 发布

键盘上的钢琴师_v5

最新推荐文章于 2022-09-04 02:36:36 发布

阅读量2.2k

点赞数 2

分类专栏：【数据结构和算法】文章标签：数据结构栈线性表队列循环队列

本文链接：https://blog.csdn.net/daijin888888/article/details/70144670

版权

【数据结构和算法】专栏收录该内容

16 篇文章 9 订阅

订阅专栏

提示：以下内容不适合零基础人员，仅供笔者复习之用。

概要：

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

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

一、栈

1. 定义

栈是限定仅在表尾进行插入和删除操作的线性表。（又称后进先出的线性表）

2. 抽象数据类型

3. 栈的顺序存储结构及实现

#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status; 
typedef int SElemType; /* SElemType类型根据实际情况而定，这里假设为int */

/* 顺序栈结构 */
typedef struct
{
        SElemType data[MAXSIZE];
        int top; /* 用于栈顶指针 */
}SqStack;

栈的普通情况、空栈、栈满情况：（注意top值）

3.1 操作

#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
{
        SElemType data[MAXSIZE];
        int top; /* 用于栈顶指针 */
}SqStack;

Status visit(SElemType c)
{
        printf("%d ",c);
        return OK;
}

/*  构造一个空栈S */
Status InitStack(SqStack *S)
{ 
        /* S.data=(SElemType *)malloc(MAXSIZE*sizeof(SElemType)); */
        S->top=-1;
        return OK;
}

/* 把S置为空栈 */
Status ClearStack(SqStack *S)
{ 
        S->top=-1;
        return OK;
}

/* 若栈S为空栈，则返回TRUE，否则返回FALSE */
Status StackEmpty(SqStack S)
{ 
        if (S.top==-1)
                return TRUE;
        else
                return FALSE;
}

/* 返回S的元素个数，即栈的长度 */
int StackLength(SqStack S)
{ 
        return S.top+1;
}

/* 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR */
Status GetTop(SqStack S,SElemType *e)
{
        if (S.top==-1)
                return ERROR;
        else
                *e=S.data[S.top];
        return OK;
}

/* 插入元素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;
}

/* 从栈底到栈顶依次对栈中每个元素显示 */
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;
}

3.2 两栈共享空间

用一个数组来存储两个栈。如图，两个栈有两个栈底，让一个栈的栈底为数组的始端，即下标为0处，另一个栈的栈底为数组的末端，即下标为数组长度n-1处。这样，两个栈如果要增加元素，就是两端点向中间延伸。

形成的新数组：0、1、2、……n-2、n-1

使用场景：两个栈的空间需求有相反关系时，即一个栈增长另一个栈缩短时。（就像买股票，有人买入就定有人卖出）

使用前提：两个具有相同数据类型的栈。

关键：top1和top2是栈1和栈2的栈顶指针，只要他两不相见，两个栈就可以一直使用。

结构分析

空栈：栈1为空时，top1=-1。栈2为空时，top2=n。

满栈：极端情况下，栈2为空，则栈1 的top1=n-1时，栈1满了；反之，栈1为空，则栈2的top2=0时，栈2满了。一般情况下，两个栈见面时，即top1+1=top2时，可认为栈满。

结构代码：

#define MAXSIZE 20 /* 存储空间初始分配量 */
typedef int Status; 
typedef int SElemType; /* SElemType类型根据实际情况而定，这里假设为int */

/* 两栈共享空间结构 */
typedef struct 
{
        SElemType data[MAXSIZE];
        int top1;	/* 栈1栈顶指针 */
        int top2;	/* 栈2栈顶指针 */
}SqDoubleStack;

插入：

/* 插入元素e为新的栈顶元素，stackNumber用于判定是栈1还是栈2 */
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;
}

删除：（栈顶元素）

/* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */
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;
}

4. 栈的链式存储结构及实现

状态分析：

基本不存在栈满（溢出）的情况，除非内存已没有可用空间，此时计算机系统已近崩溃。

链栈为空，top=NULL;

结构代码：

/* 链栈结构 */
typedef struct StackNode
{
        SElemType data;
        struct StackNode *next;
}StackNode,*LinkStackPtr;


typedef struct
{
        LinkStackPtr top;
        int count;
}LinkStack;

链栈的操作绝大部分都和单链表相似，只是在插入、删除上，特殊点。

进栈：

/* 插入元素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;
}

5. 顺序栈和链栈的对比

相同点：时间复杂度上一样，均为O（1）。

不同点：空间性能上

顺序栈

优点：存取时定位方便。

缺点：需要事先确定一个固定的长度，可能会存在内存空间浪费的问题。

链栈

优点：对栈长度无限制。

缺点：要求每个元素都有指针域，增加了内存开销。

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

二、队列

1. 定义

只允许在一端进行插入操作，而在另一端进行删除操作的线性表。

2. 抽象数据类型

3. 循环队列

3.1 队列顺序存储的不足

插入元素时间复杂度为O（1），删除时是O（n），因为后面的所有元素要向前移;

引入front指针和rear指针，前者指向队头元素，后者指向队尾元素的下一个位置。如图：

若a1，a2出队，此时队头有空闲，队尾插入元素会导致“假溢出”，如图：

此时，引入循环队列的概念：把队列的头尾相接的顺序存储结构称为循环队列。

由于rear可能比front大，也可能小，所以尽管它们只差一个位置就是满的情况，但也可能是相差整整一圈。所以若队列的最大尺寸为QueueSize，那么队列满的条件是(rear+1)%QueueSize == front。考虑到rear>front和rear<front的情况，通用的队列长度计算公式为：(rear-front+QueueSize)%QueueSize。

3.2 代码实现

3.2.1 循环队列的顺序存储结构

#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;

3.2.2 循环队列初始化

/* 初始化一个空队列Q */
Status InitQueue(SqQueue *Q)
{
	Q->front=0;
	Q->rear=0;
	return  OK;
}

3.2.3 循环队列求长度

/* 返回Q的元素个数，也就是队列的当前长度 */
int QueueLength(SqQueue Q)
{
	return  (Q.rear-Q.front+MAXSIZE)%MAXSIZE;
}

3.2.4 入队

/* 若队列未满，则插入元素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;
}

3.2.5 出队

/* 若队列不空，则删除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;
}

4. 链队列

4.1 定义

队列的链式存储结构，其实就是线性表的单链表，只不过它只能尾进头出而已，简称为链队列。为了操作方便，我们将头指针指向链队列的头结点，队尾指针指向终端结点。

空队列时，front和rear都指向头结点。

链队列的结构：

#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;

4.2 操作

4.2.1 入队

入队操作，就是链表尾部插入结点。

/* 插入元素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;
}

4.2.2 出队

头结点的后继结点出队，将头结点的后继改为它后面的结点。若链表除头结点外只剩一个元素时，则需将rear指向头结点。

/* 若队列不空,删除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;
}

5 循环队列和链队列的比较

时间上，基本操作都是常数时间，即O（1）,不过，循环队列是事先申请好空间，使用期间不释放，而对于链队列，每次申请和释放结点会存在一些时间开销，如果入队出队频繁，则两者还是略有差异。

空间上，循环队列必须有固定的长度，所以就有了存储元素个数和空间浪费的问题。而链队列不存在这样的问题，尽管它需要一个指针域，会产生一些空间上的开销，但也可以接受。所以在空间上，链队列更加灵活。

总之，在可以确定队列长度最大值的情况下，建议用循环队列，如果无法预估队列的长度，则用链队列。

6 总结

其中，循环队列是为了避免数组插入和删除数据时需要移动数据而引入的。

参考：

《大话数据结构》

键盘上的钢琴师_v5

关注

2
点赞
踩
19

收藏

觉得还不错? 一键收藏
2
评论
数据结构——栈与队列（顺序栈、链栈、循环队列、链队列）

提示：以下内容不适合零基础人员，仅供笔者复习之用。概要：栈是限定仅在表尾进行插入和删除操作的线性表。队列是只允许在一端进行插入操作、而在另一端进行删除操作的线性表。一、栈1. 定义栈是限定仅在表尾进行插入和删除操作的线性表。（又称后进先出的线性表）2. 抽象数据类型3. 栈的顺序存储结构及实现#define MAXSIZE 2
复制链接

扫一扫

专栏目录