三、栈

一、栈（Stack）：

1、定义：是限定仅在表尾进行插入和删除的线性表。（后进先出）
  允许插入和删除的一端称为栈顶（top），另一端称为（bottom）
  不含任何数据元素的栈称为空栈，栈又称后进先出（Last in first out）
  的线性表，简称LIFO结构.
  栈的插入操作，叫做进栈，也称压栈，入栈。
  栈的删除操作，叫做出栈，也有叫做弹栈。
  公共接口

  internal interface IStack<T>
   {
   void Push(T item);
   T Pop();
   T GetTop();
   int GetLength();
   bool IsEmpty();
   void Clear();
   }

Stack 类
  public class Stack : IEnumerable, ICollection, Ienumerable
  • 属性
  Count　　获取 Stack 中包含的元素个数
  • 方法
  Pop 　　移除并返回在 Stack 的顶部的对象
  push　　向 Stack 的顶部添加一个对象
  peek　　返回在 Stack 的顶部的对象，但不移除它
  ToArray　　创建数组并将堆栈元素复制到其中
  Contains 　　判断一个元素是否在栈中
  Clear　　从 Stack 中移除所有的元素。
  
  2、栈的顺序储存结构（顺序栈）
  
  C#实现

  public class SequenceStack<T> : IStack<T>
   {
   //栈的容量
   //用于存储栈中数据元素
   private readonly T[] stackData;
   private int stackSize;
   //栈顶元素index
   private int stackTop;
  
   /// <summary>
   /// 构造函数 初始化一个顺序栈 给定存储空间 栈元素为空
   /// </summary>
   /// <param name="size"></param>
   public SequenceStack(int size)
   {
   this.stackData = new T[size];
   this.stackSize = size;
   this.stackTop = -1;
   }
  
  
   public T this[int index]
   {
   get { return this.stackData[index]; }
   set { this.stackData[index] = value; }
   }
  
  
   public int StackSize
   {
   get { return this.stackSize; }
   set { this.stackSize = value; }
   }
  
   public int StackTop
   {
   get { return this.stackTop; }
   }
  
   public int GetLength()
   {
   return this.stackTop + 1;
   }
  
   public void Clear()
   {
   this.stackTop = -1;
   }
  
  
   public bool IsEmpty()
   {
   if (this.stackTop == -1)
   {
   return true;
   }
   return false;
   }
  
   public void Push(T value)
   {
   if (this.IsFull())
   {
   Console.WriteLine("Stack is Full!(SB 栈都满了还往里怼！)");
   }
   this.stackData[++this.stackTop] = value;
   }
  
   public T Pop()
   {
   T value = default(T);
   if (this.IsEmpty())
   {
   Console.WriteLine("Stack is Empty!(si bu si sa 都没了取个鸡毛！)");
   return default(T);
   }
   value = this.stackData[this.stackTop];
   --this.stackTop;
   return value;
   }
  
   public T GetTop()
   {
   if (this.IsEmpty())
   {
   Console.WriteLine("Stack is Empty !(si bu si sa 都没了取个鸡毛！)");
   return default(T);
   }
  
   return this.stackData[this.stackTop];
   }
  
   public bool IsFull()
   {
   if (this.stackTop == this.stackSize - 1)
   {
   return true;
   }
   return false;
   }
   }
  

3、栈的链式储存结构（链栈）
  链栈节点  LinkStackNode：

  public class LinkStackNode<T>
   {
   //数据域
   //引用域
  
   public LinkStackNode()
   {
   this.Data = default(T);
   this.Next = null;
   }
  
   public LinkStackNode(T val)
   {
   this.Data = val;
   this.Next = null;
   }
  
   public LinkStackNode(T val, LinkStackNode<T> p)
   {
   this.Data = val;
   this.Next = p;
   }
  
   //数据域属性
   public T Data { get; set; }
  
   //引用域属性
   public LinkStackNode<T> Next { get; set; }
   }

———————————————————————————

  链栈实现：
  public class LinkStack<T> : IStack<T>
   {
   private LinkStackNode<T> top; //栈顶指示器
   private int size; //栈中元素的个数
  
   //栈顶指示器属性
   public LinkStackNode<T> Top
   {
   get { return top; }
   set { top = value; }
   }
  
   //元素个数属性
   public int Size
   {
   get { return size; }
   set { size = value; }
   }
  
   public LinkStack()
   {
   top = null;
   size = 0;
   }
  
  
   //判断链栈是否为空
   public bool IsEmpty()
   {
   if ((top == null) && (size == 0))
   return true;
   else
   return false;
   }
  
  
   public int GetLength()
   {
   return size;
   }
  
   public void Clear()
   {
   top = null;
   size = 0;
   }
  
   //入栈操作
   //在单链表的起始处插入一个结点
   public void Push(T item)
   {
   LinkStackNode<T> q = new LinkStackNode<T>(item);
   if (top == null)
   {
   top = q;
   }
   else
   {
   //将新结点的next指向栈顶指示器top所指向的结点
   q.Next = top;
   //将栈顶指示器top指向新结点
   top = q;
   }
   ++size;
   }
  
   //出栈操作
   public T Pop()
   {
   if (IsEmpty())
   {
   Console.WriteLine("Stack is empty !");
   return default(T);
   }
   LinkStackNode<T> p = top;
   top = top.Next;
   --size;
   return p.Data;
   }
  
   //获取栈顶结点的值
   public T GetTop()
   {
   if (IsEmpty())
   {
   Console.WriteLine("Stack is empty !");
   return default(T);
   }
   return top.Data;
   }
  
   }

使用：
   //顺序栈
   // SequenceStack myStack = new SequenceStack(5);
   // myStack.Push(0);
   // myStack.Push(13);
   // myStack.Push(5);
   // myStack.Push(9);
   // myStack.Push(100);
   //while (!myStack.isEmpty())
   // {
   // Console.WriteLine(myStack.GetTop());
   // myStack.Pop();
   // }
   // Console.ReadLine();
   //链栈
   LinkStack myStack = new LinkStack();
   myStack.Push(0);
   myStack.Push(13);
   myStack.Push(5);
   myStack.Push(9);
   myStack.Push(100);
   while (!myStack.isEmpty())
   {
   Console.WriteLine(myStack.GetTop());
   myStack.Pop();
   }
   Console.ReadLine();