数据结构 第三章

最新推荐文章于 2023-10-21 12:13:24 发布
最新推荐文章于 2023-10-21 12:13:24 发布
阅读量409 收藏
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jike14455/article/details/40455391
版权

  3.1      栈

3.1.1    栈的逻辑结构

1.栈（stack）是限定仅在表尾进行插入和删除操作的线性表，允许插入和删除的而一端称为栈顶，另一端称为栈底。不含任何元素的栈称为空栈。

 

2.栈的特性：后进先出（在任何时候出栈的元素都只能是栈顶元素，即最后入栈者最先出栈）。

 

3. 栈的抽象数据类型定义

ADT Stack

Data

  栈中元素具有相同类型及后进先出的特性，相邻元素具有前驱和后继关系

Operation

   InitStack

      前置条件：栈不存在

      输入：无

      功能：栈的初始化

      输出：无

      后置条件：构造一个空栈

DestroyStack

      前置条件：栈已存在

      输入：无

      功能：销毁栈

      输出：无

      后置条件：释放栈所用的存储空间

Push

      前置条件：栈已存在

      输入：元素值x

      功能：入栈操作，在栈顶插入一个元素x

      输出：如果插入不成功，则抛出异常

      后置条件：如果插入成功，则栈顶增加了一个元素

Pop

      前置条件：栈已存在

      输入：无

      功能：出栈操作，删除栈顶元素

      输出：如果删除成功，返回被删元素值，否则，抛出异常

      后置条件：如果删除成功，则栈顶少了一个元素

GetTop

      前置条件：栈已存在

  

      输入：无

      功能：取栈顶元素，读取当前的栈顶元素

      输出：若栈不空，返回当前的栈顶元素值

      后置条件：栈不变

Empty

 

  

      前置条件：栈已存在

      输入：无

      功能：判空操作，判断栈是否为空

      输出：如果栈为空，返回1，否则，返回0

      后置条件：栈不变

endADT

3.1.2    栈的顺序存储结构及实现

1.  栈的顺序存储结构——顺序栈

     通常把数组中下标为0的一端作为栈底 。             指针top指示栈顶元素在数组中的位置。

     StackSize:存储栈元素的数组长度。                     栈空：top= -1       栈满：top=StackSize - 1

2.  顺序栈的实现

  将栈的抽象数据类型定义在顺序栈存储结构下用c++中的类实现。由于栈元素的数据类型不能确定，因此采用c++的模板机制。

 

const  int  StackSize=10;      // 10只是示例性的数据，可以根据实际问题具体定义

template  <class  datatype>   //定义模板类SeqStack

class  SeqStack

{

 public:

    SeqStack(){top= -1;}            //构造函数，初始化一个空栈

   ~ SeqStack(){ }               //析构函数为空

 Void push(DataType x);  //入栈操作，将元素x入栈

DataType pop();     //出栈操作，将栈顶元素弹出

DataType GetTop(){if(top!=-1) return data [top];} //取栈顶元素

Int Empty(){top==-1?return 1:return 0;}

Private:

Datatype data[StckMaxsize];

Int top;

                 

} ;

(1) 栈的初始化

初始化一个空栈只需将栈顶指针top置为-1。

（2）入栈操作

在栈中插入元素x只需将栈顶指针top加1，然后在top指向的位置填入元素x，算法如下：

template<class DataType>

void SeqStack<DataType>::Push(DataType x)

{

  If(top==StackSize-1) throw”上溢”；

  data[++top=x;]

}

（3）出栈操作

删除栈顶元素只需取出栈顶元素，然后将栈顶指针top减1，算法如下：

Template<class DataType>

DataType SeqStack<DataType>::pop()

{

 If(top==-1) throw”下溢”;

 X=data[top--];

 return x;

}

（4）取栈顶元素

取栈顶元素只是将top指向的栈顶元素取出，并不修改栈顶指针。

（5）判空操作

顺序栈的判空操作只需判断top==-1是否成立，如果成立，则栈为空，返回1；如果不成，则栈非空，返回0。

3． 两栈共享空间

两共享占空间入栈算法push

