栈和队列，及其低层实现

最新推荐文章于 2022-07-07 17:18:37 发布
最新推荐文章于 2022-07-07 17:18:37 发布
阅读量385 收藏 1
点赞数
分类专栏： 算法 文章标签： 队列 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a15970673567/article/details/113349001
版权

一.栈

1）栈的概念：栈是操作限定在表的尾端进行的线性表。表尾由于要进行插入、删除等操作，所以，它具有特殊的含义，把表尾称为栈顶，另一端是固定的，叫栈底。当栈中没有数据元素时叫作空栈。
2）栈的特点：先进后出
3）栈的好处：单纯从功能上讲，数组或者链表可以替代栈。它们的操作过于灵活，，当数据量很大的时候就会出现一些隐藏的风险。虽然栈限定降低了操作的灵活性，但这也使得栈在处理只涉及一端新增和删除数据的问题时效率更高，更不容易出错。

1. 顺序栈

(1)顺序栈的概念:用一片连续的存储空间来存储栈中的数据元素(使用数组)，这样的栈称为顺序栈。类似于顺序表，用一维数组来存放顺序栈中的数据元素。栈顶指示器 top 设在数组下标为 0 的端， top 随着插入和删除而变化，当栈为空时，top=-1。下图是顺序栈的栈顶指示器 top 与栈中数据元素的关系图。

在这里插入图片描述

(2)顺序栈的实现：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 栈和队列
{
    /// <summary>
    /// 顺序栈
    /// </summary>
    /// <typeparam name="T"></typeparam>
    class StackSelf<T>
    {
        //  int Count { get; }//栈中元素的个数
        //void Push(T item); //入栈操作
        //T Pop(); //出栈操作
        //T Peek(); //取栈顶元素
        //bool IsEmpty(); //判断栈是否为空
        // void Clear(); //清空操作

        private int top;
        private T[] stack;
        public int Count { get => top + 1; }
       
        public int Capacity { get => stack.Length; }//容量，用于扩容
        public StackSelf()
        {
            stack = new T[4];
            top = -1;
        }
        public StackSelf(int size)
        {
            stack = new T[size];
            top = -1;
        }
        public void Push(T item) //入栈操作
        {
            //扩容
            if (Count == Capacity)
            {
                T[] newstack = new T[Count * 2];
                Array.Copy(stack, newstack, Count);
                stack = newstack;
            }
           
                stack[top+1] = item;
                top++;
            

        }
        public T Pop() //出栈操作
        {
            if (top == -1)
            {
                throw new Exception("现为空栈");
            }
            top--;
            return stack[top + 1];
        }

        public T Peek()//取栈顶元素
        {
          return stack[top];
        }

        public bool IsEmpty() //判断栈是否为空
        {
            if (top==-1)
            {
                return true;
            }
            return false;
        }

        public void Clear()//清空操作
        {
            top = -1;
        }
    }
}

链栈

(1)链栈通常用单链表来表示，它的实现是单链表的简化。栈顶放在单链表头部，即不需要头指针，使用head指针代替。增加与删除操作在头部即head指向处进行。
(2)在链栈中进行删除操作时，只能在栈顶进行操作。因此，将栈顶的head指针指向栈顶节点(head)的next指针即可完成删除。具体操作可看代码实现

节点代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 栈和队列
{
    /// <summary>
    /// 节点类
    /// </summary>
    /// <typeparam name="T"></typeparam>
    class StackNode<T>
    {
        private T data;
        private StackNode<T> next;

        public StackNode()
        {
            Data = default(T);
            Next = null;
        }
        public StackNode(T item)
        {
            Data = item;
            Next = null;

        }
        public T Data { get => data; set => data = value; }
        internal StackNode<T> Next { get => next; set => next = value; }
    }
}

