Бинарное дерево с указателями

namespace _24hour
{
    public partial class Form1 : Form
    {
        //private Tree Tree;
        public Form1()
        {
            InitializeComponent();
        }
        private void Form1_Load(object sender, EventArgs e)
        {
 
        }
        public string prints = "";
        
        private void button2_Click(object sender, EventArgs e) //Кнопка "Далее"
        {
            string number = "";
            int i = 0;
            int j = 0;
            // Да - right
            //Нет - left
            if (radioButton1.Checked == true) //Да
            {
                i = 1;
            }
 
            if (radioButton2.Checked == true) //Нет
            {
                j = 1;
            }
 
            var queue = new Queue<TreeNode>(); // создать новую очередь
                                               //if (detailed)
            prints += "    заносим в очередь значение " + Node.Value.ToString() + Environment.NewLine;
            queue.Enqueue(Node); // поместить в очередь первый уровень
 
            if (queue.Count != 0)
            {
                if ((i == 0) && (j == 0))
                {
                    MessageBox.Show("Необходимо выбрать один из вариантов |Да| или |Нет|");
                }
                if ((i == 1) && (j == 0)) //Нажал "Да"
                {
                    //если у текущей ветви есть листья, их тоже добавить в очередь
                    if (queue.Peek().Left != null)
                    {
                        prints += "    заносим в очередь значение " + queue.Peek().Left.Value.ToString() + " из левого поддерева" + Environment.NewLine;
                        queue.Enqueue(queue.Peek().Left);
                    }
                    if (queue.Peek().Right != null)
                    {
                        number = queue.Peek().Right.Value.ToString(); //Число в текстовом документе по индексу которого получим строку
                        prints += "    заносим в очередь значение " + queue.Peek().Right.Value.ToString() + " из правого поддерева" + Environment.NewLine;
                        queue.Enqueue(queue.Peek().Right);
                    }
                    //извлечь из  очереди информационное поле последнего элемента
                    prints += "    извлекаем значение из очереди: " + queue.Peek().Value.ToString() + Environment.NewLine;
                    prints += queue.Peek().Value.ToString() + " ";
                    // убрать в очереди последний элемент
                    queue.Dequeue();
                    getString(number); //Передача числового значения уза для вывода его текстового значения
                }
                if ((i == 0) && (j == 1)) //Нажал "Нет"
                {
                    //если у текущей ветви есть листья, их тоже добавить в очередь
                    if (queue.Peek().Left != null)
                    {
                        number = queue.Peek().Left.Value.ToString(); //Число в текстовом документе по индексу которого получим строку
                        prints += "    заносим в очередь значение " + queue.Peek().Left.Value.ToString() + " из левого поддерева" + Environment.NewLine;
                        queue.Enqueue(queue.Peek().Left);
                    }
                    if (queue.Peek().Right != null)
                    {
                        prints += "    заносим в очередь значение " + queue.Peek().Right.Value.ToString() + " из правого поддерева" + Environment.NewLine;
                        queue.Enqueue(queue.Peek().Right);
                    }
                    //извлечь из  очереди информационное поле последнего элемента
                    prints += "    извлекаем значение из очереди: " + queue.Peek().Value.ToString() + Environment.NewLine;
                    prints += queue.Peek().Value.ToString() + " ";
                    // убрать в очереди последний элемент
                    queue.Dequeue();
                    getString(number); //Передача числового значения уза для вывода его текстового значения
                }
            }
        }
        public void getString(string number)
        {
            int index=0;
            using (StreamReader sReader = new StreamReader(@"number.txt")) //Получили веса вершин бинарного дерева
            {
                string[] helpArray = sReader.ReadToEnd().Split('\n');
                for (int i = 0; i < helpArray.Length; i++)
                {
                    if (helpArray[i] == number)
                    {
                        index = i; //Получили индекс, по которому получми строку из массива TexthelpArray
                        break;
                    }
                }
            }
            using (StreamReader sReader = new StreamReader(@"question.txt")) //Получили текст для каждого узла бинарного дерева
            {
                string[] TexthelpArray = sReader.ReadToEnd().Split('\n');
                richTextBox2.Text += TexthelpArray[index]+'\n';
            }
        }
        //public string prints = "";
        private void button3_Click(object sender, EventArgs e) //Загрузить дерево
        {
            //Читаем дерево из файла
            using (var file = new System.IO.StreamReader(@"number.txt"))
            {
                while (file.Peek() >= 0)
                {
                    string lineCurrent = file.ReadLine();
                    if (lineCurrent != null) Add(int.Parse(lineCurrent));
                }
            }
            string s = "";
            Print(ref s);
            richTextBox1.Text = s;
            prints = s;
            //Across(Node, ref s);
 
        }
        public void for_textBox()
        {
            textBox1.Text = prints;
        }
        public class TreeNode
        {
            public int Value; // численное значение
            public int Count = 0; // количество значений (сколько раз было добавлено данное численное значение) 
            public TreeNode Left; // левое поддерево
            public TreeNode Right; // правое поддерево
        }
        public TreeNode Node; // экземпляр класса "элемент дерева"
        
