slide1 n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
第三章 栈和队列 PowerPoint Presentation
Download Presentation
第三章 栈和队列

Loading in 2 Seconds...

play fullscreen
1 / 53

第三章 栈和队列 - PowerPoint PPT Presentation


  • 152 Views
  • Uploaded on

第三章 栈和队列. 3.1 栈. 3.2 栈的应用. 3.3 队列. 3.5 队列的应用. 学习目标. 目的: 介绍栈和队列的逻辑结构定义及在两种存储结构上如何实现栈和队列的基本运算。 要求: 在掌握栈和队列的特点的基础上,懂得在什么样的情况下能够使用栈和队列。 重点: 掌握栈和队列在两种存储结构上实现的基本运算。 难点: 循环队列重对边界条件的处理。. 引 言.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about '第三章 栈和队列' - aquarius


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
slide1
第三章 栈和队列

3.1 栈

3.2 栈的应用

3.3 队列

3.5 队列的应用

slide2
学习目标

目的:介绍栈和队列的逻辑结构定义及在两种存储结构上如何实现栈和队列的基本运算。

要求:在掌握栈和队列的特点的基础上,懂得在什么样的情况下能够使用栈和队列。

重点:掌握栈和队列在两种存储结构上实现的基本运算。

难点:循环队列重对边界条件的处理。

slide3

引 言

栈和队列是两种重要的线性结构。从数据结构的角度看,栈和队列也是线性表,其特殊性在于栈和队列的基本操作是线性表操作的子集,他们是操作受限的线性表,因此,可称为限定性的数据结构;但从数据类型的角度看,它们是和线性表大不相同的两类重要的抽象数据类型。由于它们广泛的应用在各种软件系统中,因此在面向对象的程序设计中,它们是多型数据类型。

slide4

3.1 栈

3.1.1 抽象数据类型栈的定义

栈(Stack)是限定仅在表尾进行插入或删除操作的线性表。通常称其表尾为栈顶(top),表头端称为栈底(bottom)。

假设栈S={ ai | ai ∈ElemSet, i=1,2,...,n, n≥0 },则称a1为栈底元素,an为栈顶元素,栈中元素按a1,a2,…an的次序进栈,退栈的第一个元素应为栈顶元素。因此,栈又称为后进先出(last in first out)的线性表(简称LIFO表)。

slide5

栈的抽象数据类型定义:

ADT Stack{

数据对象:

D={ ai | ai ∈ElemSet, i=1,2,...,n, n≥0 }

数据关系:

R1={ <ai-1, ai >| ai-1, ai∈D, i=2,...,n }

约定an端为栈顶,a1 端为栈底。

基本操作:

} ADT Stack

slide6

数据对象:D={ai| ai∈ElemSet, i=1,2,···,n, n≥0}数据关系:R1={<ai-1, ai >|ai-1, ai∈D, i=1,2,···,n}约定an端为栈顶,a1端为栈底基本操作: InitStack(&S)操作结果:构造一个空栈 S。DestroyStack(&S)初始条件:栈 S 已存在。 操作结果:栈 S 被销毁。

stackempty s s s true fale stacklength s s s
StackEmpty(S)初始条件:栈 S 已存在。操作结果:若栈 S 为空栈,则返TRUE,否则 FALE。StackLength(S)初始条件:栈 S 已存在。操作结果:返回 S 的元素个数,即栈的长度。

ClearStack(&S)初始条件:栈 S 已存在。操作结果:将 S 清为空栈。

gettop s e s e s
GetTop(S, &e)初始条件:栈 S 已存在且非空。操作结果:用 e 返回 S 的栈顶元素。

… …

a1

a2

an

Push(&S, e)初始条件:栈 S 已存在。 操作结果:插入元素 e 为新的栈顶元素。

… …

a1

a2

an

e

pop s e s s e
Pop(&S, &e)初始条件:栈 S 已存在且非空。操作结果:删除 S 的栈顶元素,并用 e 返回其值

… …

a1

a2

an-1

an

StackTraverse (S, visit())初始条件:栈 S 已存在。操作结果:从栈底到栈顶依次对S 的每个数据元素调用函数visit()。一旦visit()失败,则操作失败。

} ADT Stack

slide10