链栈代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 栈和队列
{
    /// <summary>
    /// 链栈
    /// </summary>
    /// <typeparam name="T"></typeparam>
    class ChainStackSelf<T>
    {
        //  int Count { get; }//栈中元素的个数
        //void Push(T item); //入栈操作
        //T Pop(); //出栈操作
        //T Peek(); //取栈顶元素
        //bool IsEmpty(); //判断栈是否为空
        // void Clear(); //清空操作

        private StackNode<T> top;//栈顶元素节点
        private int count;
        public int Count { get => count;}

        public ChainStackSelf()
        {
            top = null;
            count = 0;
        }

       public void Push(T item) //入栈操作
        {
            StackNode<T> node = new StackNode<T>(item);
            if (top==null)
            {            
                top = node;
            }
            else
            {//让新节点指向原顶部节点，然后在把新节点的位置赋予给新结点，
             //如此top永远是顶部节点，后续操作访问栈顶就很方便

                node.Next = top;
                top = node;
            }
            count++;
        }

        public T Pop() //出栈操作
        {
            if (count==0)
            {
                throw new Exception("现为空栈");
            }

            T data = top.Data;
            top = top.Next;
            count--;
            return data;
        }

        public T Peek()//取栈顶元素
        {
            return top.Data;
        }

        public bool IsEmpty() //判断栈是否为空
        {
            
            return Count==0;
        }

        public void Clear()//清空操作
        {
            top = null;
            count = 0;
        }
    }
}

栈的应用：递归，进制转换，匹配，表达式求值等

二．队列

1）队列的基本概念：队列是插入操作限定在表的尾部而其它操作限定在表的头部进行的线性表。把进行插入操作的表尾称为队尾，把进行其它操作的头部称为队头。当队列中没有数据元素时称为空队列

2）队列的特点：先进先出
3）队列的好处：与栈类似，只是两者的特点不同

1 顺序队列

顺序队列的概念：用一片连续的存储空间来存储队列中的数据元素，这样的队列称为顺序队列。类似于顺序栈，用一维数组来存放顺序队列中的数据元素。队头位置设在数组下标为 0 的端，用 front 表示；队尾位置设在数组的另一端，用 rear 表示。 front 和 rear 随着插入和删除而变化。当队列为空时， front=rear=-1。
在这里插入图片描述
特殊的，如图（d）如果此时再有一个数据元素入队就会出现溢出。但事实上队列中并未满，还有空闲空间，把这种现象称为“假溢出”。解决办法就是把它看成一个首尾相连的循环队列，也就是当队尾（rear)到达数组顶部时但队列中的元素还未饱和，此时添加元素，则把队尾(rear)重新归置为-1，再进行入队操作，但使用这种方法顺序队列就失去了自动扩容功能，具体实现看代码。

顺序队列的实现

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 队列
{
    /// <summary>
    /// 顺序队列
    /// </summary>
    /// <typeparam name="T"></typeparam>
    class QueueSelf<T>
    {
        private T[] data;
        private int head;//队头
        private int tail;//队尾
        private int count;//队列的元素个数
        public int Count { get => count; }

        public QueueSelf()
        {
            data = new T[4];
            head = -1;
            tail = -1;
            count = 0;
        }

        public QueueSelf(int size)
        {
            data = new T[size];
            head = -1;
            tail = -1;
            count = 0;
        }
       
        //        int Count { get; }//取得队列长度的属性
        //        void Enqueue(T item); //入队
        //        T Dequque(); //出队
        //        T Peek(); //取队头元素
        //        bool IsEmpty(); //判断对列是否为空
        //        void Clear(); //清空队列

        public void Enqueue(T item) //入队
         {
            if (Count == data.Length)
            {
                throw new Exception("队列已满");
            }
            else
            {
                //如果队尾已经到达数组顶端，队列中元素还未满
                则说明存在假溢出现象需要特殊处理
                if (tail == data.Length - 1)
                {
                    tail = -1;
                    data[tail + 1] = item;
                    tail++;
                }
                else
                {
                    data[tail + 1] = item;
                    tail++;
    
                }
                count++;
            }
        }

        public T Dequque() //出队
        {
            if (Count==0)
            {
                throw new Exception("队列为空");
            }
            else
            {
                //如果队头到达数组顶部，队列的元素个数Count还不为零，
                //则说明存在假溢出现象需要特殊处理
                if (head == data.Length - 1&&Count!=data.Length)
                {
                    head = -1;
                }
                T temp = data[head + 1];
                head++;
                count--;
                return temp;
            }
        }

        public T Peek() //取队头元素
        {
            if (Count == 0)
            {
                throw new Exception("队列为空");
            }
            else
            {
                //如果队头到达数组顶部，队列的元素个数Count还不为零，
                //则说明存在假溢出现象需要特殊处理
                if (head == data.Length - 1 && Count != data.Length)
                {
                    head = -1;
                }
                T temp = data[head + 1];              
                return temp;
            }

        }

        public bool IsEmpty() //判断对列是否为空
        {

            return Count == 0;
        }

        public void Clear() //清空队列
        {
            head = -1;
            tail = -1;
            count = 0;
        }
    }
}

