当前位置：文档之家 › 数据结构栈总结

数据结构栈总结

  • 格式：docx
  • 大小：36.09 KB
  • 文档页数：16

下载文档原格式

  / 16

合集下载

stack的知识点

stack的知识点

stack的知识点1. 栈的定义和特点栈（Stack）是一种具有特殊限制的线性数据结构，它的特点是“后进先出”（Last In First Out，LIFO）。

栈在计算机科学中有着广泛的应用，是一种非常重要的数据结构。

2. 栈的基本操作栈的基本操作包括入栈（push）和出栈（pop）两个操作。

•入栈操作：将元素添加到栈的顶部，使其成为新的栈顶元素。

•出栈操作：移除栈顶的元素，并返回被移除的元素。

除了入栈和出栈操作外，栈还支持其他操作，如获取栈顶元素（top）、判断栈是否为空（empty）、获取栈的大小（size）等。

3. 栈的实现方式栈可以使用数组或链表来实现。

•数组实现：使用数组来存储栈中的元素，通过一个指针来指示栈顶元素的位置。

入栈操作将元素添加到数组的末尾，出栈操作将指针向前移动一位。

•链表实现：使用链表来存储栈中的元素，每个节点包含一个数据元素和一个指向下一个节点的指针。

入栈操作将新元素插入链表的头部，出栈操作将头节点移除。

4. 栈的应用场景栈在计算机科学中有许多应用场景，以下是一些常见的应用场景。

•函数调用栈：在函数调用时，参数、局部变量和返回地址等信息会被压入栈中，函数返回时再从栈中弹出这些信息。

•表达式求值：栈可以用于解析和计算数学表达式，如中缀表达式的转换和后缀表达式的计算。

•括号匹配：栈可以用于检查表达式中的括号是否匹配，如圆括号、方括号和花括号等。

•浏览器的前进和后退功能：浏览器使用栈来记录用户访问的网页历史，通过栈的出栈和入栈操作实现前进和后退功能。

5. 栈的复杂度分析栈的入栈和出栈操作都只涉及到栈顶元素，所以这两个操作的时间复杂度都是O(1)。

而获取栈顶元素、判断栈是否为空和获取栈的大小等操作也都可以在O(1)时间内完成。

6. 总结栈是一种非常重要的数据结构，具有广泛的应用场景。

它的特点是“后进先出”，支持入栈和出栈等基本操作。

栈可以使用数组或链表来实现，常见的应用场景包括函数调用栈、表达式求值、括号匹配和浏览器的前进后退功能等。

栈的总结以及体会

栈的总结以及体会

栈的总结以及体会
栈是一种常用的数据结构，常用于程序的调用栈、表达式求值、深度优先搜索等场景。

栈的特点是先进后出，只允许在栈顶进行操作。

以下是对栈的总结和体会：
1. 实现方式：栈可以通过数组或链表来实现。

数组实现简单，但需要指定固定大小；链表实现可以动态调整大小，但需要额外的内存空间来保存指针信息。

2. 基本操作：栈的基本操作包括入栈（push）、出栈（pop）、获取栈顶元素（top）、判空（isEmpty）等。

操作的时间复杂
度均为O(1)。

3. 应用场景：栈在计算机科学中有广泛的应用。

例如，程序调用栈用于存储函数的局部变量和返回地址；表达式求值中使用栈来转换中缀表达式为后缀表达式，并利用后缀表达式进行运算；深度优先搜索中使用栈来维护待访问的节点。

4. 栈的优点：由于栈的特点，它在某些场景下能够提供高效的解决方案。

例如，在递归算法中，通过使用栈来保存递归的中间结果，可以避免递归的重复计算，提升算法的性能；在编译器的语法分析阶段，可以使用栈来验证括号的匹配情况，确保代码的正确性。

5. 栈的缺点：栈的大小一般是有限制的，当数据量超过栈的容量时，会导致栈溢出。

此外，由于栈是一个内存上的顺序结构，数据的存储是连续的，对于大型数据结构，可能会出现内存分
配不足的问题。

总而言之，栈是一种简单、高效的数据结构，广泛应用于计算机科学的各个领域。

熟练掌握栈的基本操作和相关应用场景，能够帮助我们更好地理解和解决实际问题。

数据结构--栈和队列基础知识

数据结构--栈和队列基础知识

数据结构--栈和队列基础知识⼀概述栈和队列，严格意义上来说，也属于线性表，因为它们也都⽤于存储逻辑关系为 "⼀对⼀" 的数据，但由于它们⽐较特殊，因此将其单独作为⼀篇⽂章，做重点讲解。

