C#数据结构回顾之顺序栈

顺序栈解析

一片连续的存储空间来存储栈中的数据元素，这样的栈称为顺序栈(Sequence Stack)。类似于顺序表，用一维数组来存放顺序栈中的数据元素。栈顶指示器top设在数组下标为0的端，top随着插入和删除而变化，当栈为空时，top=-1，即最基本的单元就是一个数组。栈这种结构的操作特点可以简记为“枪打出头鸟”，即所有的操作对象都是基于栈顶元素的，其实质也是top指针的变化。

接口定义

//定义栈的的接口
    public interface IStack<T>
    {
        int GetLength(); //求栈的长度
        bool IsEmpty(); //判断栈是否为空
        void Clear(); //清空操作
        void Push(T item); //入栈操作
        T Pop(); //出栈操作
        T GetTop(); //取栈顶元素
    }

顺序栈的实体类实现

一个关键的操作：

1. 访问(类似数组访问)：data[top]
2. 移动top指针：top–
   

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DataStructureLearning.Interface;

namespace DataStructureLearning.ImplementClass
{
    public class SequenceStack<T>:IStack<T>
    {
        #region 成员变量
        private int maxSize;//顺序栈的最大长度
        private int top;//栈顶
        private T[] data;//数组用于存储顺序栈的数据
        #endregion
        #region 索引器
        public T this[int index]
        {
            get
            {
                return data[index];
            }
            set
            {
                data[index] = value;
            }
        }
        #endregion
        #region 属性
        public int MaxSize
        {
            get
            {
                return maxSize;
            }
            set
            {
                maxSize = value;
            }
        }

        public int Top
        {
            get
            {
                return top;
            }
        }
        #endregion
        #region 构造方法
        public SequenceStack(int size)
        {
            data = new T[size];
            maxSize = size;
            top = -1;
        }
        #endregion
        #region 成员方法
        //获取栈的长度：由于数组是0基数组，即数组的最小索引为0，所以，顺序栈的长度就是数组中最后一个元素的索引top加1
        public int GetLength()
        {
            return top+1;
        }

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

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

        //判断是否已经满了
        public bool IsFull()
        {
            if (top == maxSize + 1)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        //向栈顶压入一个元素
        public void Push(T item)
        {
            if (IsFull() == true)
            {
                Console.WriteLine("该顺序栈已经满了！");
                return;
            }
            else
            {
                data[++top] = item;
            }
        }

        //出栈
        public T Pop()
        {
            T temp=default(T);
            if(IsEmpty()==true)
            {
                Console.WriteLine("该顺序栈为空！");
            }
            else
            {
                temp = data[top];
                --top;
            }
            return temp;
        }

        //取栈顶元素
        public T GetTop()
        {
            if (IsEmpty())
            {
            Console.WriteLine("该顺序栈为空");
            return default(T);
            }
            return data[top];
        }

        public void ShowItem()
        {
            while (top != -1)
            {
                Console.Write(data[top]+"\t");
                top--;
            }
        }
        #endregion
    }
}

顺序栈的简单测试：

SequenceStack<int> stack = new SequenceStack<int>(4);
stack.Push(3);
stack.Push(9);
//stack.Pop();
Console.WriteLine("遍历栈:");
stack.ShowItem();

小结：

1. 什么是所谓的栈是栈(Stack)是操作限定在表的尾端进行的线性表。表尾由于要进行插入、删除等操作，所以，它具有特殊的含义，把表尾称为栈顶（Top），另一端是固定的，叫栈底（Bottom） 。当栈中没有数据元素时叫空栈(Stack)。
2. 用一维数组来存放顺序栈中的数据元素。栈顶指示器top设在数组下标为0的端，top随着插入和删除而变化，当栈为空时，top=-1
3. 栈的所有操作的对象都是栈顶元素所有操作的实质都是栈顶指针的
4. 栈的特点先进后出（First in last out）。