C#数据结构之优先队列

        实现了数据结构中的优先队列，目前只实现了主体功能，对于CLONE及线程安全的支持还没有加入，如果有时间会完善的。
        思路如下：一个类为优先队列中的项（叫做PQItem），包含一个优先级和一个OBJECT的对象；主体类为PQueue，提供了类常用的方法。代码如下：

    优先队列的一个ITEM类#region 优先队列的一个ITEM类
    /**//// <summary>
    /// 优先队列的一个ITEM
    /// </summary>
    public class PQItem
    ...{
    公用的方法#region 公用的方法

        初始化方法#region 初始化方法
        public PQItem() : this(-1, null) ...{}

        public PQItem(int priority) : this(priority, null)...{}

        public PQItem(object o) : this(-1, o) ...{}

        public PQItem(int priority, object o)
        ...{
            Priority = priority;
            Obj = o;
        }
        #endregion 初始化方法

        重载ToString方法#region 重载ToString方法
        /**//// <summary>
        /// 重载ToString方法
        /// </summary>
        /// <returns>OBJECT的string</returns>
        public override string ToString()
        ...{
            return this.Obj.ToString();
        }
        #endregion 重载ToString方法
         
    #endregion 公用的方法

    公用的属性#region 公用的属性
        /**//// <summary>
        /// 一个ITEM的优先级，值越小，级别越高，小于0表示未指定优先级
        /// </summary>
        public int Priority
        ...{
            get
            ...{
                return priority;
            }
            set 
            ...{
                priority = value;
            }
        }

        /**//// <summary>
        /// 一个ITEM中包含的数据对象
        /// </summary>
        public object Obj
        ...{
            get
            ...{
                return o;
            }
            set
            ...{
                o = (value == null) ? o : value;
            }
        }
    #endregion 公用的属性

    私用的字段#region 私用的字段
        /**//// <summary>
        /// 一个ITEM的优先级，值越小，级别越高，小于0表示未指定优先级
        /// </summary>
        private int priority;

        /**//// <summary>
        /// 一个ITEM中包含的数据对象
        /// </summary>
        private object o;
    #endregion 私有的字段    
    }
    #endregion 优先队列的一个ITEM类