既然栈和队列都属于线性表，根据线性表分为顺序表和链表的特点，栈也可分为顺序栈和链表，队列也分为顺序队列和链队列，这些内容都会在本章做详细讲解。

使⽤栈结构存储数据，讲究“先进后出”，即最先进栈的数据，最后出栈；使⽤队列存储数据，讲究 "先进先出"，即最先进队列的数据，也最先出队列。

⼆栈2.1 栈的基本概念同顺序表和链表⼀样，栈也是⽤来存储逻辑关系为 "⼀对⼀" 数据的线性存储结构，如下图所⽰。

从上图我们看到，栈存储结构与之前所了解的线性存储结构有所差异，这缘于栈对数据 "存" 和 "取" 的过程有特殊的要求：1. 栈只能从表的⼀端存取数据，另⼀端是封闭的；2. 在栈中，⽆论是存数据还是取数据，都必须遵循"先进后出"的原则，即最先进栈的元素最后出栈。

拿图 1 的栈来说，从图中数据的存储状态可判断出，元素 1 是最先进的栈。

因此，当需要从栈中取出元素 1 时，根据"先进后出"的原则，需提前将元素 3 和元素 2 从栈中取出，然后才能成功取出元素 1。

因此，我们可以给栈下⼀个定义，即栈是⼀种只能从表的⼀端存取数据且遵循 "先进后出" 原则的线性存储结构。

通常，栈的开⼝端被称为栈顶；相应地，封⼝端被称为栈底。

因此，栈顶元素指的就是距离栈顶最近的元素，拿下图中的栈顶元素为元素 4；同理，栈底元素指的是位于栈最底部的元素，下中的栈底元素为元素 1。

2.2 进栈和出栈基于栈结构的特点，在实际应⽤中，通常只会对栈执⾏以下两种操作：向栈中添加元素，此过程被称为"进栈"（⼊栈或压栈）；从栈中提取出指定元素，此过程被称为"出栈"（或弹栈）；2.3 栈的具体实现栈是⼀种 "特殊" 的线性存储结构，因此栈的具体实现有以下两种⽅式：1. 顺序栈：采⽤顺序存储结构可以模拟栈存储数据的特点，从⽽实现栈存储结构。

数据结构实验报告实验总结

数据结构实验报告实验总结

数据结构实验报告实验总结本次数据结构实验主要涉及线性表、栈和队列的基本操作以及链表的应用。

通过实验，我对这些数据结构的特点、操作和应用有了更深入的了解。

下面对每一部分实验进行总结。

实验一：线性表的基本操作线性表是一种常见的数据结构，本实验要求实现线性表的基本操作，包括插入、删除、查找、遍历等。

在实验过程中，我对线性表的结构和实现方式有了更清晰的认识，掌握了用数组和链表两种方式实现线性表的方法。

实验二：栈的应用栈是一种后进先出（LIFO）的数据结构，本实验要求利用栈实现简单的括号匹配和后缀表达式计算。

通过实验，我了解到栈可以方便地实现对于括号的匹配和后缀表达式的计算，有效地解决了对应的问题。

实验三：队列的应用队列是一种先进先出（FIFO）的数据结构，本实验要求利用队列实现银行排队和迷宫求解。

通过实验，我对队列的应用有了更加深入的了解，了解到队列可以解决需要按顺序处理的问题，如排队和迷宫求解等。

实验四：链表的应用链表是一种常用的数据结构，本实验要求利用链表实现学生信息管理系统。

通过实验，我对链表的应用有了更深入的了解，了解到链表可以方便地实现对于数据的插入、删除和修改等操作，并且可以动态地调整链表的长度，适应不同的需求。

通过本次实验，我掌握了线性表、栈、队列和链表的基本操作，并了解了它们的特点和应用方式。

同时，通过实际编程的过程，我对于数据结构的实现方式和效果有了更直观的认识，也锻炼了自己的编程能力和解决问题的能力。

在实验过程中，我遇到了一些问题，如程序逻辑错误和内存泄漏等，但通过调试和修改，最终成功解决了这些问题，对自己的能力也有了更多的信心。

通过本次实验，我深刻体会到了理论与实践的结合的重要性，也对于数据结构这门课程有了更加深入的理解。

总之，本次数据结构实验给予了我很多有益的启发和收获，对于数据结构的概念、特点和应用有了更深入的理解。

在以后的学习中，我会继续加强对数据结构的学习和研究，不断提高自己的编程能力和解决问题的能力。

