数据结构之栈

原创 已于 2022-03-24 16:27:34 修改 · 107 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#数据结构 #算法
于 2022-03-24 15:17:04 首次发布
本文详细介绍了栈和队列两种基本数据结构的定义，包括栈的后进先出特性以及顺序和链式存储结构的实现。通过示例展示了栈的操作，如进栈、出栈和查看栈顶元素。同时，文章提到了栈在浏览器历史记录、撤销/重做操作等场景中的应用，并对比了顺序栈和链式栈的区别。此外，还提供了链式栈的实现代码，包括插入和删除节点的方法。

栈与队列的定义

栈是限定仅在表尾进行插入和删除操作的线性表

栈(Stack)进行插入和删除的一端称为栈顶，另一端称为栈底，不含任何数据元素称为空栈，由此栈又称为后进先出(LIFO)结构。

进栈出栈变化形式：
栈对线性表的插入和删除的位置(空间)进行限制，但是并没有限制元素的进出的时间。

例如：依次输入3个整型元素1、2、3依次进栈，那么就会有5种排序方法
第一种：1、2、3进 然后3、2、1出 321
第二种：1进 1出 2进 2出 3进 3出 123
第三种：1进 1出 2进 2出 3进 3出 231
第四种：1进 2进 2出 1出 3进 3出 213
第五中： 1进 1出 2进 3进 3出 2出 132

栈的顺序存储结构
栈作为一个线性表，其顺序存储结构也就是线性表顺序存储的简化
创建类库，新建顺序栈

public class MySeqStack<T>//顺序栈
    {
    private MySeqList<T> list;

    public MySeqStack(int maxN)
    {
        list = new MySeqList<T>(maxN);
    }
    public void Push(T elem)
    {
        if (list.Length == list.Capacity)
            throw new OutOfMemoryException();
        list.Add(elem);
    }
    public void Pop()
    {
        if(list.Length==0)
            throw new OutOfMemoryException();
        list.delete(list.Length-1);
    }

    public T Peek()
    {
        return list[list.Length - 1];
    }
    }

引用类库中的顺序表

 public  class MySeqList<T>//顺序表
    {
        private T[] array;
        private int size=0;
        public MySeqList(int MaxN)
        {
            array = new T[MaxN];
           
        }
        public void Add(T elem)
        {
            if (size == array.Length)
            {
                throw new OutOfMemoryException();
            }
            array[size] = elem;
            size++;
        }
        public void insert(int index, T element)
        {
            if (index < 0 || index > size)
            {
                throw new IndexOutOfRangeException("超出数组实际元素范围！");
            }
            if (size >= array.Length)
            {
                resize();
            }
            for (int i = size - 1; i <= index; i--)
            {
                array[i + 1] = array[i];

            }
            array[index] = element;
            size++;
        }
        public void delete(int index)
        {
            if (index < 0 || index >= size)
            {
                throw new IndexOutOfRangeException("超出数组实际元素范围");
            }

            for (int i = index; i < size - 1; i++)
            {
                array[i] = array[i + 1];
            }
            size--;

        }
        public void print()
        {
            for (int i = 0; i < array.Length; i++)
            {
                Console.WriteLine(array[i]);
            }
        }
        public void resize()
        {
            T[] arrayNew = new T[array.Length * 2];
            System.Array.Copy(array, 0, arrayNew, 0, array.Length);
            array = arrayNew;
        }

    public int Length
    {
        get { return size; }
    }
    public int Capacity//容量
    {
        get { return array.Length; }
    }
    public int IndexOf(T elem)
    {
        for (int i = 0; i < size; i++)
        {
            if (array[i].Equals(elem))
            {
                return i;
            }
        }
        return -1;
    }
    public T GetAt(int i)
    {
        if (i < 0 || i >= size)
            throw new IndexOutOfRangeException();
        return array[i];
    }
    public void SetAt(int i, T elem)
    {
        if (i < 0 || i >= size)
        {
            throw new IndexOutOfRangeException();
        }
        array[i] = elem;
    }
    public T this[int i]
    {
        get
        {
            return GetAt(i);
        }
        set
        {
            SetAt(i, value);
        }
    }
    }