Template <class DataType>

Void BothStack<DataType>::push(int i,DataType x)

{

  If(top1==top2-1) throw”上溢”;

If(i==1)data[++top1]=x;

If(i==2)data[--top]=x;

}

两栈共享空间出栈算法Pop

Template <class DataType>

DataType BothStack<DataType>::Pop(int i)

{

  If(i==1)

   If(top1==-1)throw“下溢”；

  Return data[top--];

}

If(i==2)

If(top2==StackSize)throw”下溢”；

Return data[top2++];

  }

}

3.13 栈的链接存储结构及实现

1. 栈的链接存储结构——链栈

栈的链接存储结构称为链栈。

2. 链栈的实现

⑴构造函数

构造函数的作用是初始化一个空链栈，由于链栈不带头结点，因此只需将栈顶指针top置为空。

⑵入栈操作

链栈入栈算法Push

Template<class DataType>

Void LinkStack<DataType>::Push(DataType x)

{

S=new Node;s->data=x;

s->next=top;top=s;

}

⑶出栈操作

链栈出栈算法Pop

Template<class DataType>

DataType LinkStack<DataType>::Pop()

{

If(top==NULL)throw“下溢”；

X=top->data;p=top;

Top=top->next;

Delete p;

Return x;

}

⑷取栈顶元素

取栈顶元素只需返回栈顶指针top所指结点的数据域。

⑸判空操作

链栈的判空操作只需判断top==NULL是否成立。如果成立，则栈为空，返回1；如果不成立，则栈非空，返回0。

⑹析构函数

链栈的析构函数需要将链栈中所有结点的存储空间释放，算法与单链表类的析构函数类似，算法略。

3.14 顺序栈和链栈的比较

实现顺序栈和链栈的所有基本操作的算法都只需要常数时间，因此唯一可以比较的是空间性能。初始时顺序栈必须确定一个固定的长度，所以有存储元素个数的限制和空间浪费的问题。链栈没有栈满的问题，只有当内存没有可用空间时才会出现栈满，但是每个元素都需要一个指针域，从而产生了结构性开销。所以当栈的使用过程中元素个数变化较大时，用链栈是适宜的；反之，应该采用顺序栈。

3.2 队 列

3.2.1队列的逻辑结构

1.定义：队列只允许在一端进行插入操作，在另一端进行删除操作的线性表。

允许插入的一端称为队尾，允许删除的一端称为队头。（先进先出）

2.队列的抽象数据类型定义

ADT   Queue

         InitQueue

               前置条件：队列不存在

               输入：无

               功能：初始化队列

               输出：无

               后置条件：创建一个空队列

      DestroyQueue

               前置条件：队列已存在

               输入：无

               功能：销毁队列

               输出：无

               后置条件：释放队列所占用的存储空间

     EnQueue

              前置条件：队列已存在

             输入：元素值x

             功能：入队操作，在队尾插入一个元素

             输出：如果插入不成功，抛出异常

             后置条件：如果插入成功，队尾增加了一个元素

     DeQueue

           前置条件：队列已存在

           输入：无

           功能：出队操作，删除队头元素

           输出：如果删除成功，返回被删元素值，否则，抛出删除异常

           后置条件：如果删除成功，队头减少了一个元素

   GetQueue

           前置条件：队头已存在

           输入：无

           功能：读取队头元素

          输出：若队列不空，返回队头元素

          后置条件：队列不变

  Empty

          前置条件：队列不存在

          输入：无

          功能：判空操作，判断队列是否为空

          输出：如果队列为空，返回1，否则返回0

          后置条件：队列不变

endADT

3.2.2队列的顺序存储结构及实现

循环队列：队列的头尾相接的顺序存储结构称为循环队列。

约定：队头指针front指向队头元素的前一个位置，队尾指针rear指向队尾元素。

假溢出：当元素被插入到数组中下标最大的位置上之后，队列的空间就用尽了，尽管此时数组的低端还有空闲空间，这种现象叫做“假溢出”。

队空和队满的判定：队空front=rear

                            队满（rear+1）%QueueSize==front

