算法：基于 RingBuffer 的 Queue 实现《续》

背景

上篇实现了一个简单的队列，内部使用了 _count 计数，本文采用另外一种模式，不用 _count 计数。

RingBuffer

不用 _count 计数的话，为了区分队列的满和空，需要在数组中预留一格，如下图就代表了一个满队列。

ArrayQueue

代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DataStuctureStudy.Queues
{
    public class ArrayQueue2<T>
    {
        private readonly int _maxSize;
        private readonly T[] _items;
        private int _header = 0;
        private int _tail = -1;

        public ArrayQueue2(int size)
        {
            _maxSize = size + 1;
            _items = new T[_maxSize];
        }

        public void EnQueue(T item)
        {
            if (this.IsFull())
            {
                throw new InvalidOperationException("队列已满");
            }

            if (_tail == _maxSize - 1)
            {
                _tail = -1;
            }

            _items[++_tail] = item;
        }

        public T DeQueue()
        {
            if (this.IsEmpty())
            {
                throw new InvalidOperationException("队列已空");
            }

            T item = _items[_header++];

            if (_header == _maxSize)
            {
                _header = 0;
            }

            return item;
        }

        public T Peek()
        {
            if (this.IsEmpty())
            {
                throw new InvalidOperationException("队列已空");
            }

            return _items[_header];
        }

        public bool IsFull()
        {
            return
               (_header + _maxSize - 2 == _tail)
               ||
               (_tail + 2 == _header);
        }

        public bool IsEmpty()
        {
            return
               (_tail + 1 == _header)
               ||
               (_header == 0 && _tail == _maxSize - 1);
        }

        public int Size()
        {
            if (_tail >= _header)
            {
                return _tail - _header + 1;
            }
            else
            {
                return (_maxSize - _header) + (_tail + 1);
            }
        }
    }
}

测试

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DataStuctureStudy
{
    class Program
    {
        static void Main(string[] args)
        {
            var queue = new Queues.ArrayQueue2<int>(5);

            queue.EnQueue(1);
            queue.EnQueue(2);
            queue.EnQueue(3);
            queue.EnQueue(4);
            queue.EnQueue(5);
            Console.WriteLine(queue.Size());
            while (!queue.IsEmpty())
            {
                Console.WriteLine(queue.DeQueue());
            }

            queue.EnQueue(1);
            queue.EnQueue(2);
            queue.EnQueue(3);
            queue.EnQueue(4);
            queue.EnQueue(5);
            Console.WriteLine(queue.Size());
            while (!queue.IsEmpty())
            {
                Console.WriteLine(queue.DeQueue());
            }
        }
    }
}