C#实现数据结构-线性表（二）

本文章纯属个人练习笔记，如有错误欢迎纠正。

顺序栈和链栈实现

1、通用接口实现如下：

namespace 手撕数据结构之线性表.顺序栈及链栈
{
    /// <summary>
    /// 通用接口
    /// </summary>
    /// <typeparam name="T"></typeparam>
    interface IStack<T>
    {
        void Push(T item);
        T Pop();
        T Peek();
        int GetLength();
        void Clear();
        bool isEmpty();
    }
}

2、顺序栈实现类如下：

namespace 手撕数据结构之线性表.顺序栈
{
    /// <summary>
    /// 顺序栈
    /// </summary>
    /// <typeparam name="T"></typeparam>
    class SeqStack<T> : IStack<T>
    {
        private T[] datas; //数据存储
        private int top; //栈顶索引

        public SeqStack(int size) //构造函数初始化栈大小
        {
            datas = new T[size];
            top = -1;
        }

        public SeqStack() : this(100) //默认大小为100
        {

        }

        /// <summary>
        /// 栈元素个数
        /// </summary>
        public int Length
        {
            get { return top + 1; }
        }

        /// <summary>
        /// 入栈
        /// </summary>
        /// <param name="item"></param>
        public void Push(T item)
        {
            datas[top + 1] = item;
            top++;
        }

        /// <summary>
        /// 出栈（删除栈顶元素）
        /// </summary>
        /// <returns></returns>
        public T Pop()
        {
            if (isEmpty())
            {
                Console.WriteLine("栈为空！");
                return default(T);
            }
            T temp = datas[top];
            top--;
            return temp;
        }

        /// <summary>
        /// 出栈（不删除栈顶元素）
        /// </summary>
        /// <returns></returns>
        public T Peek()
        {
            if (isEmpty())
            {
                Console.WriteLine("栈为空！");
                return default(T);
            }
            return datas[top];
        }

        /// <summary>
        /// 获取栈元素个数
        /// </summary>
        /// <returns></returns>
        public int GetLength()
        {
            return Length;
        }

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

        /// <summary>
        /// 判断栈是否为空
        /// </summary>
        /// <returns></returns>
        public bool isEmpty()
        {
            return Length == 0;
        }
    }
}

测试代码：

namespace 手撕数据结构之线性表.顺序栈及链栈
{
    class Program
    {
        static void Main(string[] args)
        {
            SeqStack<string> stack = new SeqStack<string>();

            stack.Push("abc");
            stack.Push("asdas");
            stack.Push("1dasd");

            Console.WriteLine("栈中数据个数为:" + stack.GetLength());
            Console.WriteLine("栈顶元素为:" + stack.Pop());
            Console.WriteLine("栈顶元素为:" + stack.Peek());
            stack.Clear();
            Console.WriteLine("栈中数据个数为:" + stack.GetLength());
        }
    }
}

 

3、链栈实现如下：

链栈节点类：

namespace 手撕数据结构之线性表.链栈
{
    /// <summary>
    /// 链栈的节点类
    /// </summary>
    /// <typeparam name="T"></typeparam>
    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(Node<T> next)
        {
            data = default(T);
            this.next = next;
        }

        public Node(T data, Node<T> next)
        {
            this.data = data;
            this.next = next;
        }

        public T Data
        {
            get { return data; }
            set { data = value; }
        }

        public Node<T> Next
        {
            get { return next;}
            set { next = value; }
        }
    }
}

链栈实现类：

namespace 手撕数据结构之线性表.链栈
{
    /// <summary>
    /// 链栈
    /// </summary>
    /// <typeparam name="T"></typeparam>
    class LinkStack<T> : IStack<T>
    {
        private Node<T> top; //栈顶节点（头节点）
        private int length; //栈长

        /// <summary>
        /// 入栈
        /// </summary>
        /// <param name="item"></param>
        public void Push(T item)
        {
            Node<T> newNode = new Node<T>(item);
            newNode.Next = top;
            top = newNode;
            length++;
        }

        /// <summary>
        /// 出栈（删除栈顶元素）
        /// </summary>
        /// <returns></returns>
        public T Pop()
        {
            if (isEmpty())
            {
                Console.WriteLine("栈为空!");
                return default(T);
            }
            T data = top.Data;
            top = top.Next;
            length--;
            return data;
        }

        /// <summary>
        /// 出栈（不删除栈顶元素）
        /// </summary>
        /// <returns></returns>
        public T Peek()
        {
            if (isEmpty())
            {
                Console.WriteLine("栈为空!");
                return default(T);
            }
            return top.Data;
        }

        public int GetLength()
        {
            return length;
        }

        public void Clear()
        {
            top = null;
            length = 0;
        }

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

测试代码：

namespace 手撕数据结构之线性表.顺序栈及链栈
{
    class Program
    {
        static void Main(string[] args)
        {
            LinkStack<string> stack = new LinkStack<string>();

            stack.Push("abc");
            stack.Push("asdas");
            stack.Push("1dasd");

            Console.WriteLine("栈中数据个数为:" + stack.GetLength());
            Console.WriteLine("栈顶元素为:" + stack.Pop());
            Console.WriteLine("栈顶元素为:" + stack.Peek());
            stack.Clear();
            Console.WriteLine("栈中数据个数为:" + stack.GetLength());
        }
    }
}