3.1.2 栈的表示和实现

顺序栈的定义:

typedef struct {

SElemType *base; //栈底指针

SElemType *top; //栈顶指针

int stacksize;

} SqStack

其中, stacksize指示栈的当前可使用的最大容量。Top为栈顶指针,其初值指向栈底,每当插入新元素,指针top加1,删除栈顶元素时,指针top减1。非空栈中,top始终指向栈顶元素的下一个位置。

slide11

以下是顺序栈的模块说明。

//-----ADT Stack的表示与实现-----

//-----栈的顺序存储表示-----

#define STACK_ INIT_ SIZE 100;//存储空间初始分配量

#define STACKINCREMENT 10;//存储空间分配增量

typedef struct {

SElemType *base;

//在栈构造之前和销毁之后, base的值为NULL

SElemType *top;//栈顶指针

int stacksize;

//当前已分配的存储空间,以元素为单位

} SqStack

slide12

-----基本操作的函数原型说明-----

Status InitStack (SqStack &S );

// 构造一个空栈S

Status DestroyStack(SqStack &S);

// 销毁栈S,S不再存在

Status ClearStack (SqStack &S );

// 重置S为空栈

Status StackEmpty (SqStackS );

//若栈为空栈,则返回TRUE,否则 返回FALSE

int StackLength (SqStackS );

//返回S的元素个数,即栈的长度

slide13

Status GetTop (SqStackS , SElemType &e )

//若栈不空,则用e返回S的栈顶元素,并返回OK,否则返回ERROR

Status Push (SqStack &S , SElemType e )

// 插入元素e为新的栈顶元素

Status Pop (SqStack &S , SElemType &e )

//若栈不空,则删除S的栈顶元素,并用e返回其值,并返回OK,否则返回ERROR

Status StackTraverse (SqStack &S , Status(*visit)() );

//从栈底到栈顶依次对栈中每个元素调用函数visit()。一旦visit()失败,则操作失败

slide14
//-----基本操作的算法描述(部分)-----

Status InitStack (SqStack &S ); // 构造一个空栈S

S.base = (SElemType*) malloc (STACK_INIT_SIZEsizeof (ElemType));

if (! S.base) exit(OVERFLOW); //存储分配失败

S.top =S.base;

S.stacksize =STACK_INIT_SIZE;

return OK;

}//InitStack

slide15
StatusGetTop (SqStackS , SElemType &e )

//若栈不空,则用e返回S的栈顶元素,并

//返回OK,否则返回ERROR

if(S.top ==S.base) return ERROR;

e=*(S.top-1);

return OK;

}// GetTop

slide16
Status Push (SqStack &S , SElemType e )

{ // 插入元素e为新的栈顶元素

if(S.top -S.base >= S.stacksize) {

{ // 当前存储空间已满,增加分配

S.base = (ElemType *)realloc(S.base,

(S.stacksize+STACKINCREMENT)*sizeof (ElemType));

if (! S.base) exit(OVERFLOW); // 存储分配失败

S.top =S.base+S.stacksize;

S.stacksize+= STACKINCREMENT//增加存储容量

}

*S.top++=e;

return OK;

}// Push

slide17
Status Pop (SqStack &S , SElemType &e )

//若栈不空,则删除S的栈顶元素,并

//用e返回其值,并返回OK,否则返回

//ERROR

if(S.top ==S.base) return ERROR;

e=*--S.top;

return OK;

}// Pop

slide18

3.2 栈的应用举例

3.2.1 数制转换

3.2.2 括号匹配的检验

3.2.3 行编辑程序问题

3.2.4 迷宫求解

3.2.5 表达式求值

3 2 1 n d n n div d d n mod d div mod
3.2.1 数制转换十进制数N和其它d进制数的转换的算法基于原理:N = (N div d)×d + N mod d其中,div 相除取整,mod 相除取余。

例如:(1348)10 = (2504)8, 其运算过程如下:N N div 8 N mod 8 1348 168 4 168 21 0 21 2 5 2 0 2

计算顺序

输出顺序

slide20

void conversion () {

//对于输入的任意一个非负十进制整数,

//打印输出与其等值的八进制数

InitStack(S); //构造空栈

scanf ("%d",N);

while (N) {

Push(S, N % 8);

N = N/8;

}

while (!StackEmpty(S)) {

Pop(S,e);

printf ( "%d", e );

}

}// conversion

