C#实现简单优先队列

最新推荐文章于 2026-01-05 20:16:07 发布

原创最新推荐文章于 2026-01-05 20:16:07 发布 · 803 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

DotNet

本文介绍了一个使用C#实现的泛型优先队列类，该类支持基本操作如插入(Enqueue)、删除最大元素(Dequeue)等，并采用堆结构进行高效管理。文章详细展示了如何初始化优先队列并进行关键操作。

using System;
using System.Collections.Generic;

namespace fofo.DataStructor
{
    public class PriorityQueue<T> where T: IComparable//, new()
    {
        private const int DEFAULT_CAP = 100;

        private T[] _datas = null;
        private int _capacity = DEFAULT_CAP;
        private int _size = 0;

        public PriorityQueue()
            : this(DEFAULT_CAP)
        {
        }

        public PriorityQueue(int capacity)
        {
            _capacity = capacity;
            _datas = new T[_capacity];
        }        

        public PriorityQueue(T[] initData)
        {
            if (_capacity <= initData.Length * 2)
            {
                _capacity = initData.Length * 2;
            }

            _datas = new T[_capacity];
            Array.Copy(initData, 0, _datas, 1, initData.Length);
            for (int i = initData.Length/2; i > 0; i--)
            {
                T item = _datas[i];
                if (_datas[i * 2].CompareTo(_datas[i * 2 + 1]) < 0)
                {
                    _datas[i] = _datas[i * 2];
                    _datas[i * 2] = item;
                }
                else
                {
                    _datas[i] = _datas[i * 2 + 1];
                    _datas[i * 2] = item;
                }                
            }

            _size = initData.Length;
        }

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

        public void Enqueue(T item)
        {
            if (IsFull())
            {
                ReBuild();
            }

            int i;
            for (i = ++_size; i > 1 && item.CompareTo(_datas[i / 2]) < 0; i /= 2)
            {
                _datas[i] = _datas[i / 2];
            }

            _datas[i] = item;
        }

        public T Dequeue()
        {
            if (IsEmpty())
            {
                throw new Exception("no item");
            }

            T first = _datas[1];
            T last = _datas[_size--];

            int i, child = 1;
            for (i = 1; i * 2 <= _size; i = child)
            {
                child = i * 2;
                if ((child != _size) && (_datas[child].CompareTo(_datas[child + 1]) > 0))
                {
                    child++;
                }

                if (last.CompareTo(_datas[child]) > 0)
                {
                    _datas[i] = _datas[child];
                }
                else
                {
                    break;
                }
            }
            _datas[i] = last;
            
            return first;
        }

        public void Clear()
        {
            _datas = new T[_capacity];
        }

        private bool IsFull()
        {
            return _size == (_datas.Length - 1);
        }       

        private void ReBuild()
        {
            _capacity = _capacity * 2;
            T[] data = new T[_capacity];
            Array.Copy(_datas, data, _datas.Length);
            _datas = data;
        }

    }
}