Как реализовать бинарную кучу (пирамиду)?

using System;
using System.IO;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
 
namespace BHeap
{
    public partial class Form1 : Form
    {
        
        //Graphics pictGraphics;
        public Form1()
        {
            InitializeComponent();
            
        }
 
        private void Form1_Load(object sender, EventArgs e)
        {
            
        }
 
        private void ДейстивиеToolStripMenuItem_Click(object sender, EventArgs e)
        {
 
        }
 
        private void ПрочитатьИзФайлаToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Stream  myStream;
            OpenFileDialog openFileDialog1 = new OpenFileDialog();
            openFileDialog1.InitialDirectory = "D:\\";
            openFileDialog1.Filter = "txt files (*.txt) |*.txt|All files (*.*) |*.*";
            openFileDialog1.FilterIndex = 2;
            openFileDialog1.RestoreDirectory = true;
            if (openFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                if ((myStream = openFileDialog1.OpenFile()) != null)
                {
                    MessageBox.Show("Read file was happend");
                    myStream.Close();
                }
            }
        }
        
        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);
            Font drawFont = new Font("Arial", 5);
            SolidBrush drawBrush = new SolidBrush(Color.Black);
            StringFormat drawFormat = new StringFormat();
            drawFormat.FormatFlags = StringFormatFlags.DirectionRightToLeft;
 
            BinaryHeap binary = new BinaryHeap();
            Dictionary<int, string> dic = new Dictionary<int, string>();
            //dic.Add(binary.Add(900), "B1"); // не работает 
            //dic.Add(binary.Add(1100), "B2"); // не знаю как сделать, что бы работало
            dic.Add(1000, "B1");
            dic.Add(900, "B2");
           
            int x = 670, y = 30;
            int dx = 40;
            int deb = 1;
            
            foreach (string key in dic.Values)
            {
                //MessageBox.Show(key);
                e.Graphics.DrawEllipse(Pens.Red, x, y, 30, 30);
                e.Graphics.DrawString(key, drawFont, drawBrush, x, y, drawFormat);
                for (int i = 1; i <= 3; i++)
                {
                    for (int k = 0; k < deb; k++)
                    {
                        e.Graphics.DrawEllipse(Pens.Red, x - dx, y + 40, 30, 30);
                        e.Graphics.DrawEllipse(Pens.Red, x + dx, y + 40, 30, 30);
                        //e.Graphics.DrawLine(Pens.Black, x + 15, y+30, 255, 70);
                        //e.Graphics.DrawLine(Pens.Black, x + 15, y + 30, 455, 70);
                        dx += 40;
                    }
                    deb *= 2;
                    y += 40;
                }
            }
 
           
            
        }
    }
    class BinaryHeap
    {
        private List<int> list;
 
        public BinaryHeap()
        {
            list = new List<int>();
        }
 
        // Кол-во элементов в бинарной куче
        public int Count
        {
            get
            {
                return list.Count();
            }
        }
 
        // Добавление элемента
        public void Add(int value)
        {
            list.Add(value);
            if (Count == 1) // Всего один элемент,
                return;     // нечего перемещать
 
            // Получаем индексы текущего и родительского элементов
            int current = Count - 1;        // текущий (индекс в массиве начинается с нуля)
            int parent = (current - 1) / 2; // родитель (дробная часть у int отпадает)
 
            // Если нужно - перемещаем наибольший элемент наверх,
            // чтобы соотвествовать условию бинарной кучи
            while (list[parent] < list[current])
            {
                int temp = list[current];
                list[current] = list[parent];
                list[parent] = temp;
 
                // Получаем индексы текущего и родительского элементов
                current = parent;
                parent = (current - 1) / 2;
            }
        }
 
        // Удаление элемента
        public void Remove(int index)
        {
            if (index < 0 || index > Count - 1)
            {
                Console.WriteLine("Неверный индекс, удаление невозможно");
                return;
            }
            list[0] = list[Count - 1];
            list.RemoveAt(Count - 1);
            Heapify(0);
        }
 
        // Получение максимального элемента
        // true - не удалять элемент, false - удалить
        public int GetMax(bool check)
        {
            if (check == true)
                return list[0];
            int result = list[0];
            list[0] = list[Count - 1];
            list.RemoveAt(Count - 1);
            Heapify(0);
            return result;
        }
 
        // Проверить значение по текущему индексу,
        // не нарушает ли оно правило бинарной кучи
        void Heapify(int i)
        {
            int current;
            int leftChild;
            int rightChild;
 
            while (true)
            {
                current = i;
                leftChild = 2 * i + 1;
                rightChild = 2 * i + 2;
 
                // Проверка на выход за границы массива, и сравнивает значения
                if (leftChild < Count && list[leftChild] > list[current])
                {
                    current = leftChild;
                }
 
                // Проверка на выход за границы массива, и сравнивает значения
                if (rightChild < Count && list[rightChild] > list[current])
                {
                    current = rightChild;
                }
 
                // Значение находитсяна своем месте
                if (current == i)
                {
                    break;
                }
 
                int temp = list[i];
                list[i] = list[current];
                list[current] = temp;
                i = current;
            }
        }
 
        // Сортировка
        public void Sort()
        {
            list.Sort();    // Сортировка по возрастанию
            list.Reverse(); // Перевернуть все значения
        }
 
        // Глубина бинарной кучи
        public int Height()
        {
            return CounterHeight(Count);
        }
 
        // Подсчет глубины бинарной кучи
        int CounterHeight(int val)
        {
            if (val == 0) return 0;
            return (val / 2 > 0) ? CounterHeight(val / 2) + 1 : 1;
        }
 
        // Подсчет длины максимального значения
        int MaxLengthValue()
        {
            int maxLengthValue = 0;
            for (int i = 0; i < list.Count; i++)
            {
                if (maxLengthValue < list[i].ToString().Length)
                    maxLengthValue = list[i].ToString().Length;
            }
            return maxLengthValue;
        }
    }
}