        // добавление значения в дерево (публичный метод)
        public void Add(int value)
        {
            // аргумент int value - значение, которое добавляется 
            AddRecursion(ref Node, value); // вызов внутреннего метода для добавления (нужно для того, чтобы лишний раз не вызывать "ref Node" вне класса, где это вообще не по смыслу) 
        }
        private void AddRecursion(ref TreeNode node, int val)
        {
            /*
             Аргументы метода:
             1. ref TreeNode Node - текущий "элемент дерева" (ref - передача по ссылке)
             2. int val - передаваемое (добавляемое значение)
            */
            if (node == null) // если было вызвано добавление, а этого элемента не создано 
            {
                node = new TreeNode(); // создать новый элемент дерева
                node.Value = val; // присвоить созданному элементу добавляемого значение
                node.Count = 1; // элемент добавлен только 1 раз
            }
            else // если данный элемент создан
            {
                if (node.Value == val) // если добавляемое значение совпадает тем, которое есть - увеличить счетчик повторений 
                    node.Count++;
                else
                {
                    if ((node.Value) > val) // если добавляемое значение больше того, которое есть 
                    {
                        AddRecursion(ref node.Left, val); // добавить в левое поддерево
                    }
                    else // если добавляемое значение меньше того, которое есть
                    {
                        AddRecursion(ref node.Right, val); // добавить в правое поддерево
                    }
                }
            }
        }
 
        // печать дерева (публичный метод)
        public void Print(ref string s)
        {
            // аргумент ref string s - строка, в которой накапливается представление дерева в текстовом виде (ref - передача по ссылке)
            s = ""; // обнуляем строку
            PrintRecursion(Node, 0, ref s); // вызов внутреннего метода для печати (нужно для того, чтобы лишний раз не вызывать "Node" вне класса) 
        }
 
        // печать дерева (рекурсивно) 
        private void PrintRecursion(TreeNode root, int spaces, ref string s)
        {
            //
        }
    }
}

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Windows.Forms;
 
namespace WindowsFormsApplication339
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
 
            //вопросы в плоском тексте
            var text = @"
=В задаче одна целевая функция?
 Да=Область в которой происходит задача оптимизации - это функциональные пространства?
  Да=Исходная задача неустойчивая и её решение не является нерерывно зависящем от входных данных?
   Да=Градиентный метод.
   Нет=Метод проекции градиента.
  Нет=Функция минимизации нескольких переменных?
   Да=Метод проекции градиента.
   Нет=Градиентный метод.
  Не знаю=Используйте градиентный метод.
 Нет=Методы решения много критериальных задач? 
  Да=Градиентный метод.
  Нет=Метод проекции градиента.
";
            //парсим вопросы
            var root = Node.Parse(text);
            //создаем панель
            var pn = new NodePanel {Parent = this, Dock = DockStyle.Fill};
            pn.NodeSelected += (o, e) => { pn.Build(e.Node); };
            //начинаем опрос
            pn.Build(root[0]);
        }
    }
 
    /// <summary>
    /// Панель для отображения вопросов
    /// </summary>
    class NodePanel : UserControl
    {
        public EventHandler<NodeSelectedEventArgs> NodeSelected = delegate { };
 
        public void Build(Node node)
        {
            var y1 = 200;
            var btWidth = 100;
 
            Controls.Clear();
 
            //лейба
            var lb = new Label {AutoSize = false, Dock = DockStyle.Top, Height = y1 - 10, Parent = this, Text = node.Text, Font = new Font(FontFamily.GenericSansSerif, 24)};
 
            //кнопки
            var x = 0;
            foreach(var child in node)
            {
                var theChild = child;
                var bt = new Button {Parent = this, Text = child.Condition, Left = x, Top = y1, Width = btWidth};
                bt.Click += delegate { NodeSelected(this, new NodeSelectedEventArgs { Node = theChild }); };
                x += btWidth;
            }
        }
    }
 
    class NodeSelectedEventArgs : EventArgs
    {
        public Node Node { get; set; }
    }
 
    /// <summary>
    /// Вершина дерева
    /// </summary>
    class Node : List<Node> //вершина содержит список своих детей
    {
        /// <summary>
        /// Текст вопроса или заключения
        /// </summary>
        public string Text { get; set; }
 
        /// <summary>
        /// Условие срабатывания
        /// </summary>
        public string Condition { get; set; }
 
        /// <summary>
        /// Парсинг плоского текста в дерево (формат Tree [url]https://habrahabr.ru/post/248147/[/url])
        /// </summary>
        public static Node Parse(string text)
        {
            var root = new Node();
            var lines = text.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
            Parse(root, lines, 0, 0);
 
            return root;
        }
 
        static void Parse(Node parent, string[] lines, int currentLine, int level)
        {
            if (currentLine >= lines.Length) return;
 
            for (int i = currentLine; i < lines.Length; i++)
            {
                var line = lines[i];
                var trimmed = line.TrimStart();
                var spaces = line.Length - trimmed.Length;
                if (spaces < level) return;
                if (spaces == level)
                {
                    var n = ParseNode(trimmed);
                    parent.Add(n);
                    Parse(n, lines, i + 1, level + 1);
                }
            }
        }
 
        static Node ParseNode(string line)
        {
            var parts = line.Split(new char[]{'='}, 2);
            return new Node() { Text = parts[1].Trim(), Condition = parts[0].Trim() };
        }
    }
}