public void FindLastRightNode(BinaryNode node, ref BinaryNode result_node)
        {
            // На вход подаём вершину, для которой нужно найти самого нижнего правого потомка

            if (node.Right == null)
            {
                result_node = node;
                return;
            }
            else
                FindLastRightNode(node.Right, ref result_node);
        }

public class BinaryNode
    {
        public BinaryNode Left { get; set; } // Левое поддерево
        public BinaryNode Right { get; set; } // Правое поддеревго
        public int value { get; set; } // Числовое значение вершины
        public int level { get; set; } // Уровень дерева, на котором находится вершина

        public BinaryNode(int value)
        {
            // Констркутор вершины
            // На вход даём числовое значение вершины

            this.value = value;
            Left = null;
            Right = null;
        }

        public int GetLevel()
        {
            return level;
        }
    }

private void button1_Click(object sender, EventArgs e)
        {
            string nodes_str = textBox1.Text; // Получаем вершины из поля с вершинами

            // Проверка на правильность введённых значений
            if (!CheckString(nodes_str))
                return;

            // Парсим числа из строки в список вершин
            List<int> nodes = new List<int>();
            int[] nodes_temp = nodes_str.Split(" ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries).Select(x => Convert.ToInt32(x)).ToArray();
            nodes.AddRange(nodes_temp);

            BinaryNode root_bn = new BinaryNode(nodes[0]); // Определяем корневую вершину
            nodes.RemoveAt(0); // Убираем из списка вершин первую-корневую вершину
            BinaryTree bt = new BinaryTree(root_bn); // Создаём бинарное дерево

            for (int i = 0; i < nodes.Count; i++)
            {
                bt.AddElement(nodes[i]);
            }

            for (int j = 0; j < nodes.Count; j++) // Проверочный цикл
            {
                listBox1.Items.Add(Convert.ToString(nodes[j]));
            }

            listBox1.Items.Add(" ");

            

            // ПРОВЕРКА РЕКУРСИИ

            BinaryNode tempN = new BinaryNode(5555);

            bt.FindNode(root_bn, 4, ref tempN);

            BinaryNode tempN2 = new BinaryNode(5556);

            bt.FindLastRightNode(tempN, ref tempN2);

            listBox1.Items.Add(Convert.ToString(tempN2.value));

            




            }

        }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace BinaryTree
{
        public class BinaryNode
    {
        public BinaryNode Left { get; set; } // Левое поддерево
        public BinaryNode Right { get; set; } // Правое поддеревго
        public int value { get; set; } // Числовое значение вершины
        public int level { get; set; } // Уровень дерева, на котором находится вершина

        public BinaryNode(int value)
        {
            // Констркутор вершины
            // На вход даём числовое значение вершины

            this.value = value;
            Left = null;
            Right = null;
        }

        public int GetLevel()
        {
            return level;
        }

        public BinaryNode GetLastRight()
        {
            return this.Right == null ? this : this.Right.GetLastRight();
        }
    }
        
    public class BinaryTree
    {
        public BinaryNode node_root;
        private int count;
        private int min_value;
        private int max_value;

        public BinaryTree(BinaryNode root_node)
        {
            // Констркутор бинарного дерева
            // На вход даём корневую вершину
            this.node_root = root_node;
            this.count = 1; // Поправка на корневую вершину
        }

        public int GetNodesCount()
        {
            return count;
        }

        public int GetMinValue()
        {
            return min_value;
        }

        public int GetMaxValue()
        {
            return max_value;
        }

        public void AddElement(int new_value)
        {
            if (new_value > max_value)
                max_value = new_value;
            else if (new_value < min_value)
                min_value = new_value;

            int level = 0;

            if (node_root == null)
            {
                node_root = new BinaryNode(new_value);
                node_root.level = level;
                count++;
                return;
            }
            else
                InsertElement(node_root, new_value, level);
        }        

        public void InsertElement(BinaryNode node, int new_value, int level)
        {
            level++;
            if (new_value > node.value) // Новый элемент > элемент
            {
                // Проверяем правую ветвь
                if (node.Right == null)
                {
                    node.Right = new BinaryNode(new_value);
                    node.Right.level = level + 1;
                    count++;
                }
                else
                    InsertElement(node.Right, new_value, level);
            }
            else // Новый элемент < элемент
            {
                // Проверяем левую ветвь
                if (node.Left == null)
                {
                    node.Left = new BinaryNode(new_value);
                    node.Left.level = level + 1;
                    count++;
                }
                else
                    InsertElement(node.Left, new_value, level);
            }
        }

        public bool FindValue(BinaryNode node, int search_value)
        {
            // На вход подаём корневую вершину

            if (search_value == node.value)
                return true;
            else if (search_value < node.value)
            {
                if (node.Left == null)
                    return false;
                else
                    return FindValue(node.Left, search_value);
            }
            else if (search_value > node.value)
            {
                if (node.Right == null)
                    return false;
                else
                    return FindValue(node.Right, search_value);
            }

            return false;
        }

        public bool FindNode(BinaryNode node, int search_value, ref BinaryNode result_node)
        {
            // На вход подаём корневую вершину

            if (search_value == node.value)
            {
                result_node = node;
                return true;
            }
            else if (search_value < node.value)
            {
                if (node.Left == null)
                    return false;
                else
                    return FindNode(node.Left, search_value, ref result_node);
            }
            else if (search_value > node.value)
            {
                if (node.Right == null)
                    return false;

                else
                    return FindNode(node.Right, search_value, ref result_node);
            }

            return false;
        }

        public bool FindNodeParent(BinaryNode node, int search_value, ref BinaryNode result_node)
        {
            // На вход подаём корневую вершину

            if (node.Left != null)
            {
                if (node.Left.value == search_value)
                {
                    result_node = node;
                    return true;
                }
                if (FindNodeParent(node.Left, search_value, ref result_node))
                    return true;
            }
            if (node.Right != null)
            {
                if (node.Right.value == search_value)
                {
                    result_node = node;
                    return true;
                }
                if (FindNodeParent(node.Right, search_value, ref result_node))
                    return true;
            }

            return false;
        }

        public void TraversePreorder(BinaryNode node) // Прямой обход дерева
        {
            // На вход подаём корневую вершину

            // Здесь можем выполнять какие-нибудь действия

            MessageBox.Show(Convert.ToString(node.value));

            if (node.Left != null)
                TraversePreorder(node.Left);
            if (node.Right != null)
                TraversePreorder(node.Right);
        }

        public void TraverseInorder(BinaryNode node) // Симметричный обход дерева
        {
            // На вход подаём корневую вершину

            if (node.Left != null)
                TraversePreorder(node.Left);

            // Здесь можем выполнять какие-нибудь действия

            MessageBox.Show(Convert.ToString(node.value));

            if (node.Right != null)
                TraversePreorder(node.Right);
        }

        public void TraversePostorder(BinaryNode node) // Обход дерева в обратном порядке
        {
            // На вход подаём корневую вершину

            if (node.Left != null)
                TraversePreorder(node.Left);
            if (node.Right != null)
                TraversePreorder(node.Right);

            // Здесь можем выполнять какие-нибудь действия

            MessageBox.Show(Convert.ToString(node.value));
        }

        public void TraverseDepth(BinaryNode node) // Обход дерева в ширину
        {
            // На вход подаём корневую вершину

            Queue<BinaryNode> children = new Queue<BinaryNode>();

            children.Enqueue(node); // Помещаем корень в очередь

            while(children.Count != 0) // Пока очередь не пуста
            {
                BinaryNode nodeT = children.Dequeue(); // Берём следующую вершину из очереди

                // Здесь можем выполнять какие-нибудь действия

                MessageBox.Show(Convert.ToString(nodeT.value));

                if (nodeT.Left != null)
                    children.Enqueue(nodeT.Left);
                if (nodeT.Right != null)
                    children.Enqueue(nodeT.Right);
            }
        }



        public bool RemoveNode(int value)
        {
            BinaryNode nodeT = new BinaryNode(6666);

            if (!FindNode(node_root, value, ref nodeT)) // Не найдена вершина для удаления
                return false;
            else
            {
                if (nodeT.Left == null && nodeT.Right == null) // Терминальная вершина
                {
                    BinaryNode nodeT2 = new BinaryNode(7777);

                    FindNodeParent(node_root, nodeT.value, ref nodeT2); // Ищем родительскую вершину для удаляемой вершины

                    if (nodeT2.Left == nodeT)
                    {
                        nodeT2.Left = null;
                        count--; // Уменьшаем счётчик количества вершин в дереве
                        return true;
                    }
                    else
                    {
                        nodeT2.Right = null;
                        count--; // Уменьшаем счётчик количества вершин в дереве
                        return true;
                    }
                }
                else if (nodeT.Left != null && nodeT.Right == null) // Имеет только левого потомка
                {
                    BinaryNode nodeT3 = new BinaryNode(8888);
                    FindNodeParent(node_root, nodeT.value, ref nodeT3); // Ищем родительскую вершину для удаляемой вершины
                    nodeT3.Left = nodeT.Left;
                    count--; // Уменьшаем счётчик количества вершин в дереве
                    return true;
                }
                else if (nodeT.Left == null && nodeT.Right != null) // Имеет только правого потомка
                {
                    BinaryNode nodeT4 = new BinaryNode(9000);
                    FindNodeParent(node_root, nodeT.value, ref nodeT4); // Ищем родительскую вершину для удаляемой вершины
                    nodeT4.Right = nodeT.Right;
                    count--; // Уменьшаем счётчик количества вершин в дереве
                    return true;
                }
                else if (nodeT.Left != null && nodeT.Right != null) // Имеет левого и правого потомка
                {
                    BinaryNode nodeT5 = new BinaryNode(9001);
                    FindNodeParent(node_root, nodeT.value, ref nodeT5); // Ищем родительскую вершину для удаляемой вершины

                    if (nodeT.Left.Right == null) // Левый потомок не имеет правого потомка
                    {
                        BinaryNode nodeTT = new BinaryNode(9002);
                        nodeTT = nodeT.Right;
                        nodeT5.Left = nodeT.Left;
                        nodeT.Left.Right = nodeTT;
                        count--; // Уменьшаем счётчик количества вершин в дереве
                        return true;
                    }
                    else if (nodeT.Left.Right != null) //Левый потомок имеет правого потомка
                    {
                        BinaryNode nodeT6 = new BinaryNode(9003);
                        FindNodeParent(node_root, nodeT.value, ref nodeT6); // Ищем родительскую вершину для удаляемой вершины

                        if (nodeT.Left.Right.Right == null) // Правый потомок левого потомка не имеет правого потомка
                        {
                            if (nodeT6.Left == nodeT) // Удаляемая вершина является левым потомком родительской вершины
                            {
                                nodeT6.Left = nodeT.Left.Right.Right;
                                
                            }
                            else
                            {
                                nodeT6.Right = nodeT.Left.Right.Right;

                            }
                        }
                    }
                }
            }

            return false;
        }
            
        public void FindLastRightNode(BinaryNode node, ref BinaryNode result_node)
        {
            // На вход подаём вершину, для которой нужно найти самого нижнего правого потомка

            if (node.Right == null)
            {
                result_node = node;
                return;
            }
            else
                FindLastRightNode(node.Right, ref result_node);
        }

        

    }
}

