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

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

顺序队列和链队列实现

1、通用接口实现如下：

namespace 手撕数据结构之线性表.顺序队列及链队列
{
    /// <summary>
    /// 通用接口
    /// </summary>
    /// <typeparam name="T"></typeparam>
    interface IQueue<T>
    {
        void Enqueue(T item);
        T Dequeue();
        T Peek();
        int Count { get; }
        int GetLength();
        void Clear();
        bool IsEmpty();
    }
}

2、顺序队列实现类如下：

namespace 手撕数据结构之线性表.顺序队列
{
    class SeqQueue<T> : IQueue<T>
    {
        private T[] datas; //数据存储
        private int length; //队列中元素的个数
        private int front; //队首元素的索引（-1表示队列为空）
        private int tail; //队尾元素的索引

        public SeqQueue(int size) //构造函数初始化
        {
            datas = new T[size];
            length = 0;
            front = -1;
            tail = -1;
        }

        public SeqQueue() : this(100) //初始化队列大小为100
        {

        }

        /// <summary>
        /// 队列元素个数
        /// </summary>
        public int Count
        {
            get { return length;}
        }

        /// <summary>
        /// 入队
        /// </summary>
        /// <param name="item"></param>
        public void Enqueue(T item)
        {
            if (length == datas.Length)
            {
                Console.WriteLine("队列已满!");
            }
            else
            {
                if (tail == datas.Length - 1)
                {
                    tail = -1; //重置队尾索引，使其指向队列的开头
                }

                tail++;
                datas[tail] = item;
                length++;
            }
        }

        /// <summary>
        /// 出队（删除队首元素）
        /// </summary>
        /// <returns></returns>
        public T Dequeue()
        {
            if (length > 0)
            {
                front++;
                if (front == datas.Length - 1)
                {
                    front = -1; //重置队首索引，使其指向队列开头
                }

                T temp = datas[front];
                length--;
                return temp;
            }
            else
            {
                Console.WriteLine("队列为空!");
                return default(T);
            }
        }

        /// <summary>
        /// 出队（不删除队首元素）
        /// </summary>
        /// <returns></returns>
        public T Peek()
        {
            if (length > 0)
            {
                int index = front + 1;
                if (index == datas.Length)
                {
                    index = 0;
                }

                T temp = datas[index];
                return temp;
            }
            else
            {
                Console.WriteLine("队列为空!");
                return default(T);
            }
        }

        /// <summary>
        /// 清空队列
        /// </summary>
        public void Clear()
        {
            length = 0;
            front = -1;
            tail = -1;
        }

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

        /// <summary>
        /// 判断队列是否为空
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            return length == 0;
        }
    }
}

测试代码：

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

            queue.Enqueue("abc");
            queue.Enqueue("123");
            queue.Enqueue("23456");
            Console.WriteLine("队中元素个数:" + queue.Count);
            Console.WriteLine(queue.Dequeue());
            Console.WriteLine("队中元素个数:" + queue.Count);
            queue.Clear();
            Console.WriteLine("队中元素个数:" + queue.Count);
        }
    }
}

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 LinkQueue<T> : IQueue<T>
    {
        private Node<T> front; //头节点
        private Node<T> tail; //尾节点
        private int length; //元素个数

        public LinkQueue() //构造函数初始化
        {
            front = null;
            tail = null;
            length = 0;
        }

        /// <summary>
        /// 元素个数
        /// </summary>
        public int Count
        {
            get { return length; }
        }

        /// <summary>
        /// 入队
        /// </summary>
        /// <param name="item"></param>
        public void Enqueue(T item)
        {
            Node<T> newNode = new Node<T>(item);
            if (length == 0) //当前队列为空的时候
            {
                front = newNode;
                tail = newNode;
                length = 1;
            }
            else
            {
                tail.Next = newNode;
                tail = newNode;
                length++;
            }
        }

        /// <summary>
        /// 出队（删除队首元素）
        /// </summary>
        /// <returns></returns>
        public T Dequeue()
        {
            T temp = default(T);
            if (IsEmpty())
            {
                Console.WriteLine("队列为空！");
                return temp;
            }
            else if (length == 1) //当前只有一个数据
            {
                temp = front.Data;
                front = tail = null;
                length = 0;
                return temp;
            }
            else
            {
                temp = front.Data;
                front = front.Next;
                length--;
                return temp;
            }
        }

        /// <summary>
        /// 出队（不删除队首元素）
        /// </summary>
        /// <returns></returns>
        public T Peek()
        {
            if (front != null)
                return front.Data;
            else
                return default(T);
        }

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

        /// <summary>
        /// 清空队列
        /// </summary>
        public void Clear()
        {
            front = null;
            tail = null;
            length = 0;
        }

        /// <summary>
        /// 判断队列是否为空
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            return length == 0;
        }
    }
}

测试代码：

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

             queue.Enqueue("abc");
             queue.Enqueue("123");
             queue.Enqueue("23456");
             Console.WriteLine("队中元素个数:" + queue.Count);
             Console.WriteLine(queue.Dequeue());
             Console.WriteLine("队中元素个数:" + queue.Count);
             queue.Clear();
             Console.WriteLine("队中元素个数:" + queue.Count);
        }
    }
}