精华内容
下载资源
问答
  • 栈 队列
    千次阅读
    2022-03-13 06:21:18

     基于双向链表实现栈与队列:

            内部类DoubleLinkedList<T> 可以构建双向链表, 提供4中操作: 头插 ,头取 ,尾插 ,尾取 .所以可以称为"双端双向链表"(自己起的 便于理解),这两端分别由head 和 tail 分别引用. 通常链表无论是单向还是双向链表都只有一个 head, 但为了实现基于"双端双向链表"的 "栈" 和 "队列",这四种操作头插 和 头取 就是 "栈" ,头插 尾取就是"队列".

             栈和队列都是逻辑上的结构,在数据结构中是ADT,实现的方式可以基于数组或链表或其它.      

    
    /**
     * 栈和队列的操作
     * <p>
     * 栈和队列实现:
     *      1.双向链表实现
     *      2.数组实现
     *
     * 基于双向链表实现
     */
    public class StackOrQueueBaseOnLink {
    
        private static class MyStack<T>{
            private final DoubleLinkedList<T> linkedList = new DoubleLinkedList<>();
            public void push(T t){
                linkedList.addToHead(t);
            }
            public T pop(){
                return linkedList.popFromHead();
            }
        }
    
        private static class MyQueue<T>{
            private final DoubleLinkedList<T> linkedList = new DoubleLinkedList<>();
            public void push(T t){
                linkedList.addToHead(t);
            }
            public T pop(){
                return linkedList.popFromTail();
            }
        }
    
        /**
         * 双端双向链表: 头尾可进可出
         *
         * @param <T> 存储类型
         */
        private static class DoubleLinkedList<T> {
            public Node<T> head;
            public Node<T> tail;
    
            /*头部弹出*/
            public T popFromHead(){
                if(this.head == null){
                    return null;
                }
                Node<T> curr = head;
                if(head == tail){
                    head = null;
                    tail = null;
                }else{
                    head = head.next;
                    head.prev = null;
                    curr.next = null;
                }
                return curr.val;
            }
            /*尾部弹出*/
            public T popFromTail(){
                if(this.tail == null){
                    return null;
                }
                Node<T> curr = tail;
                if(tail == head){
                    tail = null;
                    head = null;
                }else{
                    tail = tail.prev;
                    tail.next = null;
                    curr.prev = null;
                }
                return curr.val;
            }
    
            public void addToHead(T val) {
                Node<T> curr = new Node<>(val);
                if (head == null) {
                    head = curr;
                    tail = curr;
                } else {
                    //头插curr
                    curr.next = head;
                    head.prev = curr;
                    //重置head
                    head = curr;
                }
            }
    
            public void addToTail(T val){
                Node<T> curr = new Node<>(val);
                if(tail == null){
                    head = curr;
                    tail = curr;
                }else{
                    //尾插
                    tail.next = curr;
                    curr.prev = tail;
                    tail = curr;
                }
            }
        }
    
        private static class Node<T> {
            public T val;
            public Node<T> prev;
            public Node<T> next;
    
            public Node(T val) {
                this.val = val;
            }
        }
    }
    

      左神算法学习

    更多相关内容
  • delphi栈队列操作

    2018-06-04 14:45:22
    delphi栈队列操作 delphi栈队列操作 delphi栈队列操作
  • Queue_栈队列_pop_

    2021-09-30 04:30:26
    任务描述队列都提供 Push/Pop 两种操作,其中 Push:加入一个元素。Pop:弹出一个元素。给出一个线性结构的进出顺序,判定这个结构是还是队列。(40’) 输入描述第一行输入一个整数s,代表有s组测试数据。第一...
  • C语言-数据结构-栈队列实现
  • 1、5个男生3个女生排成一排,3个女生要排在一起,有多少种不同的排法?
  • 主要介绍了Python 实现数据结构中的的队列,本文给大家介绍的非常详细,具有一定的参考借鉴价值,需要的朋友可以参考下
  • 数据结构栈队列ppt.ppt

    2022-07-11 19:43:59
    数据结构栈队列ppt.ppt该文档详细且完整,值得借鉴下载使用,欢迎下载使用,有问题可以第一时间联系作者~
  • 栈队列练习题答案.doc

    2020-07-23 06:08:04
    栈队列练习题 一选择题 1. 栈和队列的共同特点是( ) A.只允许在端点处插入和删除元素 B.都是先进后出 C.都是先进先出 D.没有共同点 2. 若让元素1234依次入栈则出栈次序不可能出现 A3 2 1 4 B2 1 4 3 C1 4 2 3 D4 3 2...
  • 超级数组和链表及栈队列
  • 该压缩包包含线性表、队列的线性存储和链式存储结构的源文件
  • 栈队列PPT学习教案.pptx
  • 栈队列bPPT学习教案.pptx
  • 算法课程 栈队列并查集.pdf
  • 队列的概念

    千次阅读 2021-10-12 20:20:25
    文章目录栈、队列和双端队列栈队列双端队列Java 中的栈、队列和双端队列单调栈和单调队列二叉堆和优先队列二叉堆优先队列 栈、队列和双端队列 栈和队列是常见的数据结构。栈的特点是后进先出,添加元素、删除元素和...

    栈、队列和双端队列

    栈和队列是常见的数据结构。栈的特点是后进先出,添加元素、删除元素和查看元素都在栈顶操作。队列的特点是先进先出,添加元素在队尾操作,删除元素和查看元素在队首操作。

    双端队列比栈和队列更加灵活,可以在双端队列的两端添加元素、删除元素和查看元素。

    栈、队列和双端队列都满足每次添加元素、删除元素和查看元素的时间复杂度是 O ( 1 ) O(1) O(1)

    栈、队列和双端队列都可以基于数组或链表实现。

    栈是一种特殊的线性表,特点是后进先出,最先加入的元素最后取出,最后加入的元素最先取出。

    栈的常见操作包括判断栈是否为空和获得栈内元素个数,以及对元素的操作。对元素的操作都位于栈顶,包括以下三种操作:

    • 添加元素:将元素加入栈顶,该操作称为入栈;
    • 删除元素:将栈顶元素删除,该操作称为出栈;
    • 查看元素:获得栈顶元素,不删除元素。

    下图为栈的示意,左边为栈底,右边为栈顶。将数字 1 1 1 5 5 5 依次入栈之后,栈的状态如下图所示,此时栈顶元素是 5 5 5,第一个出栈的元素是 5 5 5

    图 1

    队列

    队列是一种特殊的线性表,特点是先进先出,最先加入的元素最先取出,最后加入的元素最后取出。队列有头部和尾部,队列头部称为队首,队列尾部称为队尾,队列内的元素从队首到队尾的顺序符合加入队列的顺序。

    队列的常见操作包括判断队列是否为空和获得队列内元素个数,以及对元素的操作。对元素的操作包括以下三种操作:

    • 添加元素:将元素加入队尾,该操作称为入队;
    • 删除元素:将队首元素删除,该操作称为出队;
    • 查看元素:获得队首元素,不删除元素。

    需要注意的是,队列的三种对元素的操作所在的位置不同,查看元素和删除元素位于队首,添加元素位于队尾。

    下图为队列的示意,左边为队首,右边为队尾。将数字 1 1 1 5 5 5 依次入队之后,队列的状态如下图所示,此时队首元素是 1 1 1,队尾元素是 5 5 5,第一个出队的元素是 1 1 1

    图 2

    双端队列

    双端队列是一种特殊的线性表,同时具有栈和队列的性质,特点是在队首和队尾都可以加入和取出元素。栈和队列都可以基于双端队列实现。

    Java 中的栈、队列和双端队列

    Java 提供了多种类和接口支持栈、队列和双端队列的实现。

    Stack \texttt{Stack} Stack 类是早期版本的栈的实现类,继承自 Vector \texttt{Vector} Vector 类。在后续版本中,JDK 的官方文档不建议使用 Stack \texttt{Stack} Stack 类实现栈的功能,而是建议使用 Deque \texttt{Deque} Deque 接口及其实现类实现栈的功能。

    Queue \texttt{Queue} Queue 接口是队列的接口,需要通过实现类完成实例化,常见的实现类包括 ArrayDeque \texttt{ArrayDeque} ArrayDeque 类和 LinkedList \texttt{LinkedList} LinkedList 类。

    Deque \texttt{Deque} Deque 接口是双端队列的接口,需要通过实现类完成实例化,常见的实现类包括 ArrayDeque \texttt{ArrayDeque} ArrayDeque 类和 LinkedList \texttt{LinkedList} LinkedList 类。

    ArrayDeque \texttt{ArrayDeque} ArrayDeque 类和 LinkedList \texttt{LinkedList} LinkedList 类都可以作为栈和队列的实现类,区别在于, ArrayDeque \texttt{ArrayDeque} ArrayDeque 类的底层实现是循环数组, LinkedList \texttt{LinkedList} LinkedList 类的底层实现是双向链表。根据 JDK 的官方文档, ArrayDeque \texttt{ArrayDeque} ArrayDeque 类作为栈使用时效率高于 Stack \texttt{Stack} Stack 类, ArrayDeque \texttt{ArrayDeque} ArrayDeque 类作为队列使用时效率高于 LinkedList \texttt{LinkedList} LinkedList 类。无论是栈的实现还是队列的实现,都推荐使用 ArrayDeque \texttt{ArrayDeque} ArrayDeque 类。

    单调栈和单调队列

    单调栈和单调队列是栈和队列的高级应用,可以解决一些复杂的问题。

    单调栈和单调队列满足元素的单调性。具体而言,单调栈内从栈底到栈顶的元素依次递增或递减,单调队列内从队首到队尾的元素依次递增或递减。在单调栈和单调队列中添加元素时,必须维护元素的单调性。

    向单调栈添加元素时,首先需要检查栈顶元素和待添加元素是否满足单调性,如果不满足单调性则将栈顶元素出栈,直到栈为空或者栈顶元素和待添加元素满足单调性,然后将待添加元素入栈。

    向单调队列添加元素时,首先需要检查队尾元素和待添加元素是否满足单调性,如果不满足单调性则将队尾元素出队,直到队列为空或者队尾元素和待添加元素满足单调性,然后将待添加元素入队。

    由于普通的队列不支持在队尾将元素出队,因此需要使用双端队列实现单调队列的功能。

    单调栈和单调队列的应用需要考虑具体情况。有时需要维护下标信息,因此在单调栈和单调队列中存储的不是元素本身,而是元素下标,下标对应的元素满足单调性。

    使用单调栈和单调队列实现通常需要两层循环,但是由于每个元素最多只会在单调栈或单调队列中被添加一次和删除一次,因此时间复杂度是线性复杂度,而不是平方复杂度。

    二叉堆和优先队列

    优先队列是一种不同于栈、队列和双端队列的数据结构。栈、队列和双端队列的实现原理是线性表,而优先队列的实现原理是二叉堆。

    二叉堆

    在介绍二叉堆之前,首先需要介绍二叉树和完全二叉树。

    二叉树是一个树的结构,每个结点最多有两个子结点,称为左子结点和右子结点。

    完全二叉树的性质是,除了层数最大的层以外,其余各层的结点数都达到最大值,且层数最大的层的所有结点都连续集中在最左边。假设完全二叉树有 l l l 层,其中根结点位于第 0 0 0 层,则对于 0 ≤ i < l − 1 0 \le i < l - 1 0i<l1,第 i i i 层有 2 i 2^i 2i 个结点。

    二叉堆是一棵完全二叉树,其中的元素按照特定规则排列。常见的例子有小根堆和大根堆。

    • 小根堆的性质是,每个结点的值都小于其子结点的值,根结点的值是堆中最小的;
    • 大根堆的性质是,每个结点的值都大于其子结点的值,根结点的值是堆中最大的。

    在二叉堆中添加元素和删除元素时,必须维护二叉堆的性质。以小根堆为例,添加元素和删除元素的操作如下:

    • 添加元素时,假设添加的元素是 x x x,首先将 x x x 添加到末尾,然后比较 x x x 和父结点元素的大小,如果 x x x 小于父结点元素,则将 x x x 和父结点交换,直到 x x x 到达根结点或者大于等于父结点元素;
    • 删除元素时,假设堆中的最后一个元素是 x x x,首先将 x x x 放置到根结点处,然后比较 x x x 和子结点元素的大小,如果 x x x 大于至少一个子结点元素,则将 x x x 和较小的子结点交换,直到 x x x 到达叶结点(没有子结点)或者小于等于全部子结点元素。

    考虑以下小根堆。

    图 3

    8 8 8 添加到小根堆中,首先将 8 8 8 添加到末尾。

    图 4

    由于 8 8 8 比父结点 15 15 15 小,因此交换,交换后 8 8 8 比父结点 10 10 10 小,因此再次交换,此时 8 8 8 不再比父结点 5 5 5 小,因此停止交换。添加元素操作结束。

    图 5

    在添加 8 8 8 之后,删除元素。删除堆顶元素 5 5 5,将最后一个元素 15 15 15 放置到根结点处。

    图 6

    由于 15 15 15 比两个子结点元素都大,因此和较小的子结点 8 8 8 交换,交换后 15 15 15 比较小的子结点 10 10 10 大,因此和较小的子结点 10 10 10 交换,此时 15 15 15 不再比子结点 30 30 30 大,因此停止交换。删除元素操作结束。

    图 7

    假设二叉堆中的元素个数是 n n n,二叉堆的层数是 l l l。根据上述例子可知,在二叉堆中添加元素和删除元素时,需要维护二叉堆的性质,时间复杂度是 O ( l ) O(l) O(l),由于 O ( l ) = O ( log ⁡ n ) O(l) = O(\log n) O(l)=O(logn),因此二叉堆的添加元素和删除元素的时间复杂度是 O ( log ⁡ n ) O(\log n) O(logn)

    优先队列

    不同于栈的后进先出和队列的先进先出,优先队列中的每个元素都有优先级,优先级最高的元素位于队首,也是最先取出的元素。

    Java 的 PriorityQueue \texttt{PriorityQueue} PriorityQueue 类是优先队列类,继承自 AbstractQueue \texttt{AbstractQueue} AbstractQueue 抽象类。 PriorityQueue \texttt{PriorityQueue} PriorityQueue 类的实现原理是二叉堆,底层实现是数组,二叉堆满足堆顶元素为优先级最高的元素。创建优先队列的时候可以自定义优先队列中的元素的比较方法,从而自定义优先级。

    由于 Java 的优先队列的实现原理是二叉堆,因此优先队列的添加元素和删除元素的时间复杂度是 O ( log ⁡ n ) O(\log n) O(logn),查看元素的时间复杂度是 O ( 1 ) O(1) O(1),其中 n n n 是优先队列中的元素个数。

    目录

    1. 栈题目:文件夹操作日志搜集器
    2. 栈题目:括号的最大嵌套深度
    3. 栈题目:有效的括号
    4. 栈题目:棒球比赛
    5. 栈题目:删除最外层的括号
    6. 栈题目:删除字符串中的所有相邻重复项
    7. 栈题目:用栈操作构建数组
    8. 栈题目:两数相加 II
    9. 栈题目:逆波兰表达式求值
    10. 栈题目:使括号有效的最少添加
    11. 栈题目:平衡括号字符串的最少插入次数
    12. 栈题目:最小栈
    13. 栈题目:行星碰撞
    14. 栈题目:验证栈序列
    15. 栈题目:检查替换后的词是否有效
    16. 栈题目:反转每对括号间的子串
    17. 栈题目:移除无效的括号
    18. 栈题目:简化路径
    19. 栈题目:括号的分数
    20. 栈题目:函数的独占时间
    21. 栈题目:字符串解码
    22. 栈题目:解析布尔表达式
    23. 栈题目:有效括号的嵌套深度
    24. 栈题目:删除字符串中的所有相邻重复项 II
    25. 栈题目:迷你语法分析器
    26. 栈题目:设计浏览器历史记录
    27. 栈题目:基本计算器
    28. 栈题目:基本计算器 II
    29. 栈题目:文件的最长绝对路径
    30. 栈题目:标签验证器
    31. 队列题目:无法吃午餐的学生数量
    32. 队列题目:最近的请求次数
    33. 队列题目:用队列实现栈
    34. 队列题目:用栈实现队列
    35. 队列题目:按递增顺序显示卡牌
    36. 队列题目:设计循环队列
    37. 队列题目:设计循环双端队列
    38. 单调栈题目:去除重复字母
    39. 单调栈题目:移掉 K 位数字
    40. 单调栈题目:找出最具竞争力的子序列
    41. 单调栈题目:132 模式
    42. 单调栈题目:每日温度
    43. 单调栈题目:接雨水
    44. 单调栈题目:股票价格跨度
    45. 单调栈题目:最大宽度坡
    46. 单调栈题目:子数组的最小值之和
    47. 单调栈题目:柱状图中最大的矩形
    48. 单调栈题目:最大矩形
    49. 单调队列题目:绝对差不超过限制的最长连续子数组
    50. 单调队列题目:满足不等式的最大值
    51. 单调队列题目:和至少为 K 的最短子数组
    52. 优先队列题目:最后一块石头的重量
    53. 优先队列题目:数据流中的第 K 大元素
    54. 优先队列题目:拼车
    55. 优先队列题目:合并K个升序链表
    56. 优先队列题目:滑动窗口最大值
    57. 优先队列题目:数据流的中位数
    58. 优先队列题目:多次求和构造目标数组
    59. 优先队列题目:数组的最小偏移量
    展开全文
  • 数据结构线性表栈队列二叉树图PPT学习教案.pptx
  • 只有线性表、栈队列
  • 八大数据结构 —— 数组 队列 链表 树 散列表 堆 图 1. 数组 优点:按照索引查询速度快、遍历数组方便 缺点: 数组大小固定后无法扩容 数组只能存储一种类型的数据 添加删除慢(需要移动其它元素) 使用场景:...

    八大数据结构 —— 数组 栈 队列 链表 树 散列表 堆 图

    在这里插入图片描述

    1. 数组

    优点:按照索引查询速度快、遍历数组方便

    缺点:

    • 数组大小固定后无法扩容
    • 数组只能存储一种类型的数据
    • 添加删除慢(需要移动其它元素)

    使用场景:频繁查询,对存储空间要求不大;增加删除少的情况

    一维数组:a[0]  	a[1]	a[2]	a[3]
    

    2. 栈

    栈是一种特殊的线性表,仅能在线性表的一端操作,栈顶允许操作,栈底不允许操作 。

    特点: 先进后出

    使用场景 :栈常应用于实现递归功能方面的场景,例如斐波那契数列。

    在这里插入图片描述

    3. 队列

    队列也是一种线性表 。 不同的是,队列可以在一端添加元素,在另一端取出元素 。

    特点:先进先出

    使用场景 : 因为队列先进先出的特点,在多线程阻塞队列管理中非常适用。

    在这里插入图片描述

    4. 链表

    链表是物理存储单元上非连续的、非顺序的存储结构,数据元素的逻辑顺序是通过链表的指针地址实现,每个元素包含两个结点,一个是存储元素的数据域(内存空间),另一个是指向下一个结点的指针域。根据指针的指向,链表能形成不同的结构。例如:单链表,双向链表,循环链表等。

    优点:

    • 很常用的一种数据结构,不需要初始化容量,可以任意加减元素;
    • 添加或删除元素时只需要改变前后两个元素结点的指针域指向地址即可,所以添加删除速度很快。

    缺点:

    • 因含有大量的指针域,占用空间较大;

    • 查找元素需要遍历链表来查找,非常耗时。

    使用场景:数据量较小,需要频繁添加删除操作的场景。

    在这里插入图片描述

    5.树

    树是由结点或顶点和边组成的(可能是非线性的)且不存在着任何环的一种数据结构。

    特点:

    • 每个结点有零个或多个子结点
    • 没有父结点的结点为根节点;
    • 每个非根结点有且只有一个父结点
    • 除了根结点外,每个子结点可以分为多个不相交的子树

    种类:

    • 无序树: 树中任意节点的子结点之间没有顺序关系,这种树称为无序树,也称为自由树;

    • 有序树: 树中任意节点的子结点之间有顺序关系,这种树称为有序树;

    • 二叉树: 每个节点最多含有两个子树的树称为二叉树;

    • 完全二叉树: 完全二叉树是效率很高的数据结构,完全二叉树是由满二叉树而引出来的。对于深度为K的,有n个结点的二叉树,当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。

    • 满二叉树:

      • 国内教程定义 :一个二叉树,如果每一个层的结点数都达到最大值,则这个二叉树就是满二叉树。也就是说,如果一个二叉树的层数为K,且结点总数是(2^k) -1 ,则它就是满二叉树。

    在这里插入图片描述

    • 国外(国际)定义:a binary tree T is full if each node is either a leaf or possesses exactly two childnodes.

    • 大意为:如果一棵二叉树的结点要么是叶子结点,要么它有两个子结点,这样的树就是满二叉树 (一棵满二叉树的每一个结点要么是叶子结点,要么它有两个子结点,但是反过来不成立,因为完全二叉树也满足这个要求,但不是满二叉树)

    在这里插入图片描述

    上图中这个二叉树也是满二叉树。但是按照国内的定义,它却不是满二叉树。

    • 霍夫曼树: 带权路径最短的二叉树称为哈夫曼树或最优二叉树;

    6. 散列表

    散列表(Hash table,也叫哈希表),是根据关键码值(Key value)而直接进行访问的数据结构。也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。这个映射函数叫做散列函数,存放记录的数组叫做散列表。

    7. 堆

    堆(Heap)是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵完全二叉树的数组对象。

    特点:

    • 堆中某个节点的值总是不大于或不小于其父节点的值;

    • 堆总是一棵完全二叉树。

      将根节点最大的堆叫做最大堆或大根堆,根节点最小的堆叫做最小堆或小根堆。常见的堆有二叉堆、斐波那契堆等。
      在这里插入图片描述

    8. 图

    图是另一种非线性数据结构。在图结构中,数据结点一般称为顶点,而边是顶点的有序偶对。如果两个顶点之间存在一条边,那么就表示这两个顶点具有相邻关系
    图详情

    展开全文
  • 数据结构-03-123栈队列数组-691.ppt
  • CKDataStructureKit用 oc 封装了队列,优先队列
  • 电信设备-信令网关的协议栈队列的维护方法、装置及系统.zip
  • 1.利用数组实现两种基础的数据结构:队列(queue,先进先出)和(stack,先进后出)。 首先定义一个全局数组int arr[100]; (定义在所有函数之前,#include语句之后)。   1)队列— 仅支持两种操作 int dequeue() ...
  • 数据结构之线性表栈队列

    千次阅读 2020-02-20 18:24:06
    数据结构之线性表栈队列、实现方式和顺序表示、栈和队列的共同点和不同点

    数据结构之线性表栈队列

    一定义:

    1、线性表(linear list):

    是数据结构的一种,一个线性表是n个具有相同特性的数据元素的有限序列。数据元素是一个抽象的符号,其具体含义在不同的情况下一般不同。

    2、栈(Stack):

    栈是限定仅能在表尾进行插入或删除操作的线性表。对栈来说,表尾称为栈顶、表头称为栈底,不含元素的空表称为空栈。

    由于栈的上述特性,最先入栈的元素最后才能被删除,最晚入栈的元素最先被删除,所以栈又称为后进先出的线性表。

    应用例子:进制转换、括号匹配检验、行编辑程序、迷宫求解、表达式求值、递归实现

    3、队列(Queue):

    和栈相反,队列是一种先进先出的线性表,它只允许在表的一端进行插入,而在另一端删除元素,允许插入的一端叫队尾,允许删除的一端叫队头。

    应用例子:操作系统中的作业排队

    双端队列,是限定插入和删除操作在表的两端进行的线性表,尽管双端队列看起来比栈和队列灵活,但实际上在应用程序中远不及栈和队列有用。

    Stack栈类与、Queue队列与线性表的区别和联系

    栈和队列都属于特殊的线性表

    二实现方式和顺序表示

    1、线性表:

    用一组地址连续的储存单元依次存储线性表的数据元素。以元素在计算机内“物理位置相邻”来表示线性表中数据元素之间的逻辑关系。只要确定了数据元素的起始位置,就可随机地访问数据元素。但是这种表示方法不便于插入和删除元素,每插入或删除一个元素,都要移动插入或删除位置之后的数据元素在连续储存单元中的位置,而且除了重新分配内存,否则在程序运行过程中不能动态地增加储存单元的数量。

    2、栈:

    和线性表相似,栈也有两种储存方式,顺序栈和链式栈。

    顺序栈的实现在于使用了数组这个基本数据结构,数组中的元素在内存中的存储位置是连续的,且编译器要求我们在编译期就要确定数组的大小,这样对内存的使用效率并不高,一来无法避免因数组空间用光而引起的溢出问题,二在系统将内存分配给数组后,则这些内存对于其他任务就不可用;

    而链栈使用了链表来实现栈,链表中的元素存储在不连续的地址,由于是动态申请内存,所以我们可以以非常小的内存空间开始,另外当某个项不使用时也可将内存返还给系统。

    3、队列

    1)顺序队列

    建立顺序队列结构必须为其静态分配或动态申请一片连续的存储空间,并设置两个指针进行管理。一个是队头指针front,它指向队头元素;另一个是队尾指针rear,它指向下一个入队元素的存储位置,

    每次在队尾插入一个元素是,rear增1;每次在队头删除一个元素时,front增1。随着插入和删除操作的进行,队列元素的个数不断变化,队列所占的存储空间也在为队列结构所分配的连续空间中移动。当front=rear时,队列中没有任何元素,称为空队列。当rear增加到指向分配的连续空间之外时,队列无法再插入新元素,但这时往往还有大量可用空间未被占用,这些空间是已经出队的队列元素曾经占用过得存储单元。

    顺序队列中的溢出现象:

    (1) "下溢"现象:当队列为空时,做出队运算产生的溢出现象。“下溢”是正常现象,常用作程序控制转移的条件。

    (2)"真上溢"现象:当队列满时,做进栈运算产生空间溢出的现象。“真上溢”是一种出错状态,应设法避免。

    (3)"假上溢"现象:由于入队和出队操作中,头尾指针只增加不减小,致使被删元素的空间永远无法重新利用。当队列中实际的元素个数远远小于向量空间的规模时,也可能由于尾指针已超越向量空间的上界而不能做入队操作。该现象称为"假上溢"现象。

    2)循环队列

    在实际使用队列时,为了使队列空间能重复使用,往往对队列的使用方法稍加改进:无论插入或删除,一旦rear指针增1或front指针增1 时超出了所分配的队列空间,就让它指向这片连续空间的起始位置。自己真从MaxSize-1增1变到0,可用取余运算rear%MaxSize和front%MaxSize来实现。这实际上是把队列空间想象成一个环形空间,环形空间中的存储单元循环使用,用这种方法管理的队列也就称为循环队列。除了一些简单应用之外,真正实用的队列是循环队列

    在循环队列中,当队列为空时,有front=rear,而当所有队列空间全占满时,也有front=rear。为了区别这两种情况,规定循环队列最多只能有MaxSize-1个队列元素,当循环队列中只剩下一个空存储单元时,队列就已经满了。因此,队列判空的条件时front=rear,而队列判满的条件时front=(rear+1)%MaxSize。

    三简述栈和队列的共同点和不同点.它们与线性表有什么关系:

    共同点:都有顺序结构和链式结构,都是只能在线性表的端点插入和删除。

    不同点:操作不同。栈和队列是在程序设计中被广泛使用的两种线性数据结构,它们的特点在于基本操作的特殊性,栈必须按"后进先出"的规则进行操作,而队列必须按"先进先出"的规则进行操作。

    与线性表的关系:栈和队列都是线性表,都是限制了插入删除点的线性表(或者说是控制了访问点的线性表)。

    队列是一种特殊的线性表,特殊之处在于它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作,和栈一样,队列是一种操作受限制的线性表。进行插入操作的端称为队尾,进行删除操作的端称为队头。队列中没有元素时,称为空队列。

    展开全文
  • 队列经典面试题

    千次阅读 多人点赞 2022-03-31 14:14:23
    目录 1、括号匹配问题 ...2、用队列实现 3、用实现队列 4、设计循环队列 1、括号匹配问题 链接直达: 有效的括号 题目: 思路: 2、用队列实现 3、用实现队列 4、设计循环队列 ...
  • C语言---队列

    2022-05-01 16:08:39
    严格来说,队列都属于线性表 "一对一" :"先进后出" 队列: "先进先出" 只能从一端存取,另一端是封闭的 在中,不论是存还是取,都必须遵循"先进后出"的原则 ==>是一种只能从表的一端...
  • python 实现队列

    2022-01-09 22:00:35
    本文不涉及栈和队列概念的详细讲解,而着重利用 python 实现栈和队列,在其中穿插代码讲解。 目录栈队列 栈 栈实现数据的后进先出(LIFO)。 队列 队列实现数据的先进先出(FIFO)。
  • stack和队列

    万次阅读 多人点赞 2021-01-30 16:18:46
    队列一· 队列二· 三.队列四.例题 一· 队列 队列是两种重要的线性结构。从数据结构来看,队列也是线性表,其特殊性在于队列的基本操作是线性表操作的子集(也具有顺序结构和链式结构)...
  • 本文实例讲述了Python数据结构之队列及二叉树定义与用法。分享给大家供大家参考,具体如下: 目前只实现了三种,队列和二叉树,哪天得空继续补吧~ 1. # class Stack: def __init__(self,size = 16): ...
  • 队列(超详细)

    千次阅读 多人点赞 2022-03-29 08:19:34
    目录一、(Stack)什么是的常见方法一级目录一级目录 一、(Stack) 什么是其实就是一种数据结构 - 先进后出(先入栈的数据后出来,最先入栈的数据会被压入栈底) 什么是java虚拟机? java...
  • C语言实现队列

    2012-05-17 13:37:07
    用C实现的队列,可以加载使用。详见博文http://blog.csdn.net/pirateleo/article/details/7574598 共包含5个文件
  • 栈队列串数组

    2013-05-15 09:27:52
    栈队列串数组

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 360,119
精华内容 144,047
关键字:

栈 队列