using System;
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 BinaryTree
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();

        }

        private void Form1_Load(object sender, EventArgs e)
        {

        }

        private void button1_Click(object sender, EventArgs e)
        {
            string nodes_str = textBox1.Text; // Получаем вершины из поля с вершинами

            // Проверка на правильность введённых значений
            if (!CheckString(nodes_str))
                return;

            // Парсим числа из строки в список вершин
            List<int> nodes = new List<int>();
            int[] nodes_temp = nodes_str.Split(" ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries).Select(x => Convert.ToInt32(x)).ToArray();
            nodes.AddRange(nodes_temp);

            BinaryNode root_bn = new BinaryNode(nodes[0]); // Определяем корневую вершину
            nodes.RemoveAt(0); // Убираем из списка вершин первую-корневую вершину
            BinaryTree bt = new BinaryTree(root_bn); // Создаём бинарное дерево

            for (int i = 0; i < nodes.Count; i++)
            {
                bt.AddElement(nodes[i]);
            }

            for (int j = 0; j < nodes.Count; j++) // Проверочный цикл
            {
                listBox1.Items.Add(Convert.ToString(nodes[j]));
            }

            listBox1.Items.Add(" ");

            /*

            // ПРОВЕРКА РЕКУРСИИ

            BinaryNode tempN = new BinaryNode(5555);

            bt.FindNode(root_bn, 4, ref tempN);

            BinaryNode tempN2 = new BinaryNode(5556);

            bt.FindLastRightNode(tempN, ref tempN2);

            listBox1.Items.Add(Convert.ToString(tempN2.value));

            */



            BinaryNode tempN = new BinaryNode(5555);

            bt.FindNode(root_bn, 4, ref tempN);

            BinaryNode tempN2 = new BinaryNode(5556);

            tempN2 = tempN.GetLastRight();

            listBox1.Items.Add(Convert.ToString(tempN2.value));





            DrawBinaryTree(bt);

            //listBox1.Items.Add(Convert.ToString(bt.GetNodesCount()));  // Число вершин в дереве
            //listBox1.Items.Add(Convert.ToString(bt.GetMinValue())); // Минимальное значение
            //listBox1.Items.Add(Convert.ToString(bt.GetMaxValue())); // Максимальное значение

            //bt.TraversePreorder(root_bn); // Прямой обход дерева
            //bt.TraverseInorder(root_bn); // Симметричный обход дерева
            //bt.TraversePostorder(root_bn); // Обход дерева в обратном порядке
            //bt.TraverseDepth(root_bn); // Обход дерева в ширину

            //listBox1.Items.Add(bt.FindValue(root_bn, 9)); // Поиск значения вершины - true или false


            //if(bt.FindNodeParent(root_bn, 9, ref tempN)) // Поиск родительской вершины
            // listBox1.Items.Add(tempN.value);

            //if (bt.FindNodeParent(root_bn, 9, ref tempN)) // Уровень вершины
            // listBox1.Items.Add(tempN.GetLevel());

            //if(bt.Remove(21)) // Удаление вершины
            {
                // bt.Remove(21);
                // bt.TraverseDepth(root_bn);
                //if(bt.FindNodeParent(root_bn, 2, ref tempN)) // Поиск родительской вершины
                // listBox1.Items.Add(tempN.value);
            }

        }



        private bool CheckString(string str)
        {
            for (int i = 0; i < str.Length; i++)
            {
                if (str[i] == ' ')
                    continue;

                if (str[i] == '-')
                    continue;

                if (str[i] >= '0' && str[i] <= '9')
                {
                    continue;
                }

                MessageBox.Show("Ошибка! Допускаются только числовые значения и пробелы между ними.");
                return false;
            }
            return true;
        }

        public void DrawBinaryTree(BinaryTree bt)
        {
            Bitmap image1 = new Bitmap("1.jpg");

            pictureBox1.SizeMode = PictureBoxSizeMode.AutoSize;
            pictureBox1.BorderStyle = BorderStyle.Fixed3D;
            pictureBox1.Image = image1;
        }
       

        private void button3_Click(object sender, EventArgs e)
        {
            int minQuantityOfNodes = Convert.ToInt32(textBox2.Text); // Минимальное количество вершин
            int maxQuantityOfNodes = Convert.ToInt32(textBox3.Text); // Максимальное значение вершин
            int minValueOfNodes = Convert.ToInt32(textBox4.Text); // Минимальное значение вершин
            int maxValueOfNodes = Convert.ToInt32(textBox5.Text); // Максимальное значение вершин

            Random r1 = new Random();
            int quantityOfNodes = r1.Next(minQuantityOfNodes, maxQuantityOfNodes); // Вычисляем количество вершин

            List<int> nodes = new List<int>(); // Создаём список для хранения числовых значений вершин

            BinaryNode root_bn = new BinaryNode(r1.Next(minValueOfNodes, maxValueOfNodes)); // Вычисляем корневую вершину
            BinaryTree bt = new BinaryTree(root_bn); // Создаём бинарное дерево


            for (int i = 0; i < quantityOfNodes - 1; i++)
            {
                nodes.Add(r1.Next(minValueOfNodes, maxValueOfNodes));
            }

            for (int i = 0; i < nodes.Count; i++) // Проверочный цикл
            {
               // listBox1.Items.Add(Convert.ToString(nodes[i]));
            }


        }



        private void textBox2_TextChanged(object sender, EventArgs e)
        {

        }


    }
    }