最近看Unirx库的代码中,发现了这么个东西 PriorityQueue,优先级队列。用于线程调度的时候按照优先级执行任务。
搜了一下,实现原理是二叉树,规则是父节点比子节点小(小堆)。Enqueue的时候先添加到数组末尾,然后在树上不断的冒泡给新来的元素安排一个合适的位置,继续保持树的规则。Dequeue的时候,直接取顶点,将末尾值赋给顶点,然后在树上不断冒泡,调整数的结构。由于只要操作数的一边,时间复杂度O(log(n))。对于队列这种数据结构,这样用挺有效率的。
恰好我自己在写一个观察者模式,希望消息发送出去之后,接受者能以一定的优先级处理消息。于是马上想到把之前的List换成PriorityQueue。。。然而傻逼的发现,队列这种数据结构,一旦Dequeue,就没了,也就是说,我用错了这个东西,使得观察者变成了一次性观察者。。。。所以蛋疼的 写了个PriorityList。思路也跟这个一致,也是每次添加元素到最后面,然后跟前面的元素依次比较,安排个合适的位置,(prewave).实现比较简单.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Threading;
namespace HGame.Collection.Util
{
/// <summary>
/// 优先级列表,添加元素后自动排序,
///
/// </summary>
public class PriorityList<T> : IReadOnlyList<T> where T : IComparable<T>
{
private int _size;
private static int _count;
public int Count
{
get { return _size; }
}
private IndexedItem[] _items;
private int _capacity;
public PriorityList():this(4)
{
}
public PriorityList(int capacity)
{
_capacity = capacity;
_items = new IndexedItem[capacity];
_size = 0;
}
public PriorityList(IReadOnlyList<T> array)
{
_size = 0;
_capacity = array.Count;
_items = new IndexedItem[_capacity];
for (int i = 0; i < array.Count; i++)
{
Add(array[i]);
}
}
private bool IsHigherPriority(int left, int right)
{
return _items[left].CompareTo(_items[right]) < 0;
}
public void Add(T t)
{
if (_size >= _items.Length)
{
var temp = _items;
_items = new IndexedItem[_items.Length * 2];
Array.Copy(temp, _items, temp.Length);
}
var index = _size++;
_items[index] = new IndexedItem() {Value = t, Id = Interlocked.Increment(ref _count)};
Prewave(index);
}
private void Prewave(int index)
{
if (index <= 0 || index > _size - 1)
{
return;
}
var pre = index - 1;
if (IsHigherPriority(index, pre))
{
SwapSkipCheck(index, pre);
Prewave(pre);
}
}
private void SwapSkipCheck(int left, int right)
{
var temp = _items[left];
_items[left] = _items[right];
_items[right] = temp;
}
public bool Remove(T t)
{
for (int i = 0; i < _size; i++)
{
if (EqualityComparer<T>.Default.Equals(_items[i].Value, t))
{
RemoveAt(i);
return true;
}
}
return false;
}
public void RemoveAt(int index)
{
if (index < 0 || index > _size - 1)
{
throw new IndexOutOfRangeException();
}
if (index == _size - 1)
{
_items[index] = default(IndexedItem);
_size--;
}
else
{
for (int i = 0; i < _size; i++)
{
if (i >= index)
{
_items[i] = _items[i + 1];
}
}
_items[--_size ] = default(IndexedItem);
}
if (_size < _items.Length / 4)
{
var temp = _items;
_items = new IndexedItem[_items.Length / 2];
Array.Copy(temp, 0, _items, 0, _size);
}
}
struct IndexedItem : IComparable<IndexedItem>
{
public T Value;
public long Id;
public int CompareTo(IndexedItem other)
{
var c = Value.CompareTo(other.Value);
return c == 0 ? Id.CompareTo(other.Id) : c;
}
}
IEnumerator<T> IEnumerable<T>.GetEnumerator()
{
var index = -1;
while (++index < _size)
{
yield return _items[index].Value;
}
}
/// 使用yield 语法糖 ,比new一个实现IEnumerator的对象效率更高
public IEnumerator GetEnumerator()
{
var index = -1;
while (++index < _size)
{
yield return _items[index].Value;
}
}
public bool RemoveBy(Func<T, bool> func)
{
for (int i = 0; i < _size; i++)
{
if (func(_items[i].Value))
{
RemoveAt(i);
return true;
}
}
return false;
}
public T this[int index]
{
get
{
if (index < 0 || index > _size - 1) throw new IndexOutOfRangeException();
return _items[index].Value;
}
}
}
}