主体代码：

    /**//// <summary>
    /// PQueue 对数据结构优先队列的实现。
    /// </summary>
    public class PQueue : System.Collections.ICollection
    ...{
    公用的方法#region 公用的方法

        初始化方法#region 初始化方法
        /**//// <summary>
        /// 空的初始化方法
        /// </summary>
        public PQueue()
        ...{
            this.innerList = new ArrayList();
        }        

        /**//// <summary>
        /// 根据一个COLLECTION接口来初始化一个实例
        /// </summary>
        /// <param name="c"></param>
        public PQueue(ICollection c)
        ...{
            this.innerList = new ArrayList(c);
        }

        /**//// <summary>
        /// 初始化PQ并指定其最大容量
        /// </summary>
        /// <param name="capacity"></param>
        public PQueue(int capacity)
        ...{
            this.innerList = new ArrayList(capacity);
            this.maxCount = capacity;            
        }
        #endregion 初始化方法

        从 PQueue 中移除所有对象#region 从 PQueue 中移除所有对象
        /**//// <summary>
        /// 从 PQueue 中移除所有对象
        /// </summary>
        public void Clear()
        ...{
            this.innerList.Clear();
        }
        #endregion 从 PQueue 中移除所有对象

        确定某元素是否在 PQueue 中#region 确定某元素是否在 PQueue 中
        /**//// <summary>
        /// 确定某元素是否在 PQueue 中。
        /// </summary>
        /// <param name="item">要在 pQueue 中定位的项。</param>
        /// <returns>如果在 PQueue 中找到 obj，则为 true；否则为 false。</returns>
        public bool Contains(PQItem item)
        ...{
            return this.innerList.Contains(item);    
        }
        #endregion 确定某元素是否在 PQueue 中

        移除并返回位于 PQueue 开始处的对象#region 移除并返回位于 PQueue 开始处的对象
        /**//// <summary>
        /// 移除并返回位于 PQueue 开始处的对象
        /// </summary>
        /// <returns>从 PQueue 的开头移除的对象</returns>
        public PQItem Dequeue()
        ...{
            if (this.count > 0)
            ...{
                PQItem item = this.innerList[0] as PQItem;
                this.innerList.RemoveAt(0);
                this.count--;
                return item;
            }
            else
            ...{
                return null;
            }
        }
        #endregion 移除并返回位于 PQueue 开始处的对象

        将一个元素添加到队列中#region 将一个元素添加到队列中
        /**//// <summary>
        /// 将一个元素添加到队列中
        /// </summary>
        /// <param name="item">要加入的元素</param>
        public void Enqueue(PQItem item)
        ...{
            try
            ...{
                this.innerList.Add(item);
                if (this.innerList.Count > 1)
                ...{
                    object tmp = new object();
                    for (int i = this.innerList.Count - 2; i >= 0; i--)
                    ...{
                        PQItem curr = this.innerList[i + 1] as PQItem;
                        PQItem pre = this.innerList[i] as PQItem;
                        if (curr.Priority < pre.Priority)
                        ...{
                            tmp = this.innerList[i + 1];
                            this.innerList[i + 1] = this.innerList[i];
                            this.innerList[i] = tmp;
                        }
                        else
                        ...{
                            break;
                        }
                    }
                }
                this.count++;
            }
            catch(System.Exception e)
            ...{
                throw(e);        
            }
        }
        #endregion 将一个元素添加到队列中

        返回位于 PQueue 开始处的对象但不将其移除#region 返回位于 PQueue 开始处的对象但不将其移除
        /**//// <summary>
        /// 返回位于 PQueue 开始处的对象但不将其移除
        /// </summary>
        /// <returns>位于 PQueue 的开头的对象</returns>
        public PQItem Peek()
        ...{
            if (this.count > 0)
            ...{
                return this.innerList[0] as PQItem;
            }
            else
            ...{
                return null;
            }
        }
        #endregion 返回位于 PQueue 开始处的对象但不将其移除

        返回表示当前 PQItem 的 String#region 返回表示当前 PQItem 的 String
        /**//// <summary>
        /// 返回表示当前 PQItem 的 String
        /// </summary>
        /// <returns>当前的PQItem</returns>
        public override string ToString()
        ...{
            return this.innerList[0].ToString();
        }
        #endregion 返回表示当前 PQItem 的 String

        从特定 Array 索引处开始将 ICollection 的元素复制到 Array 中#region 从特定 Array 索引处开始将 ICollection 的元素复制到 Array 中
        /**//// <summary>
        /// 从特定 Array 索引处开始将 ICollection 的元素复制到 Array 中
        /// </summary>
        /// <param name="array">作为从 ICollection 复制的元素的目标位置的一维 Array。Array 必须具有从零开始的索引。</param>
        /// <param name="index">array 中的从零开始的索引，从此处开始复制。</param>
        public void CopyTo(System.Array array, int index)
        ...{
            this.innerList.CopyTo(array, index);        
        }
        #endregion 从特定 Array 索引处开始将 ICollection 的元素复制到 Array 中

        返回可循环访问 PQueue 的枚举数#region 返回可循环访问 PQueue 的枚举数
        /**//// <summary>
        /// 返回可循环访问 PQueue 的枚举数
        /// </summary>
        /// <returns>用于 PQueue 的 IEnumerator</returns>
        public IEnumerator GetEnumerator()
        ...{
            return this.innerList.GetEnumerator();        
        }
        #endregion 返回可循环访问 PQueue 的枚举数

        ICollection接口的方法实现#region ICollection接口的方法实现
        /**//// <summary>
        /// 从特定 Array 索引处开始将 ICollection 的元素复制到 Array 中
        /// </summary>
        /// <param name="array">作为从 ICollection 复制的元素的目标位置的一维 Array。Array 必须具有从零开始的索引。</param>
        /// <param name="index">array 中的从零开始的索引，从此处开始复制。</param>
        void ICollection.CopyTo(System.Array array, int index)
        ...{
            this.CopyTo(array, index);
        }
        #endregion ICollection接口的方法实现

        IEnumerable接口的方法实现#region IEnumerable接口的方法实现
        /**//// <summary>
        /// 返回可循环访问 PQueue 的枚举数
        /// </summary>
        /// <returns>用于 PQueue 的 IEnumerator</returns>
        IEnumerator IEnumerable.GetEnumerator()
        ...{
            return this.GetEnumerator();        
        }
        #endregion IEnumerable接口的方法实现

    #endregion 公用的方法

    公用的属性#region 公用的属性

        /**//// <summary>
        /// 队列当前的元素个数
        /// </summary>
        public int Count
        ...{
            get
            ...{
                return count;
            }
        }

        /**//// <summary>
        /// 是否支持同步
        /// </summary>
        public bool IsSynchronized
        ...{
            get
            ...{
                return false;
            }
        }

        /**//// <summary>
        /// 同步对象
        /// </summary>
        public object SyncRoot
        ...{
            get
            ...{
                return syncRoot;
            }
        }

        ICollection接口属性实现#region ICollection接口属性实现
        /**//// <summary>
        /// 队列当前的元素个数
        /// </summary>
        int ICollection.Count
        ...{
            get
            ...{
                return this.Count;
            }
        }

        bool ICollection.IsSynchronized
        ...{
            get
            ...{
                return this.IsSynchronized;
            }
        }

        object ICollection.SyncRoot
        ...{
            get
            ...{
                return this.SyncRoot;
            }
        }
        #endregion ICollection接口属性实现

    #endregion 公用的属性

    受保护的方法#region 受保护的方法
    #endregion 受保护的方法

    私有的方法#region 私有的方法
    #endregion 私有的方法

    私用的字段#region 私用的字段
        /**//// <summary>
        /// 用于存储ITEM的内部列表
        /// </summary>
        private ArrayList innerList = null;

        /**//// <summary>
        /// 队列当前的元素个数
        /// </summary>
        private int count = 0;

        /**//// <summary>
        /// 队列的最大容量，负数表示无限制
        /// </summary>
        private int maxCount = -1;

        /**//// <summary>
        /// 用于同步的对象
        /// </summary>
        private object syncRoot = new object();
    #endregion 私有的字段
    }