强烈推荐,零基础学数据结构 第4章 栈
数据结构答案第4章
第 4 章广义线性表——多维数组和广义表2005-07-14第 4 章广义线性表——多维数组和广义表课后习题讲解1. 填空⑴数组通常只有两种运算:()和(),这决定了数组通常采用()结构来实现存储。
【解答】存取,修改,顺序存储【分析】数组是一个具有固定格式和数量的数据集合,在数组上一般不能做插入、删除元素的操作。
除了初始化和销毁之外,在数组中通常只有存取和修改两种操作。
⑵二维数组A中行下标从10到20,列下标从5到10,按行优先存储,每个元素占4个存储单元,A[10][5]的存储地址是1000,则元素A[15][10]的存储地址是()。
【解答】1140【分析】数组A中每行共有6个元素,元素A[15][10]的前面共存储了(15-10)×6+5个元素,每个元素占4个存储单元,所以,其存储地址是1000+140=1140。
⑶设有一个10阶的对称矩阵A采用压缩存储,A[0][0]为第一个元素,其存储地址为d,每个元素占1个存储单元,则元素A[8][5]的存储地址为()。
【解答】d+41【分析】元素A[8][5]的前面共存储了(1+2+…+8)+5=41个元素。
⑷稀疏矩阵一般压缩存储方法有两种,分别是()和()。
【解答】三元组顺序表,十字链表⑸广义表((a), (((b),c)),(d))的长度是(),深度是(),表头是(),表尾是()。
【解答】3,4,(a),((((b),c)),(d))⑹已知广义表LS=(a,(b,c,d),e),用Head和Tail函数取出LS中原子b的运算是()。
【解答】Head(Head(Tail(LS)))2. 选择题⑴二维数组A的每个元素是由6个字符组成的串,行下标的范围从0~8,列下标的范围是从0~9,则存放A至少需要()个字节,A的第8列和第5行共占()个字节,若A按行优先方式存储,元素A[8][5]的起始地址与当A按列优先方式存储时的()元素的起始地址一致。
数据结构--栈和队列基础知识
数据结构--栈和队列基础知识⼀概述栈和队列,严格意义上来说,也属于线性表,因为它们也都⽤于存储逻辑关系为 "⼀对⼀" 的数据,但由于它们⽐较特殊,因此将其单独作为⼀篇⽂章,做重点讲解。
既然栈和队列都属于线性表,根据线性表分为顺序表和链表的特点,栈也可分为顺序栈和链表,队列也分为顺序队列和链队列,这些内容都会在本章做详细讲解。
使⽤栈结构存储数据,讲究“先进后出”,即最先进栈的数据,最后出栈;使⽤队列存储数据,讲究 "先进先出",即最先进队列的数据,也最先出队列。
⼆栈2.1 栈的基本概念同顺序表和链表⼀样,栈也是⽤来存储逻辑关系为 "⼀对⼀" 数据的线性存储结构,如下图所⽰。
从上图我们看到,栈存储结构与之前所了解的线性存储结构有所差异,这缘于栈对数据 "存" 和 "取" 的过程有特殊的要求:1. 栈只能从表的⼀端存取数据,另⼀端是封闭的;2. 在栈中,⽆论是存数据还是取数据,都必须遵循"先进后出"的原则,即最先进栈的元素最后出栈。
拿图 1 的栈来说,从图中数据的存储状态可判断出,元素 1 是最先进的栈。
因此,当需要从栈中取出元素 1 时,根据"先进后出"的原则,需提前将元素 3 和元素 2 从栈中取出,然后才能成功取出元素 1。
因此,我们可以给栈下⼀个定义,即栈是⼀种只能从表的⼀端存取数据且遵循 "先进后出" 原则的线性存储结构。
通常,栈的开⼝端被称为栈顶;相应地,封⼝端被称为栈底。
因此,栈顶元素指的就是距离栈顶最近的元素,拿下图中的栈顶元素为元素 4;同理,栈底元素指的是位于栈最底部的元素,下中的栈底元素为元素 1。
2.2 进栈和出栈基于栈结构的特点,在实际应⽤中,通常只会对栈执⾏以下两种操作:向栈中添加元素,此过程被称为"进栈"(⼊栈或压栈);从栈中提取出指定元素,此过程被称为"出栈"(或弹栈);2.3 栈的具体实现栈是⼀种 "特殊" 的线性存储结构,因此栈的具体实现有以下两种⽅式:1. 顺序栈:采⽤顺序存储结构可以模拟栈存储数据的特点,从⽽实现栈存储结构。
栈习题——精选推荐
栈习题⼀选择题1. 对于栈操作数据的原则是(b )。
A. 先进先出B. 后进先出C. 后进后出D. 不分顺序2. 在作进栈运算时,应先判别栈是否( ①b),在作退栈运算时应先判别栈是否( ②a )。
当栈中元素为n个,作进栈运算时发⽣上溢,则说明该栈的最⼤容量为( c③)。
为了增加内存空间的利⽤率和减少溢出的可能性,由两个栈共享⼀⽚连续的内存空间时,应将两栈的( ④d)分别设在这⽚内存空间的两端,这样,当( c⑤)时,才产⽣上溢。
①, ②: A. 空 B. 满 C. 上溢 D. 下溢③: A. n-1 B. n C. n+1 D. n/2④: A. 长度 B. 深度 C. 栈顶 D. 栈底⑤: A. 两个栈的栈顶同时到达栈空间的中⼼点.B. 其中⼀个栈的栈顶到达栈空间的中⼼点.C. 两个栈的栈顶在栈空间的某⼀位置相遇.D. 两个栈均不空,且⼀个栈的栈顶到达另⼀个栈的栈底.3. ⼀个栈的输⼊序列为123…n,若输出序列的第⼀个元素是n,输出第i(1<=i<=n)个元素是(b)。
A. 不确定B. n-i+1C. iD. n-i4. 若⼀个栈的输⼊序列为1,2,3,…,n,输出序列的第⼀个元素是i,则第j个输出元素是( d )。
A. i-j-1B. i-jC. j-i+1D. 不确定的5. 设栈的输⼊序列是1,2,3,4,则(d)不可能是其出栈序列。
A. 1,2,4,3,B. 2,1,3,4,C. 1,4,3,2,D. 4,3,1,2,E. 3,2,1,4,6. ⼀个栈的输⼊序列为1 2 3 4 5,则下列序列中不可能是栈的输出序列的是(b )。
A. 2 3 4 1 5C. 2 3 1 4 5D. 1 5 4 3 27. 设⼀个栈的输⼊序列是1,2,3,4,5,则下列序列中,是栈的合法输出序列的是( d )。
A. 5 1 2 3 4B. 4 5 1 3 2C. 4 3 1 2 5D. 3 2 1 5 48. 某堆栈的输⼊序列为a, b,c ,d,下⾯的四个序列中,不可能是它的输出序列的是(d )。
栈的基本操作
栈的基本操作栈是一种重要的数据结构,它在计算机科学中有着广泛的应用。
对于栈的基本操作,包括入栈(push)、出栈(pop)、获取栈顶元素,以及查看栈的大小(size)等操作。
1.入栈(push)入栈的操作就是往栈里压栈,把元素压入栈顶,以实现入栈操作。
在把元素压入栈时,栈的元素数量会增加1,压入元素的位置就是栈顶。
2.出栈(pop)出栈的操作是从栈顶弹出元素,以实现出栈操作。
当一个元素从栈顶弹出时,栈的大小就会减少1,弹出元素的位置就是栈顶。
3.获取栈顶元素要获取栈顶元素,我们需要从栈中取出元素,但是这并不会改变栈的大小。
由于栈的特性,我们可以通过取出栈顶的元素来获取它,而不需要从栈的其他位置获取。
4.查看栈的大小(size)查看栈的大小也就是查看栈中有多少元素。
要查看栈的大小,我们只要通过查看栈的长度即可,从而知道栈中有多少元素,从而了解栈的大小。
到此,我们对栈的基本操作基本有了一个概念,包括入栈(push)、出栈(pop)、获取栈顶元素以及查看栈的大小(size)。
栈的操作可以用入栈出栈的方式来表示,也可以用推入和弹出的方式来表示,它们都是栈的基本操作。
栈的操作跟其他的数据结构的操作有所不同,比如要存储数据的时候,需要先进行入栈操作,而当要取出数据的时候,需要先进行出栈操作,而不是像队列里面先进行出队操作,再进行入队操作。
栈也可以用来实现字符串操作、算数表达式求值、函数调用以及实现括号的匹配等等,这些都是栈的基本操作的应用。
总而言之,栈是一种重要的数据结构,其基本操作可以说是它的核心。
因此,学习栈的基本操作非常重要,只有掌握了它的基本操作,才可以正确的使用栈这种数据结构。
大学计算机基础电子教材-第4章
第4章 数据结构与算法本章介绍数据结构与算法,内容包括算法和数据结构的基本概念、栈及线性链表、树与二叉树、排序技术、查找技术。
●了解数据结构与算法的基本概念。
●了解栈与线性链表的操作。
●了解树与二叉树。
●了解数据结构中的排序技术和查找技术。
4.1 算法的概念4.1.1 算法的基本概念程序是算法用某种程序设计语言的具体实现。
算法(Algorithm)是指解题方案的准确而完整的描述,是一系列解决问题的清晰指令,算法代表着用系统的方法描述解决问题的策略机制。
也就是说,能够对一定规范的输入,在有限时间内获得所要求的输出。
如果一个算法有缺陷,或不适合于某个问题,执行这个算法将不会解决这个问题。
不同的算法可能用不同的时间、空间或效率来完成同样的任务。
一个算法的优劣可以用空间复杂度和时间复杂度来衡量。
算法中的指令描述的是一个计算,当其运行时能从一个初始状态和(可能为空的)初始输入开始,经过一系列有限而清晰定义的状态,最终产生输出并停止于一个终态。
一个状态到另一个状态的转移不一定是确定的。
随机化算法在内的一些算法包含了一些随机输入。
算法具有的一些重要特性:(1)有限性。
算法在执行有限步之后必须终止。
(2)确定性。
算法的每一个步骤都是有精确的定义的。
执行的每一步都是清晰的、无二义的。
大学计算机基础84(3)输入。
一个算法具有任意个输入,它是由外部提供的,作为算法执行前的初始状态。
(4)输出。
算法一定有输出结果。
(5)可行性。
算法中的运算都必须是可以实现的。
4.1.2 算法的复杂度1.时间复杂度算法的时间复杂度采用算法执行过程中其基本操作的执行次数,即计算量来度量。
算法中基本操作的执行次数一般是与问题的规模有关的,对于节点个数为n的数据处理问题,用T(n)表示算法基本操作的执行次数。
当比较不同算法的时间性能时,主要标准是看不同算法时间复杂度所处的数量级如何。
例如:以上算法中,循环体中的代码执行了n次,因此算法的时间复杂度为O(n)。
栈的面试题目(3篇)
第1篇第一部分:基本概念与操作1. 什么是栈?- 栈是一种线性数据结构,遵循后进先出(LIFO)的原则。
它只允许在栈顶进行插入(push)和删除(pop)操作。
2. 栈的基本操作有哪些?- 入栈(push):在栈顶添加一个新元素。
- 出栈(pop):移除栈顶元素。
- 查看栈顶元素(peek 或 top):获取栈顶元素但不移除它。
- 判断栈是否为空(isEmpty):检查栈中是否没有元素。
- 获取栈的大小(size):返回栈中元素的数量。
3. 请用Python实现一个栈的数据结构。
```pythonclass Stack:def __init__(self):self.items = []def is_empty(self):return len(self.items) == 0def push(self, item):self.items.append(item)def pop(self):if not self.is_empty():return self.items.pop()return Nonedef peek(self):if not self.is_empty():return self.items[-1]return Nonedef size(self):return len(self.items)```4. 如何实现一个固定大小的栈?- 在栈类中添加一个计数器来跟踪栈的大小,并在push操作中检查是否已达到最大容量。
5. 请解释栈的两种遍历方法。
- 递归遍历:使用递归方法遍历栈的所有元素。
- 迭代遍历:使用栈的辅助结构(如队列)来实现迭代遍历。
第二部分:栈的应用6. 栈在计算机科学中的应用有哪些?- 函数调用:局部变量和返回地址存储在栈中。
- 表达式求值:逆波兰表达式(RPN)计算。
- 字符串匹配:括号匹配验证。
- 汉诺塔问题:移动塔的步骤可以通过栈来模拟。
7. 请解释如何使用栈实现括号匹配验证。
数据结构栈练习题与答案
1、栈的“先进后出”特性是指()。
A.最后进栈的元素总是最先出栈B.同时进行进栈和出栈操作时,总是进栈优先C.每当有出栈操作时,总要先进行一次进栈操作D.每次出栈的元素总是最先进栈的元素正确答案:A2、给定一个足够大的空栈,有 4 个元素的进栈次序为 A、B、C、D,则以C、D开头的出栈序列的个数为()。
A.1B.2C.3D.4正确答案:A解析:若出栈序列为CD…,则A、B、C进栈,C出栈,D进栈,D出栈,此后只有B出栈和A出栈一种情况,所以这样的出栈序列只有 CDBA 一个。
3、若元素a、b、c、d、e、f依次进栈,允许进栈、退栈的操作交替进行,但不允许连续3次退栈工作,则不可能得到的出栈序列是()。
A.dcebfaB.cbdaefC.bcaefdD.afedcb正确答案:D 解析:选项A操作:a进,b进,c进,d进,d出,c出,e进,e 出,b出,f进,f出,a出。
选项B操作:a进,b进,c进,c出,b出,d进,d出,a出,e 进,e出,f进,f出。
选项C操作:a进,b进,b出,c进,c出,a出,d进,e进,e 出,f进,f出,d出。
选项D操作:a进,a出,b进,c进,d进,e进,f进,f出,e 出,d出,c出,b出。
从中看到,选项D中最后连续出栈5次,不符合要求。
4、一个栈的进栈序列是a、b、c、d、e,则栈的不可能的输出序列是()。
A.edcbaB.decbaC.dceabD.abcde正确答案:C解析:对于选项A,a、b、c、d、e进栈,e、d、c、b、a出栈;对于选项B,a,b,c,d进栈,d出栈,e进栈,e出栈,c、b、a 依次出栈;对于选项C,a、b、c、d进栈,d出栈,c出栈,e进栈,e出栈,此时栈中从栈底到栈顶为a、b,不可能a先出栈,所以C是不可能的输出序列;对于选项D,a进栈,a出栈,b进栈,b出栈,c进栈,c出栈,d 进栈,d出栈,e进栈,e出栈。
5、当用一个数组data[0..n-1]存放栈中元素时,栈底最好()。
数据结构 (严蔚敏C语言版) 学习、复习提纲
期末复习 第一章 绪论 复习1、计算机算法必须具备输入、输出、可行性、确定性、有穷性5个特性。
2、算法分析的两个主要方面是空间复杂度和时间复杂度。
3、数据元素是数据的基本单位。
4、数据项是数据的最小单位。
5、数据结构是带结构的数据元素的集合。
6、数据的存储结构包括顺序、链接、散列和索引四种基本类型。
数据结构算 法数据:计算机处理的信息总称数据项:最小单位 数据元素:最基本单位数据对象:元素集合数据结构:相互之间存在一种或多种特定关系的数据元素集合。
概念:数据元素之间的关系 线性结构:一对一非线性结构 树:一对多 图:多对多顺序存储结构 链表存储结构 索引。
散列。
算法描述:指令的有限有序序列有穷性 确定性 可行性 输入 输出 时间复杂度 空间复杂度第二章 线性表 复习1、在双链表中,每个结点有两个指针域,包括一个指向前驱结点的指针 、一个指向后继结点的指针2、线性表采用顺序存储,必须占用一片连续的存储单元3、线性表采用链式存储,便于进行插入和删除操作4、线性表采用顺序存储和链式存储优缺点比较。
5、简单算法第三章 栈和队列 复习定义逻辑关系:前趋 后继节省空间 随机存取 插、删效率低 插入 删除1、 栈和队列的异同点。
2、 栈和队列的基本运算3、 出栈和出队4、 基本运算第四章 串 复习存储结构栈的概念:在一端操作的线性表 运算算法栈的特点:先进后出 LIFO初始化 进栈push 出栈pop顺序队列 循环队列队列概念:在两端操作的线性表 假溢出链队列队列特点:先进先出 FIFO基本运算顺序:链队:队空:front=rear队满:front=(rear+1)%MAXSIZE队空:rear 初始化 判空 进队 出队取队首元素第五章 数组和广义表 复习定义:由n(≥1)个字符组成的有限序列 S=”c 1c 2c 3 ……cn ”串长度、空白串、空串。
紧缩格式 非紧缩格式以字节为单位的存储格式 (C 语言用数组或指针表示) 基本运算strlen(s) 串长度 strcat(s1,s2) 联接 strcmp(s1,s2) 比较 strcpy(s1,s2) 复制 strstr(s1,s2) 子串查询模式匹配失败链接值匹配算法单字符链表串 多字符链表串串变量的存储映像:串名、串值对应关系表顺序存储方式压缩存储方式行优先顺序存放列优先顺序存放C语言数组:行优先下标从[0]开始,公式变化稀疏矩阵应用表达式程序调用广义表定义:n(≥0)个元素的有限序列表头:Head(A)= a1概念:长度、深度、原子、子表表尾:Tail(A)=(a2,a3,…,a n)表结点特殊矩阵对称矩阵三角矩阵对角矩阵三元组存储:三元组m n t链表存储:十字链表原子结点第六章 树 复习1、三个结点可以组成2种不同形态的树。
名词解释栈
名词解释栈栈(stack)在计算机科学中是限定仅在表尾进行插入或删除操作的线形表。
栈是一种数据结构,它按照后进先出的原则存储数据,先进入的数据被压入栈底,最后的数据在栈顶,需要读数据的时候从栈顶开始弹出数据(最后一个数据被第一个读出来)。
栈是只能在某一端插入和删除的特殊线性表。
用桶堆积物品,先堆进来的压在底下,随后一件一件往堆。
取走时,只能从上面一件一件取。
堆和取都在顶部进行,底部一般是不动的。
栈就是一种类似桶堆积物品的数据结构,进行删除和插入的一端称栈顶,另一堆称栈底。
插入一般称为进栈(PUSH),删除则称为退栈(POP)。
栈也称为后进先出表(LIFO表)。
在程序中,堆用于动态分配和释放程序所使用的对象。
在以下情况中调用堆操作:1.事先不知道程序所需对象的数量和大小。
2.对象太大,不适合使用堆栈分配器。
堆使用运行期间分配给代码和堆栈以外的部分内存。
传统上,操作系统和运行时库随附了堆实现。
当进程开始时,操作系统创建称为进程堆的默认堆。
如果没有使用其他堆,则使用进程堆分配块。
语言运行时库也可在一个进程内创建单独的堆。
(例如,C运行时库创建自己的堆。
)除这些专用堆外,应用程序或许多加载的动态链接库(DLL)之一也可以创建并使用单独的堆。
Win32提供了一组丰富的API用于创建和使用专用堆。
有关堆函数的优秀教程,请参阅MSDN平台SDK节点。
当应用程序或DLL创建专用堆时,这些堆驻留于进程空间中并且在进程范围内是可访问的。
某一给定堆分配的任何数据应为同一堆所释放。
(从一个堆分配并释放给另一个堆没有意义。
)在所有虚拟内存系统中,堆位于操作系统的虚拟内存管理器之上。
语言运行时堆也驻留在虚拟内存之上。
某些情况下,这些堆在操作系统堆的上层,但语言运行时堆通过分配大的块来执行自己的内存管理。
绕开操作系统堆来使用虚拟内存函数可使堆更好地分配和使用块。
典型的堆实现由前端分配器和后端分配器组成。
前端分配器维护固定大小块的自由列表。
数据结构-栈
数据结构-栈⼀、栈1. 1. 为什么要学习栈?栈是什么?为什么要学习它?现在先来说说栈的辉煌作⽤吧!在计算机领域中,栈是⼀种不可忽略的概念,⽆论从它的结构上,还是存储数据⽅⾯,它对于学习数据结构的⼈们来说,都是⾮常重要的。
那么就会有⼈问,栈究竟有什么作⽤,让我们这么重视它?⾸先,栈具有⾮常强⼤的“记忆”功能,它可以保存对你有作⽤的数据,也可以被叫做保存现场;其次,当咱们调⽤⼀个带参函数时候,被调⽤的函数的形参,在编译器编译的时候,这些形参都需要⼀定的空间存放他们,这时计算机就会默认帮你保存到栈中了!1. 2. 栈的定义栈的作⽤,这是⼀个咱们⽣活中处处⽤到,但是却⼜没发现的⼀种现象,例如当你拿个篮⼦去买苹果,那么你最先挑选的苹果就是在篮⼦的最底下,最后挑选的苹果就在篮⼦的最上边,那么这就造成了这么⼀种现象:先拿进篮⼦的苹果,要最后才能取出来;相反,最后拿进篮⼦的苹果,就能最先取出来!栈是限定只能在表尾进⾏插⼊和删除的线性表。
我们把允许插⼊和删除的⼀端称作栈顶(Top),另⼀端称作栈底(bottom)。
不含任何数据元素的栈被称作空栈,栈也被称为先进后出的线性表(具有线性关系)。
⽽栈的特殊性,就是在表中想进⾏插⼊和删除的操作,只能在栈顶进⾏。
这也就使得了:栈底是⾮常稳定的,因为先进来的元素都被放在了栈底。
栈的插⼊操作:叫做进栈,也叫作压栈,⼊栈。
栈的删除操作:叫做出栈,也叫弹栈。
1. 3. 进栈出栈变化形式现在请⼤家思考这样的⼀个问题:最先进栈的元素,是不是只能最后才能出来呢?答案是不⼀定的,这个问题就要细分情况了。
栈对线性表的插⼊和删除的位置进⾏了限制,并没有对元素的进出时间进⾏限制,这也就是说,在不是所有元素都进栈的情况下,事先进去的元素也可以先出站,只要确保⼀点:栈元素是从栈顶出栈就可以了!举例来说,现在有3个整型数元素1、2、3依次进栈,会有哪些出栈次序呢?第⼀种:1、2、3依次进,再3、2、1依次出栈。
数据结构中栈的介绍
数据结构中栈的介绍1.栈的概念栈(Stack )是一种特殊的表,这种表只在表的一端进行插入和删除操作。
允许插入和 删除数据元素的这一端称为栈顶;而另一固定的一端称为栈底。
不含任何元素的栈称为空栈。
栈的修改是按后进先出的原则进行的。
栈又称为后进先出 (Last In First Out ) 表,简 称为LIFO 表。
如图1所示:假设一个栈 S 中的元素为a n ,a n-1,..,a 1,则称a 1为栈底元素,a n 为栈顶元由于栈是一个特殊的表,可以用一维数组来实现栈。
同时设立指针 来指示栈顶元素的当前位置。
我们用一个数组s[1..m]来表示一个栈时,将栈底固定在数组的底部,即s[1]为最早入 栈的元素,并让栈向数组上方 (下标增大的方向)扩展。
当t=0时,表示这个栈为一个空栈。
当t=m 时,表示这个栈已满。
可以用下列方式定义栈:con stm 我表目数的上限; typestack=array[1..m] of stype; { var s:stack;t:integer; { 栈顶指针}进栈、出栈操作的过程和函数(假设栈元素的数据类型为整型):(1)进栈过程(push )① 若t >m 时,则给出溢出信息,作出错处理(进栈前首先检查栈是否已满,满则溢 出;不满则作②);② 置t=t+1 (栈指针加1,指向进栈地址); ③ S (t )=x ,结束(x 为新进栈的元素);P rocedure p ush (var s:stack; x:i nteger;var t:i nteger ); begin if t=m the n write In ('overflow') else begint (称为栈顶指针)栈的数据类型}入ft2.栈的存储与操作图2t:=t+1;s[t]:=x; end end;⑵退栈函数(pop )① 若t < 0,则给出下溢信息,作出错处理(退栈前先检查是否已为空栈, 空则下溢;不空则作②);② x=s(t),(退栈后的元素赋给 x ); ③ t=t-1,结束(栈指针减1,指向栈顶)。
严蔚敏数据结构第四章答案
void String_Reverse(Stringtype s,Stringtype &r)//求s的逆串r{StrAssign(r,''); //初始化r为空串for(i=Strlen(s);i;i--){StrAssign(c,SubString(s,i,1));StrAssign(r,Concat(r,c)); //把s的字符从后往前添加到r中}}//String_Reverse4.11void String_Subtract(Stringtype s,Stringtype t,Stringtype &r)//求所有包含在串s中而t中没有的字符构成的新串r{StrAssign(r,'');for(i=1;i<=Strlen(s);i++){StrAssign(c,SubString(s,i,1));for(j=1;j<i&&StrCompare(c,SubString(s,j,1));j++); //判断s的当前字符c是否第一次出现if(i==j){for(k=1;k<=Strlen(t)&&StrCompare(c,SubString(t,k,1));k++); //判断当前字符是否包含在t中if(k>Strlen(t)) StrAssign(r,Concat(r,c));}}//for}//String_Subtract4.12int Replace(Stringtype &S,Stringtype T,Stringtype V);//将串S中所有子串T替换为V,并返回置换次数{for(n=0,i=1;i<=Strlen(S)-Strlen(T)+1;i++) //注意i的取值范围if(!StrCompare(SubString(S,i,Strlen(T)),T)) //找到了与T匹配的子串{ //分别把T的前面和后面部分保存为head和tailStrAssign(head,SubString(S,1,i-1));StrAssign(tail,SubString(S,i+Strlen(T),Strlen(S)-i-Strlen(T)+1));StrAssign(S,Concat(head,V));StrAssign(S,Concat(S,tail)); //把head,V,tail连接为新串i+=Strlen(V); //当前指针跳到插入串以后n++;}//ifreturn n;}//Replace分析:i+=Strlen(V);这一句是必需的,也是容易忽略的.如省掉这一句,则在某些情况下,会引起不希望的后果,虽然在大多数情况下没有影响.请思考:设S='place',T='ace', V='face',则省掉i+=Strlen(V);运行时会出现什么结果?4.13int Delete_SubString(Stringtype &s,Stringtype t)//从串s中删除所有与t相同的子串,并返回删除次数{for(n=0,i=1;i<=Strlen(s)-Strlen(t)+1;i++)if(!StrCompare(SubString(s,i,Strlen(t)),t)){StrAssign(head,SubString(S,1,i-1));StrAssign(tail,SubString(S,i+Strlen(t),Strlen(s)-i-Strlen(t)+1));StrAssign(S,Concat(head,tail)); //把head,tail连接为新串n++;}//ifreturn n,}//Delete_SubString4.14Status NiBoLan_to_BoLan(Stringtype str,Stringtype &new)//把前缀表达式str转换为后缀式new{Initstack(s); //s的元素为Stringtype类型for(i=1;i<=Strlen(str);i++){r=SubString(str,i,1);if(r为字母) push(s,r);else{if(StackEmpty(s)) return ERROR;pop(s,a);if(StackEmpty(s)) return ERROR;pop(s,b);StrAssign(t,Concat(r,b));StrAssign(c,Concat(t,a)); //把算符r,子前缀表达式a,b连接为新子前缀表达式c push(s,c);}}//forpop(s,new);if(!StackEmpty(s)) return ERROR;return OK;}//NiBoLan_to_BoLan分析:基本思想见书后注释3.23.请读者用此程序取代作者早些时候对3.23题给出的程序.4.15void StrAssign(Stringtype &T,char chars&#;)//用字符数组chars给串T赋值,Stringtype的定义见课本{for(i=0,T[0]=0;chars[i];T[0]++,i++) T[i+1]=chars[i];}//StrAssign4.16char StrCompare(Stringtype s,Stringtype t)//串的比较,s>t时返回正数,s=t时返回0,s<t时返回负数{for(i=1;i<=s[0]&&i<=t[0]&&s[i]==t[i];i++);if(i>s[0]&&i>t[0]) return 0;else if(i>s[0]) return -t[i];else if(i>t[0]) return s[i];else return s[i]-t[i];}//StrCompare4.17int String_Replace(Stringtype &S,Stringtype T,Stringtype V);//将串S中所有子串T 替换为V,并返回置换次数{for(n=0,i=1;i<=S[0]-T[0]+1;i++){for(j=i,k=1;T[k]&&S[j]==T[k];j++,k++);if(k>T[0]) //找到了与T匹配的子串:分三种情况处理{if(T[0]==V[0])for(l=1;l<=T[0];l++) //新子串长度与原子串相同时:直接替换S[i+l-1]=V[l];else if(T[0]<V[0]) //新子串长度大于原子串时:先将后部右移{for(l=S[0];l>=i+T[0];l--)S[l+V[0]-T[0]]=S[l];for(l=1;l<=V[0];l++)S[i+l-1]=V[l];}else //新子串长度小于原子串时:先将后部左移{for(l=i+V[0];l<=S[0]+V[0]-T[0];l++)S[l]=S[l-V[0]+T[0]];for(l=1;l<=V[0];l++)S[i+l-1]=V[l];}S[0]=S[0]-T[0]+V[0];i+=V[0];n++;}//if}//forreturn n;}//String_Replace4.18typedef struct {char ch;int num;} mytype;void StrAnalyze(Stringtype S)//统计串S中字符的种类和个数{mytype T[MAXSIZE]; //用结构数组T存储统计结果for(i=1;i<=S[0];i++){c=S[i];j=0;while(T[j].ch&&T[j].ch!=c) j++; //查找当前字符c是否已记录过if(T[j].ch) T[j].num++;else T[j]={c,1};}//forfor(j=0;T[j].ch;j++)printf("%c: %d\n",T[j].ch,T[j].num);}//StrAnalyze4.19void Subtract_String(Stringtype s,Stringtype t,Stringtype &r)//求所有包含在串s中而t中没有的字符构成的新串r{r[0]=0;for(i=1;i<=s[0];i++){c=s[i];for(j=1;j<i&&s[j]!=c;j++); //判断s的当前字符c是否第一次出现if(i==j){for(k=1;k<=t[0]&&t[k]!=c;k++); //判断当前字符是否包含在t中if(k>t[0]) r[++r[0]]=c;}}//for}//Subtract_String4.20int SubString_Delete(Stringtype &s,Stringtype t)//从串s中删除所有与t相同的子串,并返回删除次数{for(n=0,i=1;i<=s[0]-t[0]+1;i++){for(j=1;j<=t[0]&&s[i+j-1]==t[i];j++);if(j>m) //找到了与t匹配的子串{for(k=i;k<=s[0]-t[0];k++) s[k]=s[k+t[0]]; //左移删除s[0]-=t[0];n++;}}//forreturn n;}//Delete_SubString4.21typedef struct{char ch;LStrNode *next;} LStrNode,*LString; //链串结构void StringAssign(LString &s,LString t)//把串t赋值给串s{s=malloc(sizeof(LStrNode));for(q=s,p=t->next;p;p=p->next){r=(LStrNode*)malloc(sizeof(LStrNode));r->ch=p->ch;q->next=r;q=r;}q->next=NULL;}//StringAssignvoid StringCopy(LString &s,LString t)//把串t复制为串s.与前一个程序的区别在于,串s业已存在.{for(p=s->next,q=t->next;p&&q;p=p->next,q=q->next){p->ch=q->ch;pre=p;}while(q){p=(LStrNode*)malloc(sizeof(LStrNode));p->ch=q->ch;pre->next=p;pre=p;}p->next=NULL;}//StringCopychar StringCompare(LString s,LString t)//串的比较,s>t时返回正数,s=t时返回0,s<t 时返回负数{for(p=s->next,q=t->next;p&&q&&p->ch==q->ch;p=p->next,q=q->next);if(!p&&!q) return 0;else if(!p) return -(q->ch);else if(!q) return p->ch;else return p->ch-q->ch;}//StringCompareint StringLen(LString s)//求串s的长度(元素个数){for(i=0,p=s->next;p;p=p->next,i++);return i;}//StringLenLString * Concat(LString s,LString t)//连接串s和串t形成新串,并返回指针{p=malloc(sizeof(LStrNode));for(q=p,r=s->next;r;r=r->next){q->next=(LStrNode*)malloc(sizeof(LStrNode));q=q->next;q->ch=r->ch;}//for //复制串sfor(r=t->next;r;r=r->next){q->next=(LStrNode*)malloc(sizeof(LStrNode));q=q->next;q->ch=r->ch;}//for //复制串tq->next=NULL;return p;}//ConcatLString * Sub_String(LString s,int start,int len)//返回一个串,其值等于串s从start 位置起长为len的子串{p=malloc(sizeof(LStrNode));q=p;for(r=s;start;start--,r=r->next); //找到start所对应的结点指针rfor(i=1;i<=len;i++,r=r->next){q->next=(LStrNode*)malloc(sizeof(LStrNode));q=q->next;q->ch=r->ch;} //复制串tq->next=NULL;return p;}//Sub_String4.22void LString_Concat(LString &t,LString &s,char c)//用块链存储结构,把串s插入到串t的字符c之后{p=t.head;while(p&&!(i=Find_Char(p,c))) p=p->next; //查找字符cif(!p) //没找到{t.tail->next=s.head;t.tail=s.tail; //把s连接在t的后面}else{q=p->next;r=(Chunk*)malloc(sizeof(Chunk)); //将包含字符c的节点p分裂为两个for(j=0;j<i;j++) r->ch[j]='#'; //原结点p包含c及其以前的部分for(j=i;j<CHUNKSIZE;j++) //新结点r包含c以后的部分{r->ch[j]=p->ch[j];p->ch[j]='#'; //p的后半部分和r的前半部分的字符改为无效字符'#'}p->next=s.head;s.tail->next=r;r->next=q; //把串s插入到结点p和r之间}//elset.curlen+=s.curlen; //修改串长s.curlen=0;}//LString_Concatint Find_Char(Chunk *p,char c)//在某个块中查找字符c,如找到则返回位置是第几个字符,如没找到则返回0{for(i=0;i<CHUNKSIZE&&p->ch[i]!=c;i++);if(i==CHUNKSIZE) return 0;else return i+1;}//Find_Char4.23int LString_Palindrome(LString L)//判断以块链结构存储的串L是否为回文序列,是则返回1,否则返回0{InitStack(S);p=S.head;i=0;k=1; //i指示元素在块中的下标,k指示元素在整个序列中的序号(从1开始)for(k=1;k<=S.curlen;k++){if(k<=S.curlen/2) Push(S,p->ch[i]); //将前半段的字符入串else if(k>(S.curlen+1)/2){Pop(S,c); //将后半段的字符与栈中的元素相匹配if(p->ch[i]!=c) return 0; //失配}if(++i==CHUNKSIZE) //转到下一个元素,当为块中最后一个元素时,转到下一块{p=p->next;i=0;}}//forreturn 1; //成功匹配}//LString_Palindrome4.24void HString_Concat(HString s1,HString s2,HString &t)//将堆结构表示的串s1和s2连接为新串t{if(t.ch) free(t.ch);t.ch=malloc((s1.length+s2.length)*sizeof(char));for(i=1;i<=s1.length;i++) t.ch[i-1]=s1.ch[i-1];for(j=1;j<=s2.length;j++,i++) t.ch[i-1]=s2.ch[j-1];t.length=s1.length+s2.length;}//HString_Concat4.25int HString_Replace(HString &S,HString T,HString V)//堆结构串上的置换操作,返回置换次数{for(n=0,i=0;i<=S.length-T.length;i++){for(j=i,k=0;k<T.length&&S.ch[j]==T.ch[k];j++,k++);if(k==T.length) //找到了与T匹配的子串:分三种情况处理{if(T.length==V.length)for(l=1;l<=T.length;l++) //新子串长度与原子串相同时:直接替换S.ch[i+l-1]=V.ch[l-1];else if(T.length<V.length) //新子串长度大于原子串时:先将后部右移{for(l=S.length-1;l>=i+T.length;l--)S.ch[l+V.length-T.length]=S.ch[l];for(l=0;l<V.length;l++)S[i+l]=V[l];}else //新子串长度小于原子串时:先将后部左移{for(l=i+V.length;l<S.length+V.length-T.length;l++)S.ch[l]=S.ch[l-V.length+T.length];for(l=0;l<V.length;l++)S[i+l]=V[l];}S.length+=V.length-T.length;i+=V.length;n++;}//if}//forreturn n;}//HString_Replace4.26Status HString_Insert(HString &S,int pos,HString T)//把T插入堆结构表示的串S的第pos个字符之前{if(pos<1) return ERROR;if(pos>S.length) pos=S.length+1;//当插入位置大于串长时,看作添加在串尾S.ch=realloc(S.ch,(S.length+T.length)*sizeof(char));for(i=S.length-1;i>=pos-1;i--)S.ch[i+T.length]=S.ch[i]; //后移为插入字符串让出位置for(i=0;i<T.length;i++)S.ch[pos+i-1]=T.ch[pos]; //插入串TS.length+=T.length;return OK;}//HString_Insert4.27int Index_New(Stringtype s,Stringtype t)//改进的定位算法{i=1;j=1;while(i<=s[0]&&j<=t[0]){if((j!=1&&s[i]==t[j])||(j==1&&s[i]==t[j]&&s[i+t[0]-1]==t[t[0]])){ //当j==1即匹配模式串的第一个字符时,需同时匹配其最后一个i=i+j-2;j=1;}else{i++;j++;}}//whileif(j>t[0]) return i-t[0];}//Index_New4.28void LGet_next(LString &T)//链串上的get_next算法{p=T->succ;p->next=T;q=T;while(p->succ){if(q==T||p->data==q->data){p=p->succ;q=q->succ;p->next=q;}else q=q->next;}//while}//LGet_next4.29LStrNode * LIndex_KMP(LString S,LString T,LStrNode *pos)//链串上的KMP匹配算法,返回值为匹配的子串首指针{p=pos;q=T->succ;while(p&&q){if(q==T||p->chdata==q->chdata){p=p->succ;q=q->succ;}else q=q->next;}//whileif(!q){for(i=1;i<=Strlen(T);i++)p=p->next;return p;} //发现匹配后,要往回找子串的头return NULL;}//LIndex_KMP4.30void Get_LRepSub(Stringtype S)//求S的最长重复子串的位置和长度{for(maxlen=0,i=1;i<S[0];i++)//串S2向右移i格{for(k=0,j=1;j<=S[0]-i;j++)//j为串S2的当前指针,此时串S1的当前指针为i+j,两指针同步移动{if(S[j]==S[j+i]) k++; //用k记录连续相同的字符数else k=0; //失配时k归零if(k>maxlen) //发现了比以前发现的更长的重复子串{lrs1=j-k+1;lrs2=mrs1+i;maxlen=k; //作记录}}//for}//forif(maxlen){printf("Longest Repeating Substring length:%d\n",maxlen);printf("Position1:%d Position 2:%d\n",lrs1,lrs2);}else printf("No Repeating Substring found!\n");}//Get_LRepSub分析:i代表"错位值".本算法的思想是,依次把串S的一个副本S2向右错位平移1格,2格,3格,...与自身S1相匹配,如果存在最长重复子串,则必然能在此过程中被发现.用变量lrs1,lrs2,maxlen来记录已发现的最长重复子串第一次出现位置,第二次出现位置和长度.题目中未说明"重复子串"是否允许有重叠部分,本算法假定允许.如不允许,只需在第二个for语句的循环条件中加上k<=i即可.本算法时间复杂度为O(Strlen(S)^2).4.31void Get_LPubSub(Stringtype S,Stringtype T)//求串S和串T的最长公共子串位置和长度{if(S[0]>=T[0]){StrAssign(A,S);StrAssign(B,T);}else{StrAssign(A,T);StrAssign(B,S);} //为简化设计,令S和T中较长的那个为A,较短的那个为Bfor(maxlen=0,i=1-B[0];i<A[0];i++){if(i<0) //i为B相对于A的错位值,向左为负,左端对齐为0,向右为正{jmin=1;jmax=i+B[0];}//B有一部分在A左端的左边else if(i>A[0]-B[0]){jmin=i;jmax=A[0];}//B有一部分在A右端的右边else{jmin=i;jmax=i+B[0];}//B在A左右两端之间.//以上是根据A和B不同的相对位置确定A上需要匹配的区间(与B重合的区间)的端点:jmin,jmax.for(k=0,j=jmin;j<=jmax;j++){if(A[j]==B[j-i]) k++;else k=0;if(k>maxlen){lps1=j-k+1;lps2=j-i-k+1;maxlen=k; }}//for}//forif(maxlen){if(S[0]>=T[0]){。
C语言数据结构之栈的基本操作
C语言数据结构之栈的基本操作栈是一种特殊的数据结构,它按照后进先出(LIFO)的原则进行操作。
栈可以用数组或链表来实现,下面将介绍栈的基本操作。
1.初始化栈:栈的初始化就是为栈分配内存空间,并将栈顶指针设置为-1(如果是数组实现)或者NULL(如果是链表实现)。
2.判断栈空:栈空表示栈中没有任何元素。
如果栈顶指针等于-1或者NULL,则表示栈空。
3.判断栈满:栈满表示栈中已经存满了元素。
如果栈顶指针等于栈的最大容量减1,则表示栈满。
4. 进栈(push):进栈操作就是将元素放入栈中。
如果栈不满,则将栈顶指针加1,并将元素放入栈顶位置。
5. 出栈(pop):出栈操作就是从栈中取出一个元素。
如果栈不空,则将栈顶指针减1,并返回栈顶元素。
6. 获取栈顶元素(getTop):获取栈顶元素操作不改变栈的状态,只返回栈顶元素的值。
如果栈不空,则返回栈顶元素值;否则,返回空值。
7.清空栈:清空栈操作就是将栈中的所有元素全部出栈,即将栈顶指针设置为-1或者NULL。
8.销毁栈:销毁栈操作是释放栈的内存空间,将栈的指针设置为NULL。
栈的应用:栈在计算机领域有广泛的应用,其中一个常见的应用是函数调用栈。
当一个函数调用另一个函数时,当前函数的状态(包括局部变量、返回地址等)会被压入到栈中。
当被调用函数执行完成后,栈顶的元素会被弹出,然后继续执行调用该函数的代码。
另一个常见的应用是表达式求值。
在表达式求值过程中,需要用到运算符优先级。
我们可以利用栈来处理运算符的优先级。
将运算符入栈时,可以先与栈顶运算符比较优先级,如果栈顶运算符的优先级高于当前运算符,则将栈顶运算符出栈,并继续比较。
这样可以确保栈中的运算符按照优先级从高到低的顺序排列。
此外,栈还可以用于处理括号匹配问题。
当遇到左括号时,将其入栈;当遇到右括号时,判断栈顶元素是否为对应的左括号,如果是,则将栈顶元素弹出,否则表示括号不匹配。
如果最后栈为空,则表示所有括号都匹配。
栈(C语言版)
本章主要介绍下列内容 栈的概念、存储结构及其基本操作 队列的概念、存储结构及其基本操作 栈与队列的应用举例
本章目录
1
2 3
3.1 栈
3.2 队列 3.3 栈和队列的应用举例 3.4 本章小结
4
结束
3.1 栈
3.1.1 栈的概念 3.1.2 栈的基本操作 3.1.3 顺序栈
3.1.4 链栈
返回到总目录
3.1.1 栈的概念
例如,在建筑工地上,使用的砖块从底往上一层一 层地码放,在使用时,将从最上面一层一层地拿取, 这种后进先出的线性结构称为栈(stack),栈又 称为后进先出(last in first out)的线性表,简 称LIFO表。 栈是一种特殊的线性表。其特殊性在于限定插入和 删除数据元素的操作只能在线性表的一端进行。插 入元素又称为进栈,删除元素又称为出栈。允许进 行插入和删除操作的一端称为栈顶(top),另一 端称为栈底(bottom)。处于栈顶位置的数据元 素称为栈顶元素,处于栈底位置的数据元素称为栈 底元素。不含任何数据元素的栈称为空栈。
3.1.3顺序栈
3. 顺序栈的基本操作实现
上述算法顺序栈的基本操作函数,可以对照执行主函数调用后的结果分析, 进一步了解顺序栈的各种操作的过程实现。 (7)设计主函数如下: main() { SeqStack S; DataType x; InitStack(&S); printf("依次进栈元素为:\n"); printf("r元素进栈\n"); Push(&S,'r'); printf("a元素进栈\n"); Push(&S,'a'); printf("h元素进栈\n"); Push(&S,'h'); 返回到本节目录
实用数据结构基础(第四版)课后习题
一、判断题(第一章绪论)1、数据元素就是数据得最小单元。
答案:错误2.一个数据结构就是由一个逻辑结构与这个逻辑结构上得基本运算集构成得整体。
答案:错误3.数据得存储结构就是数据元素之间得逻辑关系与逻辑结构在计算机存储器内得映像。
答案:正确4.数据得逻辑结构就是描述元素之间得逻辑关系,它就是依赖于计算机得。
答案:错误5、用语句频度来表示算法得时间复杂度得最大好处就是可以独立于计算机得软硬件,分析算法得时间答案:正确(第二章线性表)6、取顺序存储线性表得第i个元素得时间同i得大小有关。
答案:错误7、线性表链式存储得特点就是可以用一组任意得存储单元存储表中得数据元素。
答案:正确8、线性链表得每一个节点都恰好包含一个指针域。
答案:错误9、顺序存储方式得优点得存储密度大,插入与删除效率不如练市存储方式好。
答案:正确10、插入与删除操作就是数据结构中最基本得两种操作,所以这两种操作在数组中也经常使用。
答案:错误(第三章栈)11、栈就是一种对进栈与出栈作了限制得线性表。
答案:错误12、在C(或C++)语言中设顺序栈得长度为MAXLEN,则top=MAXLEN表示栈满。
答案:错误13、链栈与顺序栈相比,其特点之一就是通常不会出现满栈得情况。
答案:正确14、空栈就就是所有元素都为0上得栈。
答案:错误15、将十进制数转换为二进制数就是栈得典型应用之一。
答案:正确(第四章队列)16、队列式限制在两端进行操作得线性表。
答案:正确17、判断顺序队列为空得标准就是头指针与尾指针都指向同一结点。
答案:错误18、在循环链列队中无溢出现像。
答案:错误19、在循环队列中,若尾指针rear大于头指针front,则元素个数为rear-front。
答案:正确20、顺序队列与循环队列关于队满与队空得判断条件就是一样得。
答案:错误(第五章串)21、串就是n个字母得有限序列。
答案:错误22、串得堆分配存储就是一种动态存储结构。
答案:正确23、串得长度就是指串中不同字符得个数。
数据结构复习资料 第4章
第4章栈和队列一、复习要点本章主要讨论3种线性结构:栈、队列与优先级队列。
这3种结构都是顺序存取的表,而且都是限制存取点的表。
栈限定只能在表的一端(栈顶)插入与删除,其特点是先进后出。
队列和优先级队列限定只能在表的一端(队尾)插入在另一端(队头)删除,不过优先级队列在插入和删除时需要根据数据对象的优先级做适当的调整,令优先级最高的对象调整到队头,其特点是优先级高的先出。
而队列不调整,其特点是先进先出。
这几种结构在开发各种软件时非常有用。
本章复习的要点:1、基本知识点要求理解栈的定义和特点,栈的抽象数据类型和在递归和表达式计算中的使用,在栈式铁路调车线上当进栈序列为1, 2, 3, , n时,可能的出栈序列计数,栈的顺序存储表示和链接存储表示,特别要注意,链式栈的栈顶应在链头,插入与删除都在链头进行。
另外,需要理解队列的定义和特点,队列的抽象数据类型和在分层处理中的使用,队列的顺序存储表示(循环队列)和链接存储表示,需要注意的是,链式队列的队头应在链头,队尾应在链尾。
还需要理解优先级队列的定义和特点。
优先级队列的最佳存储表示是堆(heap),本章介绍的表示看懂即可。
2、算法设计➢栈的5种操作(进栈、退栈、取栈顶元素、判栈空、置空栈)的在顺序存储表示下的实现,以及在链接存储表示下的实现。
➢使用栈的后缀表达式计算算法➢循环队列的进队列、出队列、取队头元素、判队列空、置空队列操作的实现➢链式队列的进队列、出队列、取队头元素、判队列空、置空队列操作的实现二、难点和重点1、栈:栈的特性、栈的基本运算➢栈的数组实现、栈的链表实现➢栈满及栈空条件、抽象数据类型中的先决条件与后置条件2、栈的应用:用后缀表示计算表达式,中缀表示改后缀表示3、队列:队列的特性、队列的基本运算➢队列的数组实现:循环队列中队头与队尾指针的表示,队满及队空条件➢队列的链表实现:链式队列中的队头与队尾指针的表示、三、习题的解析4-2 铁路进行列车调度时, 常把站台设计成栈式结构的站台,如右图所示。
算法与数据结构C语言版课后习题答案(机械工业出版社)第3,4章习题参考答案
算法与数据结构C语⾔版课后习题答案(机械⼯业出版社)第3,4章习题参考答案第3章栈和队列⼀、基础知识题3.1有五个数依次进栈:1,2,3,4,5。
在各种出栈的序列中,以3,4先出的序列有哪⼏个。
(3在4之前出栈)。
【解答】34215 ,34251,345213.2铁路进⾏列车调度时,常把站台设计成栈式结构,若进站的六辆列车顺序为:1,2,3,4,5,6,那么是否能够得到435612, 325641, 154623和135426的出站序列,如果不能,说明为什么不能;如果能,说明如何得到(即写出"进栈"或"出栈"的序列)。
【解答】输⼊序列为123456,不能得出435612和154623。
不能得到435612的理由是,输出序列最后两元素是12,前⾯4个元素(4356)得到后,栈中元素剩12,且2在栈顶,不可能让栈底元素1在栈顶元素2之前出栈。
不能得到154623的理由类似,当栈中元素只剩23,且3在栈顶,2不可能先于3出栈。
得到325641的过程如下:1 2 3顺序⼊栈,32出栈,得到部分输出序列32;然后45⼊栈,5出栈,部分输出序列变为325;接着6⼊栈并退栈,部分输出序列变为3256;最后41退栈,得最终结果325641。
得到135426的过程如下:1⼊栈并出栈,得到部分输出序列1;然后2和3⼊栈,3出栈,部分输出序列变为13;接着4和5⼊栈,5,4和2依次出栈,部分输出序列变为13542;最后6⼊栈并退栈,得最终结果135426。
3.3若⽤⼀个⼤⼩为6的数组来实现循环队列,且当前rear和front的值分别为0和3,当从队列中删除⼀个元素,再加⼊两个元素后,rear和front的值分别为多少?【解答】2和43.4设栈S和队列Q的初始状态为空,元素e1,e2,e3,e4,e5和e6依次通过栈S,⼀个元素出栈后即进队列Q,若6个元素出队的序列是e3,e5,e4,e6,e2,e1,则栈S的容量⾄少应该是多少?【解答】43.5循环队列的优点是什么,如何判断“空”和“满”。
数据结构(第4版)习题及实验参考答案 数据结构复习资料完整版(c语言版)
数据结构基础及深入及考试复习资料习题及实验参考答案见附录结论1、数据的逻辑结构是指数据元素之间的逻辑关系。
即从逻辑关系上描述数据,它与数据的存储无关,是独立于计算机的。
2、数据的物理结构亦称存储结构,是数据的逻辑结构在计算机存储器内的表示(或映像)。
它依赖于计算机。
存储结构可分为4大类:顺序、链式、索引、散列3、抽象数据类型:由用户定义,用以表示应用问题的数据模型。
它由基本的数据类型构成,并包括一组相关的服务(或称操作)。
它与数据类型实质上是一个概念,但其特征是使用与实现分离,实行封装和信息隐蔽(独立于计算机)。
4、算法:是对特定问题求解步骤的一种描述,它是指令的有限序列,是一系列输入转换为输出的计算步骤。
5、在数据结构中,从逻辑上可以把数据结构分成( C )A、动态结构和表态结构B、紧凑结构和非紧凑结构C、线性结构和非线性结构D、内部结构和外部结构6、算法的时间复杂度取决于( A )A、问题的规模B、待处理数据的初态C、问题的规模和待处理数据的初态线性表1、线性表的存储结构包括顺序存储结构和链式存储结构两种。
2、表长为n的顺序存储的线性表,当在任何位置上插入或删除一个元素的概率相等时,插入一个元素所需移动元素的平均次数为( E ),删除一个元素需要移动的元素的个数为( A )。
A、(n-1)/2B、nC、n+1D、n-1E、n/2F、(n+1)/2G、(n-2)/23、“线性表的逻辑顺序与存储顺序总是一致的。
”这个结论是( B )A、正确的B、错误的C、不一定,与具体的结构有关4、线性表采用链式存储结构时,要求内存中可用存储单元的地址( D )A、必须是连续的B、部分地址必须是连续的C一定是不连续的D连续或不连续都可以5、带头结点的单链表为空的判定条件是( B )A、head==NULLB、head->next==NULLC、head->next=headD、head!=NULL6、不带头结点的单链表head为空的判定条件是( A )A、head==NULLB、head->next==NULLC、head->next=headD、head!=NULL7、非空的循环单链表head的尾结点P满足( C )A、p->next==NULLB、p==NULLC、p->next==headD、p==head8、在一个具有n个结点的有序单链表中插入一个新结点并仍然有序的时间复杂度是(B )A、O(1)B、O(n)C、O(n2)D、O(nlog2n)9、在一个单链表中,若删除p所指结点的后继结点,则执行( A )A、p->next=p->next->next;B、p=p->next;p->next=p->next->next;C、p->next=p->next;D、p= p->next->next;10、在一个单链表中,若在p所指结点之后插入s所指结点,则执行( B )A、s->next=p;p->next=s;B、s->next=p->next;p->next=s;C、s->next=p->next;p=s;D、p->next=s;s->next=p;11、在一个单链表中,已知q是p的前趋结点,若在q和p之间插入结点s,则执行(C )A、s->next=p->next;p->next=s;B、p->next=s->next;s->next=p;C、q->next=s;s->next=p;D、p->next=s;s->next=q;12、在线性结构中,第一个结点没有前趋结点,其余每个结点有且只有 1 个前趋结点。
数据结构知识点归纳
一、数据结构的章节结构及重点构成数据结构学科的章节划分基本上为:概论,线性表,栈和队列,串,多维数组和广义表,树和二叉树,图,查找,内排,外排,文件,动态存储分配。
对于绝大多数的学校而言,“外排,文件,动态存储分配”三章基本上是不考的,在大多数高校的计算机本科教学过程中,这三章也是基本上不作讲授的。
数据结构的章节比重大致为:1.概论:概念,时间复杂度。
2.线性表:基础章节,必考内容之一。
概念,算法设计题。
3.栈和队列:基本概念。
4.串:基本概念。
5.多维数组及广义表: 基本概念。
6.树和二叉树:重点难点章节,各校必考章节。
概念,问答,算法设计题。
7.图:重点难点章节,各校必考章节。
概念,问答,算法设计题。
8.查找:重点难点章节,概念,问答。
9.排序:重点难点章节,问答各种排序算法的排序过程二、各章节的主要内容:第一章概述主要内容:本章主要起到总领作用,为读者进行数据结构的学习进行了一些先期铺垫。
大家主要注意以下几点: (1)数据结构的基本概念。
(数据;数据元素;数据项;数据结构;数据的逻辑结构:线性和非线性,具体分为集合、线性结构、树形结构和图状结构;数据的存储结构:顺序存储和链式存储;运算)(2)算法的度量:时间效率和空间效率,分别用时间复杂度和空间复杂度度量,掌握时间复杂度的度量方法量方法。
(大O表示法)参考题目:填空题:1、数据结构是相互之间存在一种或多种特定关系的数据元素的集合,它包括三方面的内容,分别是数据的逻辑结构、()和()。
2、数据结构按逻辑结构可分为两大类,它们分别是()和()3. 数据的物理结构主要包括()和()两种情况。
4.线性表,栈,队列和二叉树四种数据结构中()是非线性结构,()是线性结构。
5、线性结构中元素之间存在()关系,树形结构中元素之间存在()关系,图形结构中元素之间存在()关系。
6、程序段的时间复杂度是_______。
for(i=1;i<=n;i++){ k++;for(j=1;j<=n;j++)x=x+k;}7.下列算法的时间复杂度是_____。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
4.5.2
括号配对
假设表达式中允许包含三种类型的括号:花括号‘{}’ 、方括号‘[]’和圆括号'()'。其嵌套的顺序任意,即([]{})和 [{()[]}]均为正确的格式,[(])、[()}和(()}]均为不正确的格式 。
{ [ ( ) ( ) ] } 1 2 3 4 5 6 7 8
4.5.3
行编辑程序
4.4.2
栈的基本运算
(7)销毁链栈操作。 void DestroyStack(LinkStack top) { LStackNode *p,*q; p=top; while(!p) { q=p; p=p->next; free(q); } }
4.4.3
链栈的应用
下面通过一个实例说明链栈基本算法的应用。 例4_3 利用链栈的基本运算,通过输入将字符进栈, 然后输出其出栈序列。
4.2.3
共享栈的问题
(3)出栈操作。 int PopStack(SSeqStack *S,DataType *e,int flag) { switch(flag) { case 0: if(S->top[0]==0) return 0; S->top[0]--; *e=S->stack[S->top[0]]; break; case 1: if(S->top[1]==StackSize-1) return 0; S->top[1]++; *e=S->stack[S->top[1]]; break; default: return 0; } return 1; }
4.2.2
顺序栈的基本运算
(5)出栈操作。 int PopStack(SeqStack *S,DataType *e) { if(S->top==0) { printf(“栈已经没有元素,不能出栈!\n”); return 0; } else { S->top--; *e=S->stack[S->top]; return 1; } }
4.4
栈的链式表示与实现
在顺序栈中,由于顺序存储结构需要事先静态分配, 而存储规模往往又难以确定,如果栈空间分配过小,可能会 造成溢出;如果栈空间分配过大,又造成存储空间浪费。因 此,为了克服顺序存储的缺点,采用链式存储结构表示栈。 本节主要学习内容包括栈的存储结构及链栈的基本运算。
4.4.1
栈的存储结构
4.2
栈的顺序表示与实现
与线性表一样,栈也有两种存储表示:顺序存储和链 式存储。本节的主要学习内容包括栈的顺序存储结构及顺序 存储结构下的操作实现。
4.2.1
栈的顺序存储结构
采用顺序存储结构的栈称为顺序栈。顺序栈利用一组 连续的存储单元存放栈中的元素,存放顺序依次从栈底到栈 顶。由于栈中元素之间的存放地址的连续性,在C语言中, 同样采用数组实现栈的顺序存储。
#define StackSize 100 typedef struct { DataType stack[StackSize]; int top; }SeqStack;
4.2.2
顺序栈的基本运算
在顺序存储结构中,栈的基本运算如下。以下算法的 实现保存在文件“SeqStack.h”中。 (1)栈的初始化操作。 void InitStack(SeqStack *S) /*将栈初始化为空栈只需要把栈顶指针top置为0*/ { S->top=0; /*把栈顶指针置为0*/ }
4.2.2
顺序栈的基本运算
(4)进栈操作。 int PushStack(SeqStack *S,DataType e) { if(S->top>=StackSize) { printf(“栈已满,不能进栈!\n”); return 0; } else { S->stack[S->top]=e; S->top++; return 1; } }
栈的应用非常广泛,经常会出现一个程序需要同时使 用多个栈的情况。使用顺序栈会因为栈空间的大小难以准确 估计,从而造成有的栈溢出,有的栈空间还有空闲。为了解 决这个问题,可以让多个栈共享一个足够大的连续存储空间 ,通过利用栈的动态特性使多个栈存储空间能够互相补充, 存储空间得到有效利用,这就是栈的共享 .
top top top top top top 空栈 A 插入元素A后 B A 插入元素 A,B后 C B A 插入元素 A,B,C后 D C B A 插入元素 A,B,C,D后 E D C B A 插入元素 A,B,C,D,E后 top D C B A 删除元素E后
4.1.2
栈的抽象数据类型
1.数据对象集合 2.基本操作集合
4.2.2
顺序栈的基本运算
(2)判断栈是否为空。 int StackEmpty(SeqStack S) /*判断栈是否为空,栈为空返回1,否则返回0*/ { if(S.top==0) /*判断栈顶指针top是否为0*/ return 1; /*当栈为空时,返回1;否则返回0*/ else return 0; }
4.3
栈的应用举例
上一节已经学习了栈的顺序存储结构及栈的实现。本 节通过实例来学习栈的基本操作的用法。 例4_1 将元素a、b、c、d、e依次进栈,然后将d和e 出栈,再将f和g进栈,最后将元素全部出栈,并将元素按照 出栈次序输出。
4.3
栈的应用举例
例4_2 设有两个栈S1和S2都采用顺序栈的方式存储, 并且共享一个存储区。为了尽可能利用存储空间,减少溢出 的可能,采用栈顶相向,迎面增长的方式,试设计S1和S2 有关入栈和出栈算法。
4.2.2
顺序栈的基本运算
(6)返回栈的长度操作。 int StackLength(SeqStack S) { return S.top; }
4.2.2
顺序栈的基本运算
(7)清空栈的操作。 void ClearStack(SeqStack *S) { S->top=0; }
4.2.3
共享栈的问题
a1 a2
...
ai
„
an
/\
②top->next=p e p
①p->next=top->next
4.4.2
栈的基本运算
(4)出栈操作。 int PopStack(LinkStack top,DataType *e) { LStackNode *p; p=top->next; p top if(!p) a1 a2 „ { printf(“栈已空”); return 0; } top->next=p->next; *e=p->data; free(p); return 1; }
4.1.1
栈的定义
栈,也称为堆栈,它是一种特殊的线性表,只允许在 表的一端进行插入和删除操作。栈顶是动态变化的,它由一 个称为栈顶指针(top)的变量指示。当表中没有元素时, 称为空栈。 栈的插入操作称为入栈或进栈,删除操作称为出栈或 退栈。 出栈 进栈
栈顶top
an
„
栈底
a2 a1
4.1.1
栈的定义
4.2.2
顺序栈的基本运算
(3)取栈顶元素操作。 int GetTop(SeqStack S, DataType *e) { if(S.top<=0) /*在取栈顶元素之前,判断栈是否为空*/ { printf(“栈已经空!\n”); return 0; } else { *e=S.stack[S.top-1];/*在取栈顶元素*/ return 1; } }
0 a b c d e 可用空间 p q StackSize-1 r s
top[0]=5 top[1]=StackSize-5
4.2.3
共享栈的问题
两个共享栈的数据结构类型定义 typedef struct { DataType stack[StackSize]; int top[2]; }SSeqStack;
4.2.3
共享栈的问题
(1)初始化操作。 void InitStack(SSeqStack *S) { S->top[0]=0; S->top[1]=StackSize-1; }
4.2.3
共享栈的问题
(2)进栈操作。 int PushStack(SSeqStack *S,DataType e,int flag) { if(S->top[0]==S->top[1]) return 0; switch(flag) { case 0: S->stack[S->top[0]]=e; S->top[0]++; break; case 1: S->stack[S->top[1]]=e; S->top[1]--; break; default: return 0; } return 1; }
top d c b a /\
4.4.2
栈的基本运算
链栈的基本运算包括链栈的初始化、进栈、出栈、取 栈顶元素等。带头结点的链栈的基本运算具体实现如下。
4.4.2
栈的基本运算
(1)链栈的初始化操作。 void InitStack(LinkStack *top) { if((*top=(LinkStack)malloc(sizeof(LStackNode))) ==NULL) exit(-1); (*top)->next=NULL; }
一个简单的行编辑程序的功能是:将用户输入的字符 序列存入数据区,由于用户进行输入时,有可能会出现错误 。因此,如果在编辑程序中,每接受一个字符,即存入数据 区的做法显然是不合适的。一个比较好的做法是,设立一个 输入缓冲区,用来接受用户输入的一行字符,然后逐行存入 数据区。如果用户输入出现错误,在发现输入有误时及时更 正。