栈和队列的操作实验小结

栈和队列的操作实验小结

栈和队列的操作实验小结一、实验目的本次实验旨在深入理解和掌握栈和队列这两种基本数据结构的基本操作，包括插入、删除、查找等操作，并通过实际操作加深对这两种数据结构特性的理解。

二、实验原理栈（Stack）：栈是一种后进先出（Last In First Out，LIFO）的数据结构，即最后一个进入栈的元素总是第一个出栈。

在计算机程序中，栈常常被用来实现函数调用和递归等操作。

队列（Queue）：队列是一种先进先出（First In First Out，FIFO）的数据结构，即第一个进入队列的元素总是第一个出队。

在计算机程序中，队列常常被用来实现任务的调度和缓冲等操作。

三、实验步骤与结果创建一个空栈和一个空队列。

对栈进行入栈（push）和出栈（pop）操作，观察并记录结果。

可以发现，栈的出栈顺序与入栈顺序相反，体现了后进先出的特性。

对队列进行入队（enqueue）和出队（dequeue）操作，观察并记录结果。

可以发现，队列的出队顺序与入队顺序相同，体现了先进先出的特性。

尝试在栈和队列中查找元素，记录查找效率和准确性。

由于栈和队列的特性，查找操作并不像在其他数据结构（如二叉搜索树或哈希表）中那样高效。

四、实验总结与讨论通过本次实验，我更深入地理解了栈和队列这两种数据结构的基本特性和操作。

在实际编程中，我可以根据需求选择合适的数据结构来提高程序的效率。

我注意到，虽然栈和队列在某些操作上可能不如其他数据结构高效（如查找），但它们在某些特定场景下具有无可替代的优势。

例如，在实现函数调用和递归时，栈的特性使得它成为最自然的选择；在实现任务调度和缓冲时，队列的特性使得它成为最佳选择。

我也认识到，不同的数据结构适用于解决不同的问题。

在选择数据结构时，我需要考虑数据的特性、操作的频率以及对时间和空间复杂度的需求等因素。

通过实际操作，我对栈和队列的实现方式有了更深入的理解。

例如，我了解到栈可以通过数组或链表来实现，而队列则可以通过链表或循环数组来实现。

数据结构第3章栈

数据结构第3章栈
Elemtype pop(sqstack *s) { /*若栈s不为空，则删除栈顶元素*/ Elemtype x; if(s->top<0) return NULL; /*栈空*/ x=s->stack[s->top]; s->top--; return x; }
13
（4）取栈顶元素操作
Elemtype gettop(sqstack *s) { /*若栈s不为空，则返回栈顶元素*/ If(s->top<0) return NULL; /*栈空*/ return (s->stack[s->top]); }
。
29
算术表达式求值
在计算机中，任何一个表达式都是由: 操作数（operand）、运算符（operator）和 界限符（delimiter）组成的。 其中操作数可以是常数，也可以是变量或常量的 标识符；运算符可以是算术运算体符、关系运算符和 逻辑符；界限符为左右括号和标识表达式结束的结束 符。
30
6
存储结构
栈是一种特殊的线性表，有两种存储方式: 顺序存储结构存储
链式存储结构存储。


7
顺序栈的数组表示
与第二章讨论的一般的顺序存储结构的线性表 一样，利用一组地址连续的存储单元依次存放自 栈底到栈顶的数据元素，这种形式的栈也称为顺 序栈。 使用一维数组来作为栈的顺序存储空间。 设指针top指向栈顶元素的当前位置，以数组 小下标的一端作为栈底。 top=0时为空栈，元素进栈时指针top不断地 加1，当top等于数组的最大下标值时则栈满。
5）假如读出的运算符的优先级不大于运算符栈栈顶运算符
的优先级，则从操作数栈连续退出两个操作数，从运算符栈中 退出一个运算符，然后作相应的运算，并将运算结果压入操作 数栈。此时读出的运算符下次重新考虑（即不读入下一个符号 ）。

栈与队列实验报告总结

栈与队列实验报告总结实验报告总结：栈与队列一、实验目的本次实验旨在深入理解栈（Stack）和队列（Queue）这两种基本的数据结构，并掌握其基本操作。

通过实验，我们希望提高自身的编程能力和对数据结构的认识。

二、实验内容1.栈的实现：我们首先使用Python语言实现了一个简单的栈。

栈是一种后进先出（LIFO）的数据结构，支持元素的插入和删除操作。

