第八节：队列简介、手撸顺序队列、手撸链队列和队列的应用
一. 队列简介
1. 什么是队列
队列(Queue)只允许在一端进行插入，在另一端进行删除的线性表。（队尾入队，队头出队），可见队列具有先进先出(First In First Out)或后进后出( Last In Last Out)的特性。
C#中提供Queue队列类，它不是线程安全的； 如需要使用线程安全的队列类，则使用：ConcurrentQueue
2. 名词
队头（ Front）：队列中允许数据删除的那一端。
队尾（ Rear）：队列中允许数据插入的那一端。
队上溢（Full）：存储空间已满，仍希望入队操作，会产生上溢出，是一种空间不足的出错状态。
队下溢（Empty）：队内空间无数据，仍希望出队操作，会产生下溢出，是一种数据不足的出错状态。
空队列(Empty Queue)：队列中没有数据元素.
入队（Enqueue）：将一个数据插入到队尾的操作。
出队（Dequeue）：读取队头节点并删除该节点的操作
3. 常用Api
Enqueue()入队(放在队尾)
Dequeue()出队(移除队首元素，并返回被移除的元素)
Peek()取得队首的元素，不移除
Clear()清空元素
Count获取队列中元素的个数
测试代码：
{ Console.WriteLine("--------------C#提供的Queue---------------------"); Queue<int> s1 = new Queue<int>(); s1.Enqueue(1); s1.Enqueue(2); s1.Enqueue(3); s1.Enqueue(4); Console.WriteLine($"元素的个数为：{s1.Count}"); int p1 = s1.Dequeue(); //取出并删除 Console.WriteLine($"元素的个数为：{s1.Count},取出的数据为：{p1}"); int p2 = s1.Peek(); //取出不删除 Console.WriteLine($"元素的个数为：{s1.Count},取出的数据为：{p2}"); s1.Clear(); Console.WriteLine($"元素的个数为：{s1.Count}"); }
运行结果：
4. 分类
队列存储结构的实现有以下两种方式：
顺序队列：在顺序表的基础上实现的队列结构。
链队列：在链表的基础上实现的队列结构。
两者的区别仅是顺序表和链表的区别，即在实际的物理空间中，数据集中存储的队列是顺序队列，分散存储的队列是链队列。
二. 顺序队列
1. 顺序队列
顺序队列(Sequence Queue)用一片连续的存储空间来存储队列中的数据元素.用一维数组来存放顺序队列中的数据元素。队头位置设在数组下标为 0 的端，用 front 表示；队尾位置设在数组的另一端，用 tail 表示。 front 和 tail 随着插入和删除而变化。当队列为空时， front=tail=0。因为在出队列（删除元素）的时候，需要花费大量的时间移动大量元素，速度很慢，所以很少有实际应用.
2. 顺序循环队列
为了避免大量数据的移动，通常将一维数组的各个元素看成一个收尾相接的封闭的圆环，即第一个元素是最后一个元素的下一个元素，这种形式的顺序队列称为循环顺序队列(Circular sequence Queue)。
注：C#为我们提供的Queue类就是循环队列。
3. 手撸循环队列
接口
/// <summary> /// 声明队列接口 /// </summary> /// <typeparam name="T"></typeparam> public interface IQueue<T> { int Count { get; }//获取元素个数 bool IsEmpty(); //是否为空队列 void Clear(); //清空队列 void Enqueue(T item); //入队 T Dequeue(); //出队 T Peek(); //取队头元素 }
代码
/// <summary> /// 循环队列 /// </summary> /// <typeparam name="T"></typeparam> public class SeqQueue<T> : IQueue<T> { //存放元素的数组 public T[] _array; //增长因子 1-10之间 private int _growfactor; //最小增长值 private const int _MinimumGrow = 4; //默认队列空间的大小 private const int _defaultCapacity = 8; //元素的个数 private int _size = 0; //队头指针 指向队头的第一个元素 private int _head; //队尾指针 指向队尾的最后一个元素索引+1 private int _tail; public SeqQueue() : this(_defaultCapacity, 2) { } public SeqQueue(int capacity, float growFactor) { if (capacity < 0) { throw new ArgumentOutOfRangeException("capacity", "初识容量不能小于0"); } if (capacity < _defaultCapacity) { capacity = _defaultCapacity; } if (growFactor < 1.0 || growFactor > 10.0) { throw new ArgumentOutOfRangeException("growFactor", "增长因子必须在1-10之间"); } this._array = new T[capacity]; //初始化数组 this._head = this._tail = 0; this._size = 0; this._growfactor = (int)(growFactor * 100f); } //获取元素个数 public int Count { get { return this._size; } } public void Clear() { this._head = this._tail = this._size = 0; } //出队操作 public T Dequeue() { if (this._size == 0) { throw new InvalidOperationException("队列下溢，队里里没有数据"); } T obj = this._array[_head]; //出队数据 this._array[_head] = default(T); //在数组里删除出队元素 this._head = (this._head + 1) % this._array.Length; //循环队列 处理机制，保证下标是循环的 this._size--; return obj; } //入队 public void Enqueue(T item) { if (this._size == this._array.Length) { //计算新的容量 int capacity = (int)(this._array.Length * this._growfactor / 100f); if (capacity < this._array.Length + _MinimumGrow) { //最少要增长四个元素 capacity = this._array.Length + _MinimumGrow; } //调整容量 SetCapacity(capacity); } this._array[_tail] = item; //入队 this._tail = (this._tail + 1) % this._array.Length; //移动尾巴指针 this._size++; } private void SetCapacity(int capacity) { //内存搬家 T[] destinationArray = new T[capacity]; if (this._head < this._tail) { //头指针在尾指针的前面 Array.Copy(this._array, this._head, destinationArray, 0, this._size); } else { //头指针在尾指针的后面 Array.Copy(this._array, this._head, destinationArray, 0, this._array.Length - this._head); Array.Copy(this._array, 0, destinationArray, this._array.Length - this._head, this._tail); } this._array = destinationArray; this._head = 0; this._tail = (this._size == capacity) ? 0 : this._size; } public bool IsEmpty() { return this._size == 0; } //获取队头元素，不删除 public T Peek() { if (this._size == 0) { throw new InvalidOperationException("队列下溢，队里里没有数据"); } T obj = this._array[_head]; //出队数据 return obj; } }
测试
{ Console.WriteLine("--------------手撸循环队列---------------------"); IQueue<int> s1 = new SeqQueue<int>(); s1.Enqueue(1); s1.Enqueue(2); s1.Enqueue(3); s1.Enqueue(4); Console.WriteLine($"元素的个数为：{s1.Count}"); int p1 = s1.Dequeue(); //取出并删除 Console.WriteLine($"元素的个数为：{s1.Count},取出的数据为：{p1}"); int p2 = s1.Peek(); //取出不删除 Console.WriteLine($"元素的个数为：{s1.Count},取出的数据为：{p2}"); s1.Clear(); Console.WriteLine($"元素的个数为：{s1.Count}"); }
运行结果
三. 链队列
1. 含义
队列的另外一种存储方式是链式存储，这样的队列称为链队列(Linked Queue)。同链栈一样，链队列通常用单链表来表示，它的实现是单链表的简化。
2. 手撸链队列
接口
/// <summary> /// 声明队列接口 /// </summary> /// <typeparam name="T"></typeparam> public interface IQueue<T> { int Count { get; }//获取元素个数 bool IsEmpty(); //是否为空队列 void Clear(); //清空队列 void Enqueue(T item); //入队 T Dequeue(); //出队 T Peek(); //取队头元素 }
代码
/// <summary> /// 链队列 /// (队尾tail入队,队头front出队) /// </summary> /// <typeparam name="T"></typeparam> public class LinkedQueue<T> : IQueue<T> { public QueueNode<T> front; //队头节点 public QueueNode<T> tail; //队尾节点 public int count; //元素个数 public LinkedQueue() { Clear(); } public int Count { get { return count; } } /// <summary> /// 清空所有元素 /// </summary> public void Clear() { front = null; tail = null; count = 0; } /// <summary> /// 判空 /// </summary> /// <returns></returns> public bool IsEmpty() { return count == 0; } /// <summary> /// 出队(不删除元素) /// </summary> /// <returns></returns> public T Peek() { if (front == null) { throw new ArgumentOutOfRangeException("队列下溢,队列中没有元素"); } T data = front.data; return data; } /// <summary> /// 出队(删除元素) /// </summary> /// <returns></returns> public T Dequeue() { if (front == null) { throw new ArgumentOutOfRangeException("队列下溢,队列中没有元素"); } T data = front.data; if (count == 1) { front = null; tail = null; } else { front = front.next; } count--; return data; } /// <summary> /// 入队 /// </summary> /// <param name="item"></param> public void Enqueue(T item) { QueueNode<T> newNode = new QueueNode<T>(item); if (count == 0) { front = newNode; tail = newNode; } else { tail.next = newNode; tail = newNode; } count++; } }
测试
{ Console.WriteLine("--------------手撸链队列---------------------"); IQueue<int> s1 = new LinkedQueue<int>(); s1.Enqueue(1); s1.Enqueue(2); s1.Enqueue(3); s1.Enqueue(4); Console.WriteLine($"元素的个数为：{s1.Count}"); int p1 = s1.Dequeue(); //取出并删除 Console.WriteLine($"元素的个数为：{s1.Count},取出的数据为：{p1}"); int p2 = s1.Peek(); //取出不删除 Console.WriteLine($"元素的个数为：{s1.Count},取出的数据为：{p2}"); s1.Clear(); Console.WriteLine($"元素的个数为：{s1.Count}"); }
运行结果
四. 应用
1. 流量削峰
高并发场景，比如秒杀，可以把下单请求存放到队列中，然后消费者从队列中依次取出来进行实际下单业务。
2. 应用解耦(异步)
比如登录成功后，要增加积分或者发送邮件，可以引入消息队列进行解耦，异步处理增加积分 或者 发送邮件的请求。
!
- 作 者 : Yaopengfei(姚鹏飞)
- 博客地址 : http://www.cnblogs.com/yaopengfei/
- 声 明1 : 如有错误，欢迎讨论，请勿谩骂^_^。
- 声 明2 : 原创博客请在转载时保留原文链接或在文章开头加上本人博客地址，否则保留追究法律责任的权利。
