• 数据结构复习--栈和队列(1)--栈


    1.栈和队列简介:

    栈和队列是非常重要的两种数据结构,在软件设计中应用很多。栈和队列也是线性结构,线性表,栈和队列这三种数据元素和数据元素间的逻辑完全相同。差别是线性表的操作不受限制,而栈和队列的操作收到限制,栈的操作只能在表的一端进行,队列的插入操作在表的一端进行而其它操作在表的另一端进行,所以把栈和队列称为操作受限的线性表

    栈:

    栈(Stack)是操作限定在表的尾端进行的线性表。表尾由于要进行插入,删除等操作,所以,它具有特殊含义,把表尾成为栈顶(Top),另一端是固定的,叫栈底(Bottom)。当栈中没有数据元素时叫空栈(Empty Stack)。

    栈通常记为S=(a1,a2,......an),a1为栈底元素,an为栈订元素,这n个数据元素按照a1,a2,......an的顺序依次入栈,而出栈的顺序相反,an第一个出栈,a1最后一个出栈。所以,栈的操作是按照后进先出(Last In First Out)或先进后出(First In Last Out)。栈操作示意图:

     C#2.0中提供了泛型的Stack<T>类,用来进行栈的操作。

    常用方法:

    1.Push()  入栈,添加数据

    2.Pop()  出栈,删除数据并返回被删除的数据

    3.Peek()取得栈订的数据,不删除

    4.Clear()清空所有的数据

    4.Count 取得栈中数据的个数

    2.顺序栈:

    用一片连续的存储空间来存储栈中的数据元素,这样的栈成为顺序栈<Sequence Stack>,类似于顺序表,用以为数组来存放栈中的数据元素。栈顶指示器top设在数组下标为0的一端,top随插入和删除而变化,当栈顶为空时,top=-1 示意图:

     c#实现顺序栈:

     public class SeqStack<T> : IStackDS<T>
        {
            /// <summary>
            /// 存放元素
            /// </summary>
            private T[] Data;
            /// <summary>
            /// 指向栈顶索引
            /// </summary>
            private int top;
            /// <summary>
            /// 构造函数
            /// </summary>
            /// <param name="size">长度</param>
            public SeqStack(int size)
            {
                Data = new T[size];
                top = -1;
            }
            /// <summary>
            /// 默认构造函数
            /// </summary>
            public SeqStack() : this(10)
            {
    
            }
            /// <summary>
            /// 获取元素数量
            /// </summary>
            public int Count { get { return top + 1; } }
            /// <summary>
            /// 清空
            /// </summary>
            public void Clear()
            {
                top = -1;
            }
            /// <summary>
            /// 获取长度
            /// </summary>
            /// <returns></returns>
            public int GetLength()
            {
                return Count;
            }
            /// <summary>
            /// 是否为空
            /// </summary>
            /// <returns></returns>
            public bool IsEmpty()
            {
                return Count == 0;
            }
            /// <summary>
            /// 获取栈顶元素
            /// </summary>
            /// <returns></returns>
            public T Peek()
            {
                return Data[top];
            }
            /// <summary>
            /// 出栈
            /// </summary>
            /// <returns></returns>
            public T Pop()
            {
                T temp = Data[top];
                top--;
                return temp;
            }
            /// <summary>
            /// 入栈
            /// </summary>
            /// <param name="item"></param>
            public void Push(T item)
            {
                Data[top + 1] = item;
                top++;
            }
        }
    View Code

    3.链栈:

     栈的另外一种存储方式是链式存储,这样的栈成为链栈(Linked Stack)。链栈通常用单链表来表示,它的实现是单链表的简化。所以链栈的结点结构与单链表一样。由于链栈的操作只在一端进行,为了操作方便,把栈顶设在链表的头部,并且不需要头结点。

    c#实现链栈:

     class LinkStack<T> : IStackDS<T>
        {
            /// <summary>
            /// 栈顶元素结点
            /// </summary>
            private Node<T> top;
            /// <summary>
            /// 栈中元素个数
            /// </summary>
            private int count = 0;
            /// <summary>
            /// 取得栈中元素个数
            /// </summary>
            public int Count { get { return count; } }
            /// <summary>
            /// 清空栈中数据
            /// </summary>
            public void Clear()
            {
                count = 0;
                top = null;
            }
            /// <summary>
            /// 取得栈中元素个数
            /// </summary>
            /// <returns></returns>
            public int GetLength() => count;
            /// <summary>
            /// 是否为空
            /// </summary>
            /// <returns></returns>
            public bool IsEmpty() => count == 0;
           
            /// <summary>
            /// 取得栈顶元素数据 不删除栈顶
            /// </summary>
            /// <returns></returns>
            public T Peek()
            {
                return top.Data;
            }
            /// <summary>
            /// 出栈
            /// </summary>
            /// <returns></returns>
            public T Pop()
            {
                //取得栈顶元素,删除
                T data = top.Data;
                top = top.Next;
                count--;
                return data;
            }
            /// <summary>
            /// 入栈
            /// </summary>
            /// <param name="item"></param>
            public void Push(T item)
            {
                //把新添加的元素作为栈顶
                Node<T> newNode = new Node<T>(item);
                newNode.Next = top;
                top = newNode;
                count++;
            }
        }
    View Code

     结点类:

    public class Node<T>
        {
            /// <summary>
            /// 存放数据
            /// </summary>
            private T data;
            /// <summary>
            /// 下一个结点
            /// </summary>
            private Node<T> next;
    
            #region 构造函数
            public Node()
            {
                data = default(T);
                next = null;
            }
            public Node(T data)
            {
                this.data = data;
                next = null;
            }
            public Node(T _data,Node<T> _next)
            {
                data = _data;
                next = _next;
            }
            public Node(Node<T> _next)
            {
                data = default(T);
                next = _next;
            }
            #endregion
    
            public T Data { get => data; set => data = value; }
            public Node<T> Next { get => next; set => next = value; }
        }
    View Code
  • 相关阅读:
    求最大子数组02
    求最大子数组
    第3周学习进度
    四则运算3
    第2周学习进度
    构建之法阅读笔记02
    四则运算2及单元测试
    四则运算1
    第1周学习进度
    构建之法阅读笔记01
  • 原文地址:https://www.cnblogs.com/quebra/p/10247315.html
Copyright © 2020-2023  润新知