在本次实验中，我们实现了两个基本的栈操作：push（插入元素）和pop（删除元素）。

2.队列的实现：然后，我们实现了一个简单的队列。

队列是一种先进先出（FIFO）的数据结构，支持元素的插入和删除操作。

在本次实验中，我们实现了两个基本的队列操作：enqueue（在队尾插入元素）和dequeue（从队头删除元素）。

3.栈与队列的应用：最后，我们使用所实现的栈和队列来解决一些实际问题。

例如，我们使用栈来实现一个算术表达式的求值，使用队列来实现一个简单的文本行编辑器。

三、实验过程与问题解决在实现栈和队列的过程中，我们遇到了一些问题。

例如，在实现栈的过程中，我们遇到了一个“空栈”的错误。

经过仔细检查，我们发现是因为在创建栈的过程中没有正确初始化栈的元素列表。

通过添加一个简单的初始化函数，我们解决了这个问题。

在实现队列的过程中，我们遇到了一个“队列溢出”的问题。

这是因为在实现队列时，我们没有考虑到队列的容量限制。

通过添加一个检查队列长度的条件语句，我们避免了这个问题。

四、实验总结与反思通过本次实验，我们对栈和队列这两种基本的数据结构有了更深入的理解。

我们掌握了如何使用Python语言实现这两种数据结构，并了解了它们的基本操作和实际应用。

在实现栈和队列的过程中，我们也学到了很多关于编程的技巧和方法。

例如，如何调试代码、如何设计数据结构、如何优化算法等。

这些技巧和方法将对我们今后的学习和工作产生积极的影响。

然而，在实验过程中我们也发现了一些不足之处。

例如，在实现栈和队列时，我们没有考虑到异常处理和性能优化等方面的问题。

栈和队列总结与心得

栈和队列总结与心得
栈和队列是计算机科学中非常重要的数据结构，它们在算法和程序设计中都有着广泛的应用。

在我的学习过程中，我深刻地认识到了栈和队列的重要性，并且对它们有了更深入的理解。

栈是一种后进先出（LIFO）的数据结构，它的操作包括入栈和出栈。

入栈操作将一个元素压入栈顶，出栈操作将栈顶元素弹出。

栈的应用非常广泛，例如在函数调用中，每次函数调用时都会将当前函数的状态保存在栈中，当函数返回时再将状态弹出，这样就可以实现函数的嵌套调用。

此外，栈还可以用于表达式求值、括号匹配等问题的解决。

队列是一种先进先出（FIFO）的数据结构，它的操作包括入队和出队。

入队操作将一个元素加入队尾，出队操作将队头元素弹出。

队列的应用也非常广泛，例如在操作系统中，进程调度时就可以使用队列来管理进程的执行顺序。

此外，队列还可以用于广度优先搜索、缓存等问题的解决。

在学习栈和队列的过程中，我深刻地认识到了它们的优点和缺点。

栈的优点是操作简单，只需要考虑栈顶元素即可，缺点是只能访问栈顶元素，不能随意访问其他元素。

队列的优点是可以访问队列头和队列尾，缺点是操作稍微复杂一些，需要考虑队列头和队列尾的位置。

栈和队列是计算机科学中非常重要的数据结构，它们在算法和程序设计中都有着广泛的应用。

在我的学习过程中，我深刻地认识到了它们的优点和缺点，并且对它们有了更深入的理解。

我相信，在今后的学习和工作中，我会更加熟练地运用栈和队列，为解决实际问题做出更大的贡献。

数据结构-栈

