数据结构系列：链栈[C#][第二部分]

首先，提供一个接口，里面写好方法，甚至跟上次的顺序栈可以是一样的，不过我换了个解决方案，于是就重新制作了一个。

namespace 链栈
{
     
    interface StackDS<T>
    {
     //不写那么多了
        int Count {
      get; }  //获得数据的数量,属性？//迷惑
        int Size {
      get; }

        int GetLength();//获得长度
        bool isEmpty();//是否为空
        void Clear();//清空
        void Push(T item);//入站

        T Pop();//返回值是我们要准备出栈的元素
        T Peek();//获得栈顶的元素
        T[] Travel();   
    }
}

做完之后，就是链栈与顺序栈最大的差别，
总所周知，我们顺序栈是按照数组来存储的，本身就有index序号
但是我们现在的链栈，是通过每一个结点连着其前面的结点，
而后面新的结点又连着他，如此循环而生成，
最后一个结点则是我们的头结点（因为方便取出，我们该放在头）

下面是Node 结点类的生成

//概念是， 创造一个新的类型
//他具有
1.存储数据的能力
2.指向前面的那个结点（里面也有元素跟同样的指向）

   class Node<T>
    {
     
        private T data;//数据
        private Node<T> next;//连接之前的数据的结点

        public Node()
        {
     
            data = default(T);
            next = null;
        }
        public Node(T data)
        {
     
            this.data = data;
            next = null;
        }
        public Node(T data,Node<T> next)
        {
     
            this.data = data;
            this.next = next;
        }
        public Node(Node<T> next)
        {
     
            this.next = next;
        }
        
       public  T Data {
      get {
      return data; } set {
      data = value; } }
       public Node<T> Next
        {
     
            get {
      return next; }
            set {
      next = value; }
        }

    }
}

紧接着，利用这一个类，跟一个接口，我们直接生成我们的class 链表

//1.首先实现 接口中的方法
//2.将结点制作出来， 称为栈顶结点 （top）
//3.制作count，方便遍历，你懂的

namespace 链栈
{
     
    class LinkStack<T> : StackDS<T>
    {
     //持有一个头结点

        private Node<T> top;//栈顶元素的结点  //寻找头
        private int count = 0;//栈中元素的个数//用来遍历

        public int Count
        {
     
            get
            {
     
                return count;
            }
        }
        
        public void Clear()
        {
     
            count = 0;
            top = null;
        }

        //返回元素的个数，不可改变
        public int GetLength()
        {
     
            return count;
        }

        public bool isEmpty()
        {
     
          return  count == 0;
        }

        public T Peek()
        {
     
            return top.Data;//只取得数据
        }

        public T Pop()//同push
        {
     
            T data = top.Data;//需要返回的栈顶的数据
            top = top.Next;//原来的栈顶变回了栈顶
            count--;
            return data;
        }

        public void Push(T item)//这段是最困难的
        {
     
            //创建第一个 结点， 然后作为新的头结点
            //第二步，指向原来的结点
            //第三步，top现在有了新的结点。
            Node<T> newNode = new Node<T>(item);//创造一个新结点
            newNode.Next = top;//之前的头为现在的下一个
            top = newNode;     //现在为目前的头结点
            count++;

        }

        public T[] Travel()
        {
     //我其实有想尝试自己在里面遍历，但是意义不是很大可能
            throw new NotImplementedException();
        }
    }
}

最后，我们的链栈就实现了，然后在主程序中运行一下。

 class Program
    {
     
        static void Main(string[] args)
        {
     

            LinkStack<int> linkStack = new LinkStack<int>();
            linkStack.Push(1);
            linkStack.Push(2);
            linkStack.Push(3);

            int a = linkStack.Pop();
            linkStack.Pop();//这里又少了一个元素。
            Console.WriteLine(a);
            Console.WriteLine(linkStack.Count);

            linkStack.Clear();
            bool b = linkStack.isEmpty();
            Console.WriteLine(b);
            Console.WriteLine(linkStack.Count);
            Console.ReadKey();

        }
    }

那么栈就到一段落了，说实话，从这个链栈中，
我已经大概能自己实现链表跟顺序表了，期待自己的努力，
一定要加油，一定要进游戏公司。