新建MySeqStack类，并引用类库

static void Main(String[] args)
        {
            MySeqStack<string> ss = new MySeqStack<string>(3);
            ss.Push("第一个元素");
            ss.Push("第二个元素");
            ss.Push("第三个元素");
            try
            {
                ss.Push("第四个元素");
                Debug.Assert(false, "栈满应抛异常");
            }
            catch(OutOfMemoryException e)
            { }
            ss.Pop();
            ss.Pop();
            ss.Pop();
            try
            {
                ss.Pop();
                Debug.Assert(false, "栈空应抛异常");
            }
            catch (OutOfMemoryException e)
            { }

            Console.WriteLine( ss.Peek());
           

            Console.ReadLine();
            
        }

栈的链式存储结构

class Node<T>
    {
        public T data;
        public Node<T> next;
      
    }

    class MyLinkedList<T>//链栈
    {
        private Node<T> head;
        private Node<T> last;
        private int size;
      

        public void Insert(int index ,T data)
        {
            if (index < 0)
                throw new IndexOutOfRangeException("数组越界");
            Node<T> insertedNode = new Node<T>();
            insertedNode.data = data;
            if (size == 0)
            {
                head = insertedNode;
            }
            else if (index == 0)
            {
                insertedNode.next = head;
                head = insertedNode;
            }
            else if (size == index)
            {
                last.next = insertedNode;
                last = insertedNode;
            }
            else
            {
                int cnt = 0;
                for (Node<T> p = head; p != null; p = p.next)
                {
                    if (cnt == index - 1)
                    {
                        insertedNode.next = p.next;
                        p.next = insertedNode;
                        return;
                    }
                }



            }

            size++;
           
        }
        public void Delete(int index)
        {
            if (index < 0 || index >= size)
            {
                throw new IndexOutOfRangeException("超出链表范围");
            }

            if (index == 0)
            {
                head = head.next;
            }
            else if (index == size - 1)
            {
                int cnt = 0;
                for (Node<T> p = head; p != null; p = p.next)
                {
                    if (cnt == index - 1)
                    {
                        p.next = null;
                        return;
                    }
                    cnt++;
                }
            }
            else
            {
                int cnt = 0;
                for (Node<T> p = head; p != null; p = p.next)
                {
                    if (cnt == index - 1)
                    {
                        p.next = p.next.next;
                        return;

                    }
                    cnt++;
                }
            }
            size--;
        }
        public void print()
        {
            for (Node<T> p = head; p != null; p = p.next)
            {
                Console.WriteLine(p.data);
            }
        }
        public T GetAt(int i)
        {
            if (i < 0)
                throw new IndexOutOfRangeException();

            int cnt = 0;
            for (Node<T> p = head; p != null; p = p.next)
            {
                if (cnt == i)
                {
                    return p.data;
                }cnt++;
            }
            throw new OutOfMemoryException();

        }
        public bool IsEmpty
        {
            get
            {
                return head == null;
            }
        }
    }

class MyLinkedStack<T>
{
    private MyLinkedList<T> list = new MyLinkedList<T>();

    public void Push(T elem)
    {
        list.Insert(0, elem);
    }
    public void Pop()
    {
        if (list.IsEmpty)
            throw new OutOfMemoryException();
        list.Delete(0);
    }

    public T Peek()
    {
        return list.GetAt(0);
    }
}

class Program
    {
        static void Main(String[] args)
        {
            MySeqStack<string> ss = new MySeqStack<string>(3);
            ss.Push("第一个元素");
            ss.Push("第二个元素");
            ss.Push("第三个元素");
          
            ss.Pop();
            ss.Pop();
        

            Console.WriteLine(ss.Peek());

            Console.ReadLine();

        }
    }

