数据结构——第三章《栈、队列和数组》

最新推荐文章于 2024-09-13 18:30:00 发布

WBushYdc

最新推荐文章于 2024-09-13 18:30:00 发布

阅读量72

点赞数

分类专栏： 408 文章标签：数据结构算法

本文链接：https://blog.csdn.net/wbushydc/article/details/133625990

版权

408 专栏收录该内容

23 篇文章 1 订阅

订阅专栏

第三章栈、队列和数组

3.1栈

3.1.1栈的基本概念

1，定义

线性表是具有相同数据类型的n(n20）个数据元素的有限序列，其中n为表长，当n=0时线性表是一个空表。

栈(Stack）是只允许在一端进行插入或删除操作的线性表。

术语

栈顶：

允许插入和删除的一端

栈底：

不允许插入和删除的一端

空栈：

特性：后进先出（LIFO）

2，基本操作

InitList(&L)：初始化表。构造一个空的线性表L，分配内存空间。
DestroyList(&L)：销毁操作。销毁线性表，并释放线性表L所占用的内存空间

Listlnsert(&L,i,e)：插入操作。在表L中的第i个位置上插入指定元素e。
ListDelete(&L,i&e)：删除操作。删除表L中第1个位置的元素，并用e返回删除元素的值。

LocateElem(L.e)：按值查找操作。在表L中查找具有给定关键字值的元素。
GetElem(L,i)：按位查找操作。获取表L中第i个位置的元素的值。

其他常用操作：
Length(L)：求表长。返回线性表L的长度，即L中数据元素的个数。
PrintList(L)：输出操作。按前后顺序输出线性表L的所有元素值。
Empty(L)：判空操作。若L为空表，则返回true，否则返回false。

3.1.2栈的顺序存储实现(top=-1,指向当前元素)

顺序存储，用静态数组实现，并需要记录栈顶指针。

//顺序栈的定义
#define MaxSize 10
typedef struct
{
    ElmType data[MaxSize];//静态数组存放栈中元素
    int top;//栈顶指针，指向此时栈顶元素的位置
}SqStack;

1，基本操作

1，创（初始化）

void InitStack(SqStack &S)
{
    S.top = -1;//初始化栈顶指针
}

2，增（进栈）

先判断栈是否满了

//新元素入栈
bool Push(SqStack &S, ElemType x)
{
    if(s.top == MaxSize - 1)//栈满，报错
        return false;
    S.top = S.top + 1;//指针先加一
    s.data[S.top] = x;//新元素入栈
    return true;
}

3，删（出栈）

数据还残留在内存中，只是逻辑上被删除了

//出栈操作
bool Pop(SqStack &S, ElemType &x)
{
    if(S.top == -1)\\栈空，报错
        return false;
    x = S.data[S.top];
    S.top--;
    return true;
}

4，查（获取栈顶元素）

//读栈顶元素
bool GetTop(SqStack S, ElemType &x)
{
    if(S.top == -1)//栈空报错
        return false;
    x = S.data[s.top];
    retur true;
}

5，判空、判满

//判断栈空
bool StackEmpty(SqStack S)
{
    if(S.top == -1)
        return true;
    else
        return false;
}

2，两种实现

初始化时top=0和top=-1

前者代表栈顶指针指向下一个要插入的位置

后者指向当前元素的位置

3，共享栈

两个栈共享同一片内存空间，两个栈从两边往中间增长

初始化

0号栈栈顶指针初始时 top0=-1;

1号栈栈顶指针初始时 top1=MaxSize;

栈满条件

top0+ 1 == top1;

3.1.3栈的链式存储实现

跟单链表差不多，限制只能头插，删除也只能删除第一个元素

1，定义

用链式存储方式实现的栈

2，带头结点

两种实现方式
不带头结点（推荐）

3，重要基本操作

创（初始化）
增（进栈）
删（出栈）
查(获取栈顶元素)
如何判空、判满？

3.2队列

3.2.1队列的基本概念

1，定义

队列(Queue)是只允许在一端进行插入，在另一端删除的线性表。

特点：

先进入队列的元素先出队（FIFO）。

术语：

队头，队尾，空队列

队头：允许删除的一端

队尾：允许插入的一瑞

2，基本操作

InitQueue(&Q)：初始化队列，构造一个空队列Q。
DestroyQueue(&Q)：销毁队列。销毁并释放队列Q所占用的内存空间

EnQueue(&Q,x):入队，若队列Q未满，将x加入，使之成为新的队尾。
DeQueue(&Q,&x)：出队，若队列Q非空，删除队头元素，并用x返回。

GetHead(Q,&x)：读队头元素，若队列Q非空，则将队头元素赋值给x。

其他常用操作：
QueueEmpty(Q)：判队列空，若队列Q为空返回true，否则返回false。

3.2.2队列的顺序存储实现

1，队列的实现

#define MaxSize 10
typedef struct
{
    ElemType data[MaxSize]; //用静态数组存放队列元素
    int front,rear;//队头指针和队尾指针
}SqQueue;

分配一块连续的存储单元存放队列中的元素，并附设两个指针

队尾指针：指向队尾元素的后一个位置（下一个应该插入的位置)。

队头指针：指向队头元素。

2，基本操作

进队操作：队不满时，先送值到队尾元素,再将队尾指针加1
出队操作：队不空时，先取队头元素值，再将队头指针加1

1，初始化

//初始化队列
void InitQueu(SqQueue &Q)
{
    //初始化时，队头、队尾指针指向0
    Q.read = Q.front =0;
}

2，判空

bool QueueEmpty(SqQueue Q)
{
    if(Q.rear == Q.front0)
        return true;
    else
        return false;
}

3，增/删（入队/出队操作）

进队操作：队不满时，先送值到队尾元素,再将队尾指针加1
出队操作：队不空时，先队头元素值，再将队头指针加1

假溢出：这种溢出并不是真正的溢出，在data数组中依然存在可以存放元素的空位置

3，循环队列

把存储队列元素的表从逻辑上视为一个环，称为循环队列

初始时:Q.front=Q.rear=0
队首指针进1:Q.front=（Q.front+1）%MaxSize
队尾指针进1:Q.rear=(Q.rear+1)%MaxSize
队列长度：(Q.rear+MaxSize-Q.front)%MaxSize.

判断条件：

队空：Q.front=Q.rear

队满：

牺牲一个单元来区分队空和队满,即”队头指针在队尾指针的下一位置作为队满的标志”。

类型中增设表示元素个数的数据成员。

类型中增设tag数据成员，以区分是队满还是队空

3.2.3队列的链式存储实现

1，队列的实现

typedef struct LinkNode//链式队列节点
{
    ElemType data;
    struct LinkNode *next;
}LinkNode;
typedef struct{			//链式队列
    LinkNode *front, *rear;//队列的头和尾指针
}LinkQueue;

2，基本操作

1，创（初始化）

//初始化队列（带头节点）
void InitQueue(LinkQueue &Q)
{
    //初始时front、rear都指向头节点
    Q.front = Q.rear =(LinkNode *)malloc(sizeof(LinkNode));
    Q.front->next = NULL;
}

//判断队列是否为空
bool IsEmpty(LinkQueue Q)
{
    if(Q.front == Q.rear)
        return true;
    else
        return false;
}

//初始化队列（不带头节点）
void InitQueue(LinkQueue &Q)
{
    //初始化时front、rear都指向NULL
    Q.front = NULL;
    Q.front = NULL;
}

//判断队列是否为空（带头节点）
bool IsEmpty(LinkQueue Q)
{
    if(Q.front == NULL)
        return true;
    else 
        return false;
}

2，增（入队）

//新元素入队（带头结点）
void EnQueue(LinkQueue &Q, ElemType x)
{
    LinkNode *s = (LinkNode *)malloc(sizeof(LinkNode));
    s->data = x;
    s->next = NULL;
    Q.rear->next = s;//新节点插入到rear之后
    Q.rear = s;//修改表尾指针
}

//新元素入队（不带头结点）
void EnQueue(LinkQueue &Q, ElemType x)
{
    LinkNode *s = (LinkNode *)malloc(sizeof(LinkNode));
    s->data = x;
    s->next = NULL;
    if(Q.front == NULL)//在空队列中插入第一个元素时，队头和队尾指针都需要修改
    {
        Q.front = s;
        Q.rear = s;
    }
    else
    {
        Q.rear->next = s;//新节点插入到rear之后
   	 	Q.rear = s;//修改表尾指针
    }
}

3，删（出队）

//队头元素出队（带头节点）
bool DeQueu(LinkQueue &Q, ElemType &x)
{
    if(Q.front == Q.rear)//空队
        return false;
    LinkNode *p = Q.front->next;
    x = p->data;
    Q.front->next = p->next;//修改头节点的next指针
    if(Q.rear == p)//如果此次是最后一个节点出队
        Q.rear = Q.front;//修改rear指针的指向
    free(p);
    return true;
}

//队头元素出队（不带头节点）
bool DeQueu(LinkQueue &Q, ElemType &x)
{
    if(Q.front == Q.rear)//空队
        return false;
    LinkNode *p = Q.front;
    x = p->data;
    Q.front = p->next;//修改头节点的next指针
    if(Q.rear == p)//如果此次是最后一个节点出队
    {
        Q.rear = NULL;
        Q.front = NULL;
    }
    free(p);
    return true;
}