循环队列的实现

const int QueueSize=100;                           //定义存储队列元素的数组的最大长度

template<class DataType>                           //定义模板类CirQueue

class CirQueue

{

public:

CirQueue(){front=rear=QueueSize;}              //构造函数，初始化空队列

~CirQueue(){}                                  //析构函数为空

void EnQueue(DataType x);                      //入队操作，将元素x入队

DataType DeQueue();                            //出队操作，将队头元素出队

DataType GetQueue();                           //读取队头元素（并不删除）

int Empty(){front==rear?return 1:return 0;}    //判断队列是否为空

private:

DataType data[QueueSize];                     //存放队列元素的数组

int front,rear;                               //队头和队尾指针

};

（1） 构造函数

构造函数的作用是初始化一个空的循环队列，只需将队头指针和队尾指针同时指向数组的某一个位置，一般是数组的高端，即rear=front=QueueSize-1。

（2） 入队操作

template <class DataType>

void CirQueue<DataType>::EnQueue(DataType x)

{

if ((rear+1)%QueueSize==front) throw"上溢";

rear=(rear+1)%QueueSize;                    //队尾指针在循环意义下加1

data[rear]=x;                               //在队尾处插入元素

}

（3） 出队操作

template <class DataType>

DataType CirQueue<DataType>::DeQueue()

{

if (rear==front) throw"下溢";

front=(front+1)%QueueSize;                  //队头指针在循环意义下加1 

return data[front];                         //读取并返回出队前的队头元素

}

（4） 读取队头元素

template <class DataType>

DataType CirQueue<DataType>::GetQueue()

{

if(rear==front) throw"下溢";

i=(front+1)%QueueSize;                 //注意不要给队头指针赋值

return data[i];

}

（5） 判空操作

循环队列的判空操作只需要判定front==rear是否成立。如果成立，则队列为空，返回1；如果不成立，则队列非空，返回0。

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

链队列：队列的链式存储结构称为链队列。

链队列的实现

template <class DataType>

class LinkQueue

{

public:

LinkQueue();                    //构造函数，初始化一个空的链队列

~LinkQueue();                   //析构函数，释放链队列中各结点的存储空间

void EnQueue(DataType x);       //入队操作，将元素x入队

DataType DeQueue();             //出队操作，将队头元素出队

DataType GetQueue();            //取链队列的队头元素

int Empty(){front==rear?return 1: return 0;}//判断链队列是否为空

private:

Node<DataType> *front, *rear;   //队头和队尾指针，分别指向头结点和终端结点

};

（1） 构造函数

template <class DataType>

LinkQueue<DataType>::LinkQueue()

{

Node<DataType> *s=NULL;

s=new Node<DataType>;s->next=NULL;//创建一个头结点

front=rear=s;                     //将队头指针队尾指针都指向头结点s

}

（2） 析构函数

template <class DataType>

LinkQueue<DataType>::~LinkQueue()

{

Node<DataType> *p=NULL;

while (front!=NULL)

{

p=front->next;

delete front;

front=p;

}

}

（3）入队操作

template <class DataType>

void LinkQueue<DataType>::EnQueue(DataType x)

{

Node<DataType> *s=NULL;

s=new Node<DataType>;s->data=x;//申请一个数据域为x的结点s

s->next=NULL;

rear->next=s;                  //将结点s插入到队尾

rear=s;

}

（4）出队操作

template <class DataType>

DataType LinkQueue<DataType>::DeQueue()

{

Node<DataType> *p=NULL;

int x;

if(rear==front) throw"下溢";

p=front->next;x=p->data;//暂存队头元素

front->next=p->next;    //将队头元素所在结点摘链

if(p->next==NULL) rear=front;//判断出队前队列长度是否为1

delete p;

return x;

}

（5）读取

template <class DataType>

DataType LinkQueue<DataType>::GetQueue()

{

if(front!=rear)

return front->next->data;

}

template <class DataType>::Empty()

{

if(front==rear)

return 1;

else

return 0;

}

3.3 应用举例

3.3.1 栈的应用举例——表达式求值