数据结构-栈⼀、栈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,指向栈顶)。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
if(!S.base)
exit(OVERFLOW);//存储分配失
S.top=S.base+S.stacksize;
S.stacksize+=STACK_INCREMENT;
}
*(S.top)++=e;
}
Status ListInser_Cir(CirLinkList L,int i,int e) //在i处插入元素e，算法-8
return OK;
}
同双向链表
求表的长度
int ListLength_Sq(SqList L) //返回L中数据元素个数
{
return L.length;
}
int ListLength_Link(LinkList L)//得到表的长度
{
int i=0;
LinkList p;
p=L->next;
while(p)
p->next=q->next;
q->next=p;
return OK;
}
Status ListInser_Dul(DulLinkList L,int i,int e) //在i处插入元素e，算法-8
{
int j=1;
DulLinkList p,q;
q=L;
if(i<1||i>(ListLength_Dul(L)+1))
{
if(L->next==NULL)
return OK;
return ERROR;
}
Status ListEmpty_Cir(CirLinkList L) //判断L表是否为空表
{
if(L->next==L)
return OK;
return ERROR;
}
Status ListEmpty_Dul(DulLinkList L) //判断L表是否为空表
同
尾插入法
无
Status InsLast_Link(LinkList &q,LinkList &p) //尾插入法
{
q->next=p;
q=p;
p->next=NULL;
return OK;
}
Status InsLast_Cir(CirLinkList &q,CirLinkList &p) //尾插入法
}
同双向链表
头插入法
无
Status InsFirst_Link(LinkList &L,LinkList &p) //头插入，算法-10
{
p->next=L->next;
L->next=p;
return OK;
}
Status InsFirst_Cir(CirLinkList &L,CirLinkList &p) //头插入，算法-10
};
typedef DulNode *DulLinkList;
同双向链表
初始化(Init)
void InitStack(SeqStack &S)//构造一个空栈S
{
S.top=-1; //top为下标
}
void InitStack(SqStack &S)//构造一个空栈S
{
if(!(S.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType))))
return ERROR;
while(j<i&&q)
{
q=q->next;
j++;
}
p=(DulLinkList)malloc(sizeof(DulNode));
p->data=e;
p->next=q->next;
p->prior=q;
q->next->prior=p;
q->next=p;
return OK;
{
p->next=L->next;
L->next=p;
return OK;
}
Status InsFirst_Dul(DulLinkList &L,DulLinkList &p)
{
p->next=L->next;
p->prior=L;
L->next->prior=p;
L->next=p;
return OK;}
{
q->next=p;
q=p;
p->next=L;
return OK;
}
Status InsLast_Dul(DulLinkList &q,DulLinkList &p) //尾插入法
{
q->next=p;
p->pL;
return OK;
}
Status InsLast_Dul(DulLinkList &q,DulLinkList &p) //尾插入法
{
if(L->next==L&&L->prior=NULL)
return OK;
return ERROR;
}
Status ListEmpty_Dul(DulLinkList L) //判断L表是否为空表
{
int j=1;
CirLinkList p,q;
q=L;
if(i<1||i>(ListLength_Cir(L)+1))
return ERROR;
while(j<i&&q)
{
q=q->next;
j++;
}
p=(CirLinkList)malloc(sizeof(CirNode));
p->data=e;
{
int j=1;
if(i<1||i>ListLength_Cir(L))
return ERROR;
while(j<i)
{
L=L->next;
j++;
}
CirLinkList p;
p=L->next;
e=p->data;
L->next=p->next;
free(p);
return OK;
}
Status ListDelete_Dul(DulLinkList L,int i,int &e)//删除第i个元素，并用e返回，算法-9
{
q->next=p;
p->prior=q;
q=p;
p->next=L;
return OK;
}
删除相应序号的结点
Status ListDelete_Sq(SqList &L,int i,ElemType &e) //在顺序线性表L中删除第i个元素，并用e返回其值
{//算法2.5
int *p,*q;
if(i<1||i>L.length)
L->prior=NULL;
return OK;
}
Status InitList_Dul(DulLinkList &L) //构造一个空的头结点
{
L=(DulLinkList)malloc(sizeof(DulNode));
if(!L)
return ERROR;
L->next=L;
L->prior=L->next;
{
i++;
p=p->next;
}
return i;
}
int ListLength_Cir(CirLinkList L)//得到表的长度
{
int i=0;
CirLinkList p;
p=L->next;
while(p!=L)
{
i++;
p=p->next;
}
return i;
}
int ListLength_Dul(DulLinkList L)//得到表的长度
return OK;
}
插入元素
Status ListInsert_Sq(SqList &L,int i,ElemType e) //在顺序线性表L中第i个位置之前插入新的元素e
{//算法2.4
int *p,*q,*newbase;
if(i<1|| i>L.length+1)return ERROR; //i值不合法
数据结构
第3章栈与队列总结
栈
顺序栈
单链栈
循环链栈
双向链栈
双向循环链栈
数组
结构体
结构模型
#define MAXSIZE 10
typedef struct{
SElemTypeStack[MAXSIZE];
int top;
}SeqStack;
typedef struct{
SElemType *base;//在栈构造之前和销毁之后，base的值为NULL
return OK;
}
void Push(SqStack &S,SElemType e)//插入元素e为新的栈顶元素
{
if(S.top-S.base>=S.stacksize)//栈满，追加存储空间
{
S.base=(SElemType *)realloc(S.base,(S.stacksize+STACK_INCREMENT*sizeof(SElemType)));