/// <summary>
        /// 根据指定数组初始化面向中位数的堆。
        /// </summary>
        /// <param name="keys">初始数组。</param>
        public MedianPQ(Key[] keys)
        {
            minPQ = new MinPQ <Key>();
            maxPQ = new MaxPQ <Key>();

            if (keys.Length == 0)
            {
                n      = 0;
                median = default(Key);
                return;
            }

            n      = keys.Length;
            median = keys[0];
            for (var i = 1; i < keys.Length; i++)
            {
                if (median.CompareTo(keys[i]) < 0)
                {
                    minPQ.Insert(keys[i]);
                }
                else
                {
                    maxPQ.Insert(keys[i]);
                }
            }

            UpdateMedian();
        }
        static void Main(string[] args)
        {
            Console.WriteLine("Enter the number of elements in queue:");
            var            input = Console.ReadLine();
            MaxPQ <string> pq;
            int            number;

            while (!int.TryParse(input, out number))
            {
                Console.WriteLine("Enter a valid number:");
                input = Console.ReadLine();
            }

            pq = new MaxPQ <string>(number);

            while (number > 0)
            {
                Console.WriteLine("Enter keys");
                string entry = Console.ReadLine();
                pq.Insert(entry);
                number--;
            }

            while (!pq.IsEmpty)
            {
                Console.WriteLine(pq.DeleteMax());
            }
        }
 /// <summary>
 /// 默认构造函数,构造一个面向中位数的堆。
 /// </summary>
 public MedianPQ()
 {
     maxPQ  = new MaxPQ <Key>();
     minPQ  = new MinPQ <Key>();
     median = default(Key);
     n      = 0;
 }
 /// <summary>
 /// 构造一个指定容量的面向中位数的堆。
 /// </summary>
 /// <param name="capacity">初始容量。</param>
 public MedianPQ(int capacity)
 {
     maxPQ  = new MaxPQ <Key>((capacity - 1) / 2);
     minPQ  = new MinPQ <Key>((capacity - 1) / 2);
     n      = 0;
     median = default(Key);
 }
 /// <summary>
 /// 构造一个指定容量的面向中位数的堆。
 /// </summary>
 /// <param name="capacity">初始容量。</param>
 public MedianPQ(int capacity)
 {
     this.maxPQ  = new MaxPQ <Key>((capacity - 1) / 2);
     this.minPQ  = new MinPQ <Key>((capacity - 1) / 2);
     this.n      = 0;
     this.median = default(Key);
 }
        /// <summary>
        /// 根据指定数组初始化面向中位数的堆。
        /// </summary>
        /// <param name="keys">初始数组。</param>
        public MedianPQ(Key[] keys)
        {
            this.minPQ = new MinPQ <Key>();
            this.maxPQ = new MaxPQ <Key>();

            if (keys.Length == 0)
            {
                this.n      = 0;
                this.median = default(Key);
                return;
            }

            this.n      = keys.Length;
            this.median = keys[0];
            for (int i = 1; i < keys.Length; i++)
            {
                if (this.median.CompareTo(keys[i]) < 0)
                {
                    this.minPQ.Insert(keys[i]);
                }
                else
                {
                    this.maxPQ.Insert(keys[i]);
                }
            }

            UpdateMedian();
        }
 /// <summary>
 /// 默认构造函数,构造一个面向中位数的堆。
 /// </summary>
 public MedianPQ()
 {
     this.maxPQ  = new MaxPQ <Key>();
     this.minPQ  = new MinPQ <Key>();
     this.median = default(Key);
     this.n      = 0;
 }
Exemple #8
0
 /// <summary>
 /// 根据已有元素建立一个最大-最小堆。(O(n))
 /// </summary>
 /// <param name="keys">需要建堆的元素。</param>
 public MinMaxPQ(Key[] keys)
 {
     this.n = keys.Length;
     MinMaxNode[] minNodes = new MinMaxNode[keys.Length];
     MinMaxNode[] maxNodes = new MinMaxNode[keys.Length];
     for (int i = 0; i < this.n; i++)
     {
         MinMaxNode.GetNodes(keys[i], i + 1, out minNodes[i], out maxNodes[i]);
     }
     this.minPQ = new MinPQ(minNodes);
     this.maxPQ = new MaxPQ(maxNodes);
 }
Exemple #9
0
        /// <summary>
        /// 根据已有元素建立一个最大-最小堆。(O(n))
        /// </summary>
        /// <param name="keys">需要建堆的元素。</param>
        public MinMaxPQ(Key[] keys)
        {
            n = keys.Length;
            var minNodes = new MinMaxNode[keys.Length];
            var maxNodes = new MinMaxNode[keys.Length];

            for (var i = 0; i < n; i++)
            {
                MinMaxNode.GetNodes(keys[i], i + 1, out minNodes[i], out maxNodes[i]);
            }
            minPQ = new MinPQ(minNodes);
            maxPQ = new MaxPQ(maxNodes);
        }
        /// <summary>
        /// 获取堆的迭代器,元素以降序排列。
        /// </summary>
        /// <returns></returns>
        public IEnumerator <Key> GetEnumerator()
        {
            MaxPQ <Key> copy = new MaxPQ <Key>(this.n);

            for (int i = 1; i <= this.n; i++)
            {
                copy.Insert(this.pq[i]);
            }

            while (!copy.IsEmpty())
            {
                yield return(copy.DelMax()); // 下次迭代的时候从这里继续执行。
            }
        }
Exemple #11
0
        /// <summary>
        /// 获取堆的迭代器,元素以降序排列。
        /// </summary>
        /// <returns>最大堆的迭代器。</returns>
        public IEnumerator <Key> GetEnumerator()
        {
            var copy = new MaxPQ <Key>(n);

            for (var i = 1; i <= n; i++)
            {
                copy.Insert(pq[i]);
            }

            while (!copy.IsEmpty())
            {
                yield return(copy.DelMax()); // 下次迭代的时候从这里继续执行。
            }
        }
Exemple #12
0
 /// <summary>
 /// 构造一个指定容量的最大-最小堆。
 /// </summary>
 /// <param name="capacity">堆的大小。</param>
 public MinMaxPQ(int capacity)
 {
     minPQ = new MinPQ(capacity);
     maxPQ = new MaxPQ(capacity);
     n     = 0;
 }
Exemple #13
0
 /// <summary>
 /// 构造一个指定容量的最大-最小堆。
 /// </summary>
 /// <param name="capacity">堆的大小。</param>
 public MinMaxPQ(int capacity)
 {
     this.minPQ = new MinPQ(capacity);
     this.maxPQ = new MaxPQ(capacity);
     this.n     = 0;
 }