链式队列

链式队列的概念：链式队列就是一个单链表，由于链队列的操作只是在一端进行，为了操作方便，把队头设在链表的头部，并且不需要头结点。

新增操作:链式队列进行新增数据操作时，将拥有数值item的新结点 newnode 赋值给原队尾结点的后继，即 tail.next。然后把当前的newnode 设置为队尾结点，指针 tail指向 newnode 。如下图所示：

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

删除操作:只需要让头结点指向要删除结点的后继，特殊的删除最后一个节点需要队头和队尾指针置空。具体操作看代码实现。

链式队列的实现：

节点实现：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 队列
{
    class Node<T>
    {
        T data;
        Node<T> next;
        
        public T Data { get => data; set => data = value; }
        internal Node<T> Next { get => next; set => next = value; }

        public Node(T item)
        {
            data = item;
            next = null;
        }
    }
}

链队列实现：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 队列
{
    class ChainQueue<T>
    {
     
        private Node<T> head;//队头
        private Node<T> tail;//队尾
        private int count;//队列的元素个数
        public int Count { get => count; }

        public ChainQueue()
        {
           
            head = null;
            tail = null;
            count = 0;
        }


        //        int Count { get; }//取得队列长度的属性
        //        void Enqueue(T item); //入队
        //        T Dequque(); //出队
        //        T Peek(); //取队头元素
        //        bool IsEmpty(); //判断对列是否为空
        //        void Clear(); //清空队列

        public void Enqueue(T item) //入队
        {

            Node<T> newnode = new Node<T>(item);
            if (Count==0)
            {
                head = newnode;
                tail = newnode;
              
            }
           
            else
            {
                tail.Next = newnode;
                tail = newnode;
            }
            count++;
        }

        public T Dequque() //出队
        {
            if (Count == 0)
            {
                throw new Exception("队列为空");
            }
            else if (Count == 1)
            {

                T temp = head.Data;
                head = null;
                tail = null;
                count--;
                return temp;
            }
            else
            {
                T temp = head.Data;
                head = head.Next;
                count--;
                return temp;
            }
        }

        public T Peek() //取队头元素
        {
            if (Count == 0)
            {
                throw new Exception("队列为空");
            }
           
            else
            {
                             
                return head.Data;
            }

        }

        public bool IsEmpty() //判断对列是否为空
        {

            return Count == 0;
        }

        public void Clear() //清空队列
        {
            head =null;
            tail = null;
            count = 0;
        }

    }
}
_不动明王
关注
专栏目录
栈和队列的底层实现及迷宫问题
星星爱奋斗
10-22 6152
一：栈 1.栈的应用背景          栈是一种线性数据结构，并且只能在某一端存数据和取数据。 关键词：先进先出。 2.栈的两种实现方法： 2.1用ArrayList实现栈 具体代码如下： import java.util.ArrayList; public class ArrayListAsStack { ArrayList stack = new ArrayList(
栈和队列的应用大全
weixin_46503238的博客
05-22 1778
应用一:栈在括号匹配中的应用 #include <stdio.h> #include <stdlib.h> #include<stdbool.h> #define MaxSize 50 typedef char ElemType; typedef struct { ElemType data[MaxSize]; int top; } SqStack; bool InitStack(SqStack *s) { s->top=-1;//初
栈和队列的对比和实现
wang_xiang_long的博客
06-28 435
栈和队列对比 栈(Stack):限定只能在表的一端进行插入和删除操作的线性表. 队列(Queue):是限定只能在表的一端进行插入,另一端删除操作的线性表. 不同之处在于队列先进先出,栈先进后出. 栈的实现 方法一(数组实现) class Stack: #定义栈 def __init__(self): self.stack=[] self.size=0 def __str__(self):#转化为字符串方便打印 return str(self.
队列与栈
weixin_34408717的博客
07-03 92
1.队列先进先出，栈先进后出。 2. 对插入和删除操作的"限定"。 栈是限定只能在表的一端进行插入和删除操作的线性表。 队列是限定只能在表的一端进行插入和在另一端进行删除操作的线性表。 从"数据结构"的角度看，它们都是线性结构，即数据元素之间的关系相同。但它们是完全不同的数据类型。除了它们各自的基本操作集不同外，主要区别是对插入和删除操作的"限定"。 栈和队列...
栈内存和队列的底层演示
li1019865596的博客
04-06 1920
栈内存和队列的底层原理演示
栈和队列的底层数组实现
zwz2011303359的博客
03-17 1223
public class MyStack { private int[] arr; //栈点 private int top; //构造方法 public MyStack(){ arr=new int[20]; top=-1; } public MyStack(int maxsize){ arr=new int[maxsize]; top=-1; } //
第 栈和队列PPT学习教案.pptx
10-10
递归可以通过模拟栈操作来实现，每个函数调用都会在栈上创建一个新的层，保存局部变量和返回地址。当递归调用结束时，通过回溯栈顶元素，程序返回到之前的调用点。递归可用于解决各种问题，如树的遍历、分治策略等。...
数据结构——栈和队列
FREEDOM’s blog
07-07 888
1.栈 2. 队列 3.特殊矩阵的压缩存储
栈、队列及其应用---迷宫问题
qq_40389988的博客
03-12 2586
一、需求分析 1、输入的形式和输入值的范围本程序需要三组输入，分别是迷宫的行数、列数，最后把迷宫的值作为一个二维数组进行输入，根据提示输入起点坐标(sx,sy)和终点坐标(ex,ey),输入的类型均是正整数。 2、输出的形式求得的通路以三元组(i,j,d)的形式输出，其中：(i,j)指示迷宫中的一个坐标，d表示走到下一坐标的方向。结果显示为迷宫的一条通路（i1,j1,d1）,(i2,j2,d2),...
栈、队列以及二叉树的实现
11-24
在计算机科学领域，数据结构是编程的基础，其中栈（Stack）、队列（Queue）和二叉树（Binary Tree）是三种基本且重要的概念。这些数据结构各有特点，用途广泛，对于理解和解决各种算法问题至关重要。 栈是一种...
数据结构—队列与栈的相互实现以及相互比较
weixin_56438185的博客
04-09 1359
目录 一、队列实现栈 二、用栈实现队列 三、队列与栈的相互比较 一、队列实现栈 LeetCode题目链接：用队列实现栈 题目描述： 声明：下面再用队列实现栈的过程中，使用的实现队列功能的函数，在之前的文章中有详细记录 文章链接：数据结构—队列的C语言实现 1、定义用队列实现栈的结构体 typedef struct { Queue q1; Queue q2; } MyStack; 2、创建栈 动态开辟一个用队列实现栈的结构体空间，然后再调用队列的初始化函数，.
栈和队列的对比
weixin_41440777的博客
12-15 2177
1.栈和队列的区别 栈是先进先出的数据结构中，有PUSH和POP两种操作，PUSH是把元素压入栈顶，POP是吧元素从栈顶弹出，TOP取栈顶元素。 栈是限定只能在表的一端进行插入和删除操作的线性表。 队列是限定只能在表的一端进行插入和在另一端进行删除操作的线性表。 从"数据结构"的角度看，它们都是线性结构，即数据元素之间的关系相同。但它们是完全不同的数据类型。除了它们各自的基本操作集不同外，主要...
栈和队列的底层实现-Java描述
小小本科生
07-14 1113
栈和队列的两种底层实现一：双向链表实现1.栈2.队列二：数组实现1.栈2.队列 一：双向链表实现 双向链表实现可以从头部进，头部出，以及尾部进，尾部出的结构 public static class Node<T> { public T value; public Node<T> last; public Node<T> next; public Node(T value) {
【数据结构 Java 版】详解栈和队列的实现
吞吞吐吐大魔王的博客
10-24 6506
文章目录1. 栈1.1 概念1.2 助解图题1.3 栈的数组实现1.4 问题1.5 栈的单链表实现2. 队列2.1 概念2.2 问题2.3 队列的单链表实现2.4 数组实现队列2.5 循环队列2.6 双端队列3. 栈和队列练习题3.1 有效的括号3.2 用队列实现栈3.3 用栈实现队列3.4 实现一个最小栈3.5 设计循环队列 1. 栈 1.1 概念 栈：是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。 特点：栈中的数据元素遵循先进后出的原则，但要注意进的同时也可以出，元素不是要全部进展
数据结构之栈和队列
qq_54178958的博客
11-09 289
之前讲解了顺序表、单向无头链表、双向无头链表。现在我们介绍一种新的数据结构，栈和队列。它们存储数据的方式是在我们之前学习的数组和链表的基础之上的。
了解栈和队列，以及实现
qq_44442895的博客
01-19 124
栈和队列 功能受限的表结构：对表结构加以限制、形成特殊的表结构 栈： 只有一个出入口的表结构，先进后出 FILO(栈的缩写：First In Last Out) ​ 空增栈： top初始值：0 入栈 top++ ​ 满增栈： top初始值：-1 ++top 入栈 ​ 满减栈： top初始值：cal-1 出栈 top– ​ 空减栈： top初始值：cal top-- 出栈 ​ 顺序栈： ​ 数据项： ​ 存储元素的内存首地址 ​ 栈的容量 ​ 栈定位置 ​ 运算： ​ 创建、销毁、栈空、入
Java实现简单的栈和队列(底层基于数组)
wxx17353227396的博客
06-11 428
栈：LIFO（后进先出） 队列：FIFO（先进先出） 栈的顺序存储结构实现-Java // 栈 public class MyStack { // 底层实现是一个数组 private long[] arr; private int top; // 默认的构造方法 public MyStack() { arr = new long[10]; top = -1; } // ...
c语言底层数组的方式实现栈和队列
nchensiwei的博客
02-18 650
c语言底层用双向链表的方式实现栈和队列比较容易，这里分享下c语言底层数组的方式实现栈和队列，栈结构的实现比较简单，队列的实现可以巧妙的利用一个size记录队列的有效大小和两个入队出队位置变量，另外还有一个跳转下一个有效位置函数比较巧妙，代码如下： #include<stdio.h> #include<stdlib.h> #define stacksizelimit 10 //实现栈的数组固定长度 #define queuesizelimit 10 //实现队列的数组固定长度
栈和队列原理
qq_43697646的博客
01-24 769
栈和队列是STL库里面的两个数据结构。STL有多个版本，知道STL的具体版本才能知道对应的栈和队列的实现原理。 三个常见的STL版本： （1）HP STL HP STL是C++ STL的第一个实现版本，而且开放源代码，其他版本的C++ STL一般是以HP STL为蓝本实现的。 （2）P.J.Plauger STL 由P.J.Plauger参照HP STL实现，被被Visual C++编译器所采用，不是开源的。 （3）SGI STL 由Silicon Graphics Computer Syst
栈和队列详解：共享存储单元的双栈实现
"本文介绍了如何使用一组地址连续的存储单元构建两个共享栈，以及栈和队列的基本概念和操作。" 在计算机科学中，栈和队列是两种重要的数据结构，它们都属于线性表的范畴。线性表允许在任意位置进行插入和删除操作，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值