3.3.2栈的应用举例——火车车厢重排

思想火花——直觉可能是错误的

 

 

 

jike14455
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构第三章
yuuka77的专栏
10-25 298
3.1     栈 3.1.1    栈的逻辑结构 1.栈（stack）是限定仅在表尾进行插入和删除操作的线性表，允许插入和删除的而一端称为栈顶，另一端称为栈底。不含任何元素的栈称为空栈。   2.栈的特性：后进先出（在任何时候出栈的元素都只能是栈顶元素，即最后入栈者最先出栈）。   3. 栈的抽象数据类型定义 ADT Stack Data   栈中元素具有相同类型及后进先出
顺序栈的功能实现（初始化，判空，压栈，弹栈，打印栈顶元素，批量手动输入元素压栈弹栈） ——以c语言为例
immortalize的博客
11-03 544
顺序栈特点：FILO(先进后出） 计算顺序栈的长度方法：length=s.top-s.base; 时间复杂度：O（1） #include <stdio.h> #include <iostream> using namespace std; #define sElemType int //预定义类型 #define STACK_INIT_SIZE 10 //预定义初始容量 //定义顺序栈的结构体 typedef struct sqStack{ sEl
数据结构（栈Stack和队列Queue）
jxttutu的博客
02-28 850
3.1栈和队列的定义和特点 3.1.1栈的定义和特点 *栈是仅限于表尾进行插入和删除操作的线性表 *栈的表尾称为栈顶（top），表头称为栈底(base)。不含元素的空表称为空栈 *插入元素到栈顶称为入栈（push），也称压栈 *从栈顶删除一个元素称为出栈（pop），也称弹栈 *栈是一种后进先出的线性表（LIFO） ***已知入栈顺序，求可能的出栈顺序问题 *栈的存储结构分...
数据结构-----栈
lixiaoting9181的博客
03-12 192
才这么聪明的魔法科目·
数据结构之C语言实现队列（学习笔记）
weixin_45803046的博客
07-21 225
一、队列的基本概念 队列是只允许在另一端进行插入操作，而在另一端进行删除操作的线性表 队列是一种先进先出（First In First Out）的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。 二、循环队列 把队列这种头尾相接的顺序存储结构称为循环队列 1.队列满的条件 //当头指针和尾指针相邻时，说明对了已满 (rear+1)%QueueSize==front; 2.队列长度计算公式 rear->front+QueueSize)%QueueSize; 循环队列的
数据结构第三章栈
11-17
数据结构第三章栈，数据结构第三章栈课件，数据结构第三章栈PPT
严蔚敏数据结构第三章所有代码
07-14
严蔚敏数据结构第三章所有代码，其余章节的代码在CSDN中查找
数据结构第三章习题.pdf
09-30
数据结构第三章习题.pdf
数据结构第3章1
08-08
第3章 链表一、复习要点本章重点讨论最简单的链表结构——单链表。详细地介绍了单链表的抽象数据类型，单链表的类定义，相应操作的实现，引入了带表头结点的单链表结构。
【数据结构】线性表（八）队列：顺序队列及其基本操作（初始化、判空、判满、入队、出队、存取队首元素）
最新发布
CSDN2023博客之星Top22 人工智能领域赛道Top2 大三赛道Top2 码龄2-3年赛道Top3
10-21 1071
本文实现了一个基本的顺序队列，包括队列的初始化、判空、判满、入队、出队和获取队首元素等操作。
数据结构：循环队列
Hokachi的博客
11-16 1329
的操作，我的思路是将头指针固定不动，然后每一次元素入队就将尾指针后移，每一次出队就把当前头指针指向的元素返回，然后将整个数组整体前移一个位置，尾指针同时减一。与普通队列不同的是，头指针front与尾指针rear的初始值都设置为0，并且由于循环队列中需要空出一个位置用于判断和保持操作一致，因此数组实际大小应该比用户期待队列的大小大1，因此size的值应该为用户期待队列大小的值maxsize加一。的学习笔记，这一篇写的是循环队列，大部分代码可以继续沿用，某些地方需要作出更改，使其可以实现循环队列的功能。
顺序队列和链队列（Queue模板）
快乐不能半途而废的博客
03-09 1307
目录 模板：CSDN 一、队列 1.定义： 2.储存方式： 3.基本操作: 二、判断顺序队列队满的三种方法 三、基本操作： 1.声明 2.初始化数据 3.入队 4.出队 5.判断队满和队空 6.获得栈顶元素 7.清空队列 8.显示队列数据 四、模板（自制） 1.顺序队列 2.链队列 模板：相关讲解CSDN 一、队列 1.定义： 只允许在一端...
数据结构（C++)_3-2队列
zu_zhu_xia的博客
07-11 189
基本概念 1.只允许在一端进行插入操作，在另一端进行删除操作的线性表； 2.队尾：允许插入（入队、进队）的一端； 3.队头：允许删除（出队）的一端； 4.特性：先进先出 5.例子：银行排队、键盘缓冲区、操作系统的作业调度 01顺序队列 1.设置队头、队尾变量 rear 、front; 2.入队rear加1、出队rear-1; 3.约定：front指向队头元素的前一个位置，rear指向队尾元素的位置； 02循环队列 1.假溢出：队列向数组高端移动，元素插入到数组下标的最大位置后，数组低端还有空闲空间； 2.解
栈
dongyanxia1000的专栏
07-28 343
1、栈（stack）是限定仅在表尾进行插入和删除操作的线性表。（表尾指栈顶） ---- 把允许插入和删除的一端称为栈顶（top），另一端称为栈底（bottom），不含任何数据元素的栈称为空栈。 栈又称为后进先出（Last In First Out）的线性表，简称LIFO结构。 理解栈的定义需要注意： ---- 首先它是一个线性表，也就是说，栈元素具有线性关系，即前驱后继关系。只不过它是一种
栈的基本建立以及应用（括号匹配)
Nactua的博客
05-10 676
栈是一种运算受限的线性表，是一种特殊的线性表。他只允许在表尾进行插入和删除操作的线性表。其中一段被称为栈顶，另一端称为栈底。向一个栈插入新元素称作入栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素。同理的，从一个栈删除元素又称作出栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。栈的基本建立包括初始化，建立入栈函数，出栈函数和测试函数。 1、初始化 #include <stdio.h> #include <malloc.h> #defi...
循环队列的实现（初始化、入队操作、出队操作、判满、判空、获取队头、队尾元素、销毁操作）
weixin_46153828的博客
03-15 3398
typedef struct { int* array; int front; int rear; int count; //用count++的方式判断循环队列是否满 int N; //总个数 } MyCircularQueue; //初始化 MyCircularQueue* myCircularQueueCreate(int k) { MyCircularQueue* myQueue=(MyCircularQueue*)malloc(sizeof(MyCircu...
数据结构|顺序队列的实现（实验3.3）
weixin_40141473的博客
10-18 1347
一、实验目的 1、熟练掌队列的结构特点，掌握队列的顺序存储和实现。 2、学会使用队列解决实际问题。 二、实验内容 1、自己确定结点的具体数据类型和问题规模，建立一个顺序队列，实现队列的入队和出队操作。 三、实验步骤 1、依据实验内容分别说明实验程序中用到的数据类型的定义； template<typename T> class Cirqueue{ ...
Queue基本操作
DL猿
10-18 793
queue没有迭代器 所以queue不允许随机访问，不允许随机访问的都没有迭代器 queue构造函数 queue<T> queT;//queue采用模板类实现，queue对象的默认构造形式： queue存取、插入和删除操作 push(elem);//往队尾添加元素 pop();//从队头移除第一个元素 back();//返回最后一个元素 front();//返回第一个元素 queue赋值操作 queue& operator=(const queue &que);//重载
java语言程序设计与数据结构第三章
03-16
Java语言程序设计与数据结构第三章主要介绍了Java中的基本数据类型、运算符、表达式、控制流语句等内容。其中，基本数据类型包括整型、浮点型、字符型、布尔型等，运算符包括算术运算符、关系运算符、逻辑运算符等，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值