算法 3.1

slide21

3.2.2 表达式求值

限于二元运算符的表达式定义:

表达式 ::= (操作数) + (运算符) + (操作数)

操作数 ::= 简单变量 | 表达式

简单变量 :: = 标识符 | 无符号整数

表达式的三种标识方法:设 Exp = S1 + OP + S2

则称OP + S1 + S2为前缀表示法

S1 + OP + S2为中缀表示法

S1 + S2 + OP为后缀表示法

slide22

例如: Exp = a  b+(c  d / e)  f

前缀式: + a b c / d e f

中缀式: a  b+c  d / e  f

后缀式: a b c d e /  f +

结论:

1)操作数之间的相对次序不变;

      • 2)中缀式丢失了括弧信息,
  • 致使运算的次序不确定;
  • 3)前缀式的运算规则为:
  • 连续出现的两个操作数和在它们
  • 之前且紧靠它们的运算符构成一
  • 个最小表达式;
slide23
4)后缀式的运算规则为:
  • 运算符在式中出现的顺序恰为
  • 表达式的运算顺序;
  • 每个运算符和在它之前出现 且
  • 紧靠它的两个操作数构成一个最小
  • 表达式。
slide24

如何从后缀式求值?

例如:

a b  c d e /  f  +

先找运算符,再找操作数

ab

d/e

c-d/e

(c-d/e)f

slide25

如何从原表达式求得后缀式?

分析 “原表达式” 和 “后缀式”中的运算符:

原表达式:a + b c  d / e f

后缀式: a b c  + d e / f 

每个运算符的运算次序要由它之后的一个运算符来定,在后缀式中,优先数高的运算符领先于优先数低的运算符。

slide26

从原表达式求得后缀式的规律为:

  • 1) 设立操作符栈;
  • 2) 设表达式的结束符为“#”,予设运算符栈的栈底为“#”;
  • 3) 若当前字符是操作数,则直接发送给后缀式。
  • 4) 若当前运算符的优先数高于栈顶运算符,则进栈;
  • 5) 否则,退出栈顶运算符发送给后缀式;

6) “(”对它之前后的运算符起隔离作用,“)”可视为自相应左括弧开始的表达式的结束符。

slide27