和顺序栈的区别
只有栈空没有栈满
对于链栈来说，是不需要头结点的
由于单链表有头指针，而栈顶指针也是必须的，将头指针域栈顶指针合并起来。所以要在头部进行插入与删除

栈的应用
1、浏览器进行、后退的历史记录
2、用户编辑文档是的Undo/Redo操作
3、字符串逆序
4、游戏菜单层级打开关闭
5、递归
6、四则运算表达式求值

【数据结构】栈是什么？从0理解栈的数据结构
XuanRan的博客
11-14 4432
在数据结构的学习中，栈是一种非常重要的结构。无论你是否是计算机专业，栈的概念其实并不复杂。本篇文章将帮助你从零理解栈的数据结构，了解它的基本用途、实际应用以及如何在C++中实现栈操作。
数据结构 栈
syshrgjdkdh的博客
08-10 2215
摘要 栈是一种后进先出（LIFO）的线性数据结构，仅允许在栈顶进行插入（push）和删除（pop）操作。其核心特性包括：仅操作栈顶、不支持随机访问、默认基于deque实现。栈的提出源于1950年代鲍尔团队对逆波兰表达式计算和函数调用机制的研究，现广泛应用于程序调用栈、表达式求值、括号匹配等场景。C++中可通过STL的std::stack或手动数组实现栈操作，基本功能包括压栈、弹栈、判空等。例题B3758展示了栈在括号匹配中的典型应用——通过栈统计未匹配括号数量，动态补全成合法序列。栈的高效性使其成为算法和系
【数据结构】栈的详解
fighting小泽的博客
05-17 3410
栈的结构体其实和顺序表差不多，一个动态开辟的数组，一个栈的容量。注意 top 我们要决定它指向栈顶还是栈顶的下一个元素。如果top初始化为0，则它指向栈顶的下一个元素。如果top初始化为-1，则它指向栈顶元素。我比较喜欢初始化为0，1是top还可以表示元素的个数，可以用来判断栈是否满了。2是插入元素的时候直接在top的位置插入就行，然后再top++即可。这里根据大家喜好设定就行。int top;} ST;
数据结构之——栈
WenJieya的博客
03-27 7478
数据结构之——栈 一：栈的定义： 栈是限定是限定仅在表位进行插入和删除操作的线性表，栈又称为先进后出（Last In First Out）的线性表，简称LIFO结构。 栈顶：允许插入和删除的一端称为栈顶。 栈底：不可以进行插入和删除操作。 空栈：不含任何数据元素的栈称为空栈。 理解栈的定义需要注意几点： 1：它是一个线性表，即说明栈元素具有 线性关系，即 前驱后继 关系。只不 过它是一种特殊的线性表而已。 2：定义中说在线性表的表的表尾进行插入和删除操作，注意这里表尾指的是
数据结构-栈及栈的应用
初始化的博客
07-19 5090
栈的概述 栈式一种重要的线性结构，属于一种操作受限的线性表 栈(stack) 是限定尽在表尾进行插入或删除操作的线性表 表尾端称为栈顶(top)，表头端称为栈底(bottom) 栈的元素先进后出(后进先出)，即最先进入栈的元素最后出栈 ...
栈—数据结构
weixin_63722559的博客
09-06 1384
6、获取栈顶元素（获取栈顶元素，在外面开一个空间，将该空间的地址传过去，进行获取元素，以便于区分元素还是返回值）入栈的方向是是增栈的方式，放入数据的是满栈的方式。入栈的方向是是减栈的方式，放入数据的是满栈的方式。入栈的方向是是增栈的方式，放入数据的是空栈的方式。入栈的方向是是减栈的方式，放入数据的是空栈的方式。3、出栈（看一下，出去的元素，所以和6一样）1、入栈：先放入输入，再移动栈顶指针。2、出栈：先移动栈顶指针，再数据弹出。1、入栈：先挪栈顶指针，再放入数据。2、出栈：先移出数据，再移动指针。
数据结构——————栈
m0_66847953的博客
10-03 1358
栈（Stack）是一种特殊的线性数据结构，其插入和删除操作都只允许在表的一端进行。这一端被称为栈顶（top），另一端则被称为栈底（bottom）。栈遵循后进先出（Last In First Out，LIFO）的规则，即最后存入的元素将被最先取出。顺序栈采用一个数组存放栈中的元素。如果需要用到两个类型相同的栈，这时若为它们各自开辟一个数组空间,极有可能出现这样的情况：第一个栈已满,再进栈就溢出了，而另一个栈还有很多空闲的存储空间。解决这个问题的方法是。
数据结构——栈
2401_88326089的博客
06-22 1097
本文介绍了栈的基本概念和两种实现方式：顺序栈和链栈。主要操作包括压栈(插入)和出栈(删除)。顺序栈采用数组实现，具有高效尾部操作的优势；链栈则使用链表结构实现。最后通过一道有效的括号匹配算法题展示了栈的实际应用。理解栈的实现原理有助于掌握更复杂的数据结构，并为算法学习打下基础。
【数据结构】栈
Kaisir777的博客
12-14 857
什么是栈？栈：一种特殊的线性表其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端 称为栈顶，另一端称为栈底。栈顶 栈底是什么，线性表又是什么？栈顶与栈底是不固定的，取决于你想在哪边操作。拿顺序表举例，若只在表尾增删，那表尾就是栈顶，相对的表头就是栈底。压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。出栈：栈的删除操作叫做出栈，出数据也在栈顶。因为栈一般是存储在堆上的，故栈的大小可以看作无穷大（取决于你的机器）。【数据结构】初阶——顺序表①为什么说栈是受限制的。
栈数据结构
Jeffxu_lib的博客
08-27 2430
栈是一种先进后出的数据结构，可以分为：顺序栈和链式栈 一、顺序栈 1、其结构如下图所示： 2、栈的基本操作，只有如下的五个 push( ) 入栈 pop( ) 出栈 empty( ) 是否为空 top( ) 返回栈顶元素 size( ) 返回栈中元素个数 swap() 交换 #include<iostream> #include<stack> ...
【数据结构】栈和队列——栈
最新发布
m0_72516377的博客
08-24 946
本文介绍了栈和队列的基本概念与实现方式。主要内容包括： 栈的定义与特点：受限线性表，遵循先进后出(FILO)原则，仅允许在栈顶进行插入(push)和删除(pop)操作。 栈的存储结构：顺序栈(数组实现)和链式栈(链表实现)，分析各自优缺点。 顺序栈的实现细节：包括静态和动态两种方式，重点说明栈顶指针的两种不同定义方式及其操作差异。 栈的基本操作：详细讲解入栈(Push)操作的实现逻辑，包括栈满判断、元素放置和指针更新等关键步骤。 文章通过代码示例展示了顺序栈的初始化、入栈和出栈操作，并特别强调了动态顺序栈的
＜数据结构＞——栈
m0_65759588的博客
04-12 1971
📚参考资料：《数据结构C语言版》-严蔚敏 一、栈 首先，我们了解一下什么是栈？ 栈是限定仅在表尾进行插入或删除操作的线性表。 表尾为栈顶，表头为栈底，不含元素的空表称为空栈。 例如， 洗干净的盘子总是逐个往上叠放在已经洗好的盘子上面 ， 而用时从上往下逐个取用 还有一些案例也利用了栈： 括号的检验 我们来看这些括号，给它们标号为1-4，当出现1和2时，我们更想要先出现3，再出现4。而由于1与3配对，2与4配对，所以我们其实对于2的需求感强于对1的需求感。 1先进...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值