二叉堆的c#实现

在下小白一个 如有错误请指正

上代码

using System;
using System.Collections.Generic;

//数据结构
namespace DataStructure
{

    //二叉堆 就是数据结构中堆的一种 不是内存中的堆
    //二叉堆的第一个元素通常放在数组0或者1的位置
    //当二叉堆的第一个元素在数组0的位置时 左子节点的索引为2*i+1,右子节点的索引为2*i+2,父节点的索引为floor((i-1)/2)
    //第一个元素在数组1的位置时 左子节点的索引为 2*i 右子节点的索引为2*i+1 父节点的索引为floor(i/2)

    /// <summary>
    /// 二叉堆 最大堆
    /// 父节点的键值总是大于或等于任意一个子节点的键值
    /// </summary>
    public class MaxHeap<T> where T : IComparable
    {
        private List<T> mHeqp;

        public List<T> MHeap => mHeqp ?? (mHeqp = new List<T>());

        /// <summary>
        /// 插入
        /// </summary>
        /// <param name="key">插入的key</param>
        public void Inset(T key)
        {
            //插入最后
            MHeap.Add(key);
            int star = MHeap.Count - 1;
            //向上调整
            AdjustUpWard(star);
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="key">删除的key</param>
        public void Remove(T key)
        {
            if (mHeqp == null) return;

            if (mHeqp.Contains(key))
            {
                int removePos = mHeqp.IndexOf(key);
                int endPos = mHeqp.Count - 1;
                //要删除的值 替换为最后一个值
                mHeqp[removePos] = mHeqp[endPos];
                //删除最后一个值
                mHeqp.Remove(mHeqp[endPos]);
                //向下调整
                if (mHeqp.Count > 1)
                    AdjustDownWard(removePos, mHeqp.Count - 1);
            }
        }

        /// <summary>
        /// 销毁
        /// </summary>
        public void Destory()
        {
            mHeqp.Clear();
            mHeqp = null;
        }

        /// <summary>
        /// 向上调整
        /// </summary>
        /// <param name="starPos">开始位置</param>
        protected void AdjustUpWard(int starPos)
        {
            int parentPos = (starPos - 1)/2;
            T starKey = mHeqp[starPos];

            while (starPos > 0)
            {
                int cmp = starKey.CompareTo(mHeqp[parentPos]);
                if (cmp > 0)
                {
                    mHeqp[starPos] = mHeqp[parentPos];
                    starPos = parentPos;
                    parentPos = (parentPos - 1) /2;
                }
                else
                    break;
            }

            mHeqp[starPos] = starKey;
        }

        /// <summary>
        /// 向下调整
        /// </summary>
        /// <param name="starPso">开始位置</param>
        /// <param name="endPos">结束位置</param>
        protected void AdjustDownWard(int starPso, int endPos)
        {
            int leftChildPos = starPso*2 + 1;
            int rightChildPos = starPso*2 + 2;
            T temp = mHeqp[starPso];

            while (leftChildPos <= endPos)
            {
                int bigKeyPos = mHeqp[leftChildPos].CompareTo(mHeqp[rightChildPos]) > 0 ? leftChildPos : rightChildPos;
                if (bigKeyPos <= endPos)
                {
                    int cmp = mHeqp[bigKeyPos].CompareTo(temp);
                    if (cmp > 0)
                    {
                        mHeqp[starPso] = mHeqp[bigKeyPos];
                        starPso = bigKeyPos;

                        leftChildPos = leftChildPos*2 + 1;
                        rightChildPos = leftChildPos + 1;
                    }
                    else
                        break;
                }
                else
                    break;
            }
            mHeqp[starPso] = temp;
        }

        public void Print()
        {
            for (int i = 0; i < mHeqp.Count; i++)
            {
                Console.WriteLine("Index ：{0}   Key: {1}", i, mHeqp[i].ToString());
            }
        }
    }

    /// <summary>
    /// 二叉堆 最小堆
    /// 任意节点的值小于他的子节点的值
    /// </summary>
    public class MinHeap<T> where T : IComparable
    {
        private List<T> mHeap;
        public List<T> MHeap => mHeap ?? (mHeap = new List<T>());

        /// <summary>
        /// 向上调整
        /// </summary>
        /// <param name="startPos">开始位置</param>
        private void AdjustUpWard(int startPos)
        {
            int parentPos = (startPos - 1) / 2;
            T temp = mHeap[startPos];
            while (startPos > 0)
            {
                int cmp = mHeap[parentPos].CompareTo(temp);
                if (cmp < 0)
                {
                    break;
                }
                else
                {
                    mHeap[startPos] = mHeap[parentPos];
                    startPos = parentPos;
                    parentPos = (parentPos - 1) / 2;
                }
            }
            mHeap[startPos] = temp;
        }

        /// <summary>
        /// 向下调整
        /// </summary>
        /// <param name="startPos">开始位置</param>
        /// <param name="endPos">结束位置</param>
        private void AdjustDownWard(int startPos, int endPos)
        {
            int leftChildPos = startPos*2 + 1;
            int rightChildPos = startPos*2 + 2;
            T temp = MHeap[startPos];
            while (leftChildPos <= endPos)
            {
                int smallPos = MHeap[leftChildPos].CompareTo(MHeap[rightChildPos]) > 0 ? rightChildPos : leftChildPos;
                if (smallPos <= endPos)
                {
                    int cmp = temp.CompareTo(MHeap[smallPos]);
                    if (cmp > 0)
                    {
                        MHeap[startPos] = MHeap[smallPos];
                        startPos = smallPos;
                        leftChildPos = leftChildPos*2 + 1;
                        rightChildPos = leftChildPos + 1;
                    }
                    else
                        break;
                }
                else
                    break;
            }
            MHeap[startPos] = temp;
        }

        /// <summary>
        /// 插入
        /// </summary>
        /// <param name="key">要插入的值</param>
        public void Inset(T key)
        {
            MHeap.Add(key);
            int insetIndex = MHeap.Count - 1;
            AdjustUpWard(insetIndex);
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="key">要删除的值</param>
        public void Remove(T key)
        {
            if (key == null) return;
            if (mHeap == null) return;

            if (mHeap.Contains(key))
            {
                int removeIndex = MHeap.IndexOf( key);
                int endIndex = MHeap.Count - 1;

                T temp = MHeap[endIndex];

                mHeap.Remove(MHeap[endIndex]);

                MHeap[removeIndex] = temp;

 

                AdjustDownWard(removeIndex, endIndex - 1);
            }
        }

        /// <summary>
        /// 删除
        /// </summary>
        public void Destroy()
        {
            mHeap.Clear();
            mHeap = null;
        }

        public void Print()
        {
            for (int i = 0; i < MHeap.Count; i++)
            {
                Console.WriteLine("Index ：{0}   Key: {1}", i, MHeap[i].ToString());
            }
        }
    }
}