void transform(char suffix[ ], char exp[ ] ) {

//已知表达式exp,求其后缀表达式suffix

InitStack(S); Push(S, #);

p = exp; ch = *p;

while (!StackEmpty(S)) {

if (!IN(ch, OP)) Pass( Suffix, ch);

else { }

if ( ch!= # ) { p++; ch = *p; }

else { Pop(S, ch); Pass(Suffix, ch); }

} // while

} // CrtExptree

slide28

switch (ch) {

case ( : Push(S, ch); break;

case ) : Pop(S, c);

while (c!= ( )

{ Pass( Suffix, c); Pop(S, c) }

break;

defult :

while(Gettop(S, c) && ( precede(c,ch)))

{ Pass( Suffix, c); Pop(S, c); }

if ( ch!= # ) Push( S, ch);

break;

} // switch

slide29

算符优先算法求表达式值过程为:

  • 1) 设立操作符栈OPTR,操作数或运算结果栈OPND;
  • 2) 设表达式的结束符为“#”,予设运算符栈的栈底为“#”,操作数栈为空栈;
  • 3) 依次读入表达式中每个字符,若是操作数则进OPND栈,若是运算符则和OPTR栈的栈顶运算符比较优先权后作相应操作,直至整个表达式求值完毕(即OPTR栈的栈顶元素和当前读入的字符均为‘#’)。
slide30
OperandType EvaluateExpression() {

//算术表达式求值的算符优先算法。设OPTR和OPND

//分别为运算符栈和运算数栈,OP为运算符集合。

InitStack (OPTR); Push(OPTR,’#’);

initStack (OPND); c=getchar();

while (c!=‘#’||GetTop(OPTR)!=‘#’) {

if (!In (c, OP)) { Push (OPND, c); c= getchar();}

//不是运算符则进栈

else

switch (Precede( GetTop (OPTR), c)){

case’<’: //栈顶元素优先权低

Push (OPTR, c); c= getchar();

break;

slide31
case’=’: //脱括号并接受下一字符

Pop (OPTR, c); c= getchar();

break;

case’>’: //退栈并将运算结果入栈

Pop (OPTR, theta);

Pop (OPND, b); Pop (OPND, a);

Push (OPND, Operate (a,

theta, b));

break;

}//switch

}//while

return GetTop(OPND);

}//EvaluateExpression

算法 3.4

slide32

3.3 队列

3.3.1 抽象数据类型队列的定义

队列(queue )是一种先进先出(first in first out,简称FIFO表)的线性表。它只允许在表的一端进行插入,而在另一端删除元素。

在队列中,允许插入的一端叫做队尾(rear),允许删除的一端称为队头(front)。

假设队列为q= (a1,a2,…an),则a1为队头元素,an为队尾元素。

slide33

抽象数据类型队列的定义

ADT Queue {

数据对象:

D={ai | ai∈ElemSet, i=1,2,...,n, n≥0}

数据关系:

R1={ <a i-1,ai > | ai-1, ai ∈D, i=2,...,n}

约定:其中a1端为队列头, an端为队列尾

基本操作:

} ADT Queue

initqueue q q destroyqueue q q q
InitQueue(&Q)操作结果:构造一个空队列Q。DestroyQueue(&Q)初始条件:队列Q已存在。操作结果:队列Q被销毁,不再存在。InitQueue(&Q)操作结果:构造一个空队列Q。DestroyQueue(&Q)初始条件:队列Q已存在。操作结果:队列Q被销毁,不再存在。

队列的基本操作:

QueueEmpty(Q)初始条件:队列Q已存在。操作结果:若Q为空队列,则返回TRUE,否则返回FALSE。

queuelength q q q
QueueLength(Q)初始条件:队列Q已存在。操作结果:返回Q的元素个数,即队列的长度。QueueLength(Q)初始条件:队列Q已存在。操作结果:返回Q的元素个数,即队列的长度。

GetHead(Q, &e)初始条件:Q为非空队列。操作结果:用e返回Q的队头元素。

… …

a1

a2

an

clearqueue q q q
ClearQueue(&Q)初始条件:队列Q已存在。操作结果:将Q清为空队列。ClearQueue(&Q)初始条件:队列Q已存在。操作结果:将Q清为空队列。

EnQueue(&Q, e)初始条件:队列Q已存在。操作结果:插入元素e为Q 的新的队尾元素。

… …

a1

a2

an

e

dequeue q e q q e
DeQueue(&Q, &e)初始条件:Q为非空队列。操作结果:删除Q的队头元素,并用e返回其值。

… …

a1

a2

an

slide38

3.3.2 链队列

——队列的链式表示和实现

链队列——队列的链式映象

typedef struct QNode {// 结点类型

QElemType data;

struct QNode *next;

} QNode, *QueuePtr;

slide39

typedef struct { // 链队列类型

QueuePtr front; // 队头指针

QueuePtr rear; // 队尾指针

} LinkQueue;

a1

an

Q.front

Q.rear

Q.front

Q.rear

空队列

slide40

-----基本操作的函数原型说明-----

Status InitQueue (LinkQueue &Q );

// 构造一个空的队列Q

Status DestroyQueue (LinkQueue &Q );

// 销毁队列Q,Q不再存在

Status ClearQueue (LinkQueue &Q );

// 重置Q为空队列

Status QueueEmpty (LinkQueue Q );

//若为空队列,则返回TRUE,否则 返回FALSE

int QueueLength (LinkQueue Q );

//返回Q的元素个数,即队列的长度

slide41

Status GetHead (LinkQueue Q , QElemType &e )

//若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR

Status EnQueue (LinkQueue &Q , QElemType e )

// 插入元素e为新的队尾元素

Status DeLinkQueue (LinkQueue &Q , QElemType &e )

//若队列不空,则删除Q的队头元素,并用e返回其值,并返回OK,否则返回ERROR

Status Queue Traverse (LinkQueue &Q , visit() );

//从队尾到队头依次对队列中每个元素调用函数visit()。一旦visit()失败,则操作失败

slide42

Status InitQueue (LinkQueue &Q) {

// 构造一个空队列Q

Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));

if (!Q.front) exit (OVERFLOW); //存储分配失败

Q.front->next = NULL;

return OK;

}

slide43

Status DestroyQueue (LinkQueue &Q) {

// 销毁队列Q

while (Q.front) {

Q.rear = Q.front->next;

free (Q.front) ;

Q.front = Q.rear;

}

return OK;

}

slide44

Status EnQueue (LinkQueue &Q, QElemType e) {

// 插入元素e为Q的新的队尾元素

p = (QueuePtr) malloc (sizeof (QNode));

if(!p) exit (OVERFLOW); //存储分配失败

p->data = e; p->next = NULL;

Q.rear->next = p; Q.rear = p;

return OK;

}

slide45

Status DeQueue (LinkQueue &Q, QElemType &e) {

// 若队列不空,则删除Q的队头元素,

//用 e 返回其值,并返回OK;否则返回ERROR

if (Q.front == Q.rear) return ERROR;

p = Q.front->next; e = p->data;

Q.front->next = p->next;

if (Q.rear == p) Q.rear = Q.front;

free (p); return OK;

}

slide46

3.3.3 循环队列——队列的顺序表示和实现

#define MAXQSIZE 100 //最大队列长度

typedef struct {

QElemType *base; // 动态分配存储空间

int front; // 头指针,若队列不空,

// 指向队列头元素

int rear; // 尾指针,若队列不空, //指向队列尾元素 的下一个位置

} SqQueue;

slide47

Status InitQueue (SqQueue &Q) {

// 构造一个空队列Q

Q.base = (ElemType *) malloc

(MAXQSIZE *sizeof (ElemType));

if (!Q.base) exit (OVERFLOW); //存储分配失败

Q.front = Q.rear = 0;

return OK;

}

slide48

Status EnQueue (SqQueue &Q, ElemType e) {

// 插入元素e为Q的新的队尾元素

if ((Q.rear+1) % MAXQSIZE == Q.front)

return ERROR; //队列满

Q.base[Q.rear] = e;

Q.rear = (Q.rear+1) % MAXQSIZE;

return OK;

}

slide49

Status DeQueue (SqQueue &Q, ElemType &e) {

// 若队列不空,则删除Q的队头元素,

// 用e返回其值,并返回OK; 否则返回ERROR

if (Q.front == Q.rear) return ERROR;

e = Q.base[Q.front];

Q.front = (Q.front+1) % MAXQSIZE;

return OK;

}

slide50

3.4 队列的应用

队列在日常生活中和计算机程序设计中,有着非常重要的作用,在此,仅举出两个方面例子来说明它,其它应用在后面章节中将会遇到。

slide51

例子1:

第一个例子就是CPU资源的竞争问题。在具有多个终端的计算机系统中,有多个用户需要使用CPU各自运行自己的程序,它们分别通过各自终端向操作系统提出使用CPU的请求,操作系统按照每个请求在时间上的先后顺序,将其排成一个队列,每次把CPU分配给队头用户使用,当相应的程序运行结束,则令其出队,再把CPU分配给新的队头用户,直到所有用户任务处理完毕。

slide52

例子2:主机与外部设备之间速度不匹配问题。例子2:主机与外部设备之间速度不匹配问题。

以主机和打印机为例来说明,主机输出数据给打印机打印,主机输出数据的速度比打印机打印的速度要快得多,若直接把输出的数据送给打印机打印,由于速度不匹配,显然是不行的。所以解决的方法是设置一个打印数据缓冲区,主机把要打印输出的数据依次写入到这个缓冲区中,写满后就暂停输出,继而去做其它的事情,打印机就从缓冲区中按照先进先出的原则依次取出数据并打印,打印完后再向主机发出请求,主机接到请求后再向缓冲区写入打印数据,这样利用队列既保证了打印数据的正确,又使主机提高了效率。

slide53

本章小结

掌握栈和队列类型的特点,并能在相应的应用问题中正确选用它们。

熟练掌握栈类型的两种实现方法,特别应注意栈满和栈空的条件以及它们的描述方法。

熟练掌握循环队列和链队列的基本操作实现算法,特别注意队满和队空的描述方法。

理解递归算法执行过程中栈的状态变化过程。