数据结构---队列

  interface IQueue<T>
    {
        int GetLength();
        bool IsEmpty();
        void Clear();
        void In(T item);
        T Out();
        T GetFront();
    }

  class Node<T>
    {
        private T data;
        private Node<T> next;

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

//线性队列

  class SeqQueue<T> : IQueue<T>
    {
        private T[] data;
        private int count;
        private int front;//头
        private int rear;//尾
        public int Count
        {
            get{ return count; }
        }
        public int Front
        {
            get{return front; }
        }
        public int Rear
        {
            get{return rear;}
        }
        public T this[int i]
        {
            get{ return data[i];}
        }
        public SeqQueue(int size)
        {
            data = new T[size];
            count = 0;
            front = rear = -1;
        }
        public void Clear()
        {
            count = 0;
            front = rear = -1;
             Array.Clear(data, 0, data.Length);
        }

        public T GetFront()
        {
            return data[front + 1];
        }

        public int GetLength()
        {
            return count;
        }
        public bool IsFull()
        {
            if (count == data.Length)
            {
                Console.WriteLine("Queue is full!");
                return true;
            }
            else
            {
                return false;
            }

        }
        public void In(T time)//添加
        {
            if (IsFull())
            {
                Console.WriteLine("Queue is Full!");
                return;
            }
            else
            {
                if (rear == data.Length - 1)
                {
                    data[0] = time;
                    rear = 0;
                    ++count;
                }
                else
                {
                    data[++rear] = time;                   
                    ++count;
                }
            }
        }

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

        public T Out()//删除
        {
            if (count > 0)
            {
                T temp = data[front + 1];

                if (front < data.Length - 2)
                {
                    ++front;
                }
                else
                {
                    front = -1;
                }
                count--;
                return temp;
            }
            else
            {
                Console.WriteLine("Queue is empty!");
                return default(T);
            }
        }
    }

//单链 队列

 class LinkQueue<T> : IQueue<T>
    {
       private  Node<T> front;
        private Node<T> rear;
        private int count;
        public int Count { get => count;}
        internal Node<T> Front { get => front; set => front = value; }
        internal Node<T> Rear { get => rear; set => rear = value; }
        public LinkQueue()
        {
            front = null;
            rear = null;
            count = 0;
        }
        public void Clear()
        {
            front = null;
            rear = null;
            count = 0;
        }

        public T GetFront()
        {
            if (IsEmpty())
            {
                return default(T);
            }
            return front.Data;
        }

        public int GetLength()
        {
            return count;
        }
        public T  this[int i]
        {
            get
            {
                Node<T> temp = front;
                for (int j = 0; j < i; ++j)
                {
                    temp = temp.Next;
                }
                return temp.Data;               
            }
        }
        public void In(T item)
        {
            Node<T> q = new Node<T>(item);
            if (IsEmpty ())
            {
                front = q;
                rear = q;
                ++count;
            }
            else
            {
                rear.Next = q;
                rear = q;
                ++count;
            }
        }

        public bool IsEmpty()
        {
            return front == null; 
        }

        public T Out()
        {
            if (IsEmpty())
            {
                Console.WriteLine("队列为空 ");
                return default(T); 
            }
            else if (count == 1)
            {
                T temp = front.Data;
                front = null;
                rear = null;
                count = 0;
                return temp;
            }
            else
            {
                T temp = front.Data;
                front = front.Next;
                --count;
                return temp;
            }
        }
    }