private void AddTo(_001_TreeNode.BineryTreeNode <T> node, T value)
 {
     if (node.CompareTo(value) > 0)
     {
         if (node.Left == null)
         {
             node.Left = new _001_TreeNode.BineryTreeNode <T>(value);
         }
         else
         {
             AddTo(node.Left, value);
         }
     }
     else
     {
         if (node.Rigth == null)
         {
             node.Rigth = new _001_TreeNode.BineryTreeNode <T>(value);
         }
         else
         {
             AddTo(node.Rigth, value);
         }
     }
 }
Beispiel #2
0
            //Find
            private _001_TreeNode.BineryTreeNode <T> FindWithParent(T value, out _001_TreeNode.BineryTreeNode <T> parent)
            {
                _001_TreeNode.BineryTreeNode <T> current = _head;
                parent = null;

                while (current != null)
                {
                    int result = current.CompareTo(value);

                    if (result > 0)
                    {
                        parent  = current;
                        current = current.Left;
                    }
                    else if (result < 0)
                    {
                        parent  = current;
                        current = current.Rigth;
                    }
                    else
                    {
                        break;
                    }
                }

                return(current);
            }
            // Adde item
            public void Add(T item)
            {
                if (_head == null)
                {
                    _head = new _001_TreeNode.BineryTreeNode <T>(item);
                }
                else
                {
                    AddTo(_head, item);
                }

                _count++;
            }
Beispiel #4
0
            public bool Remove(T value)
            {
                _001_TreeNode.BineryTreeNode <T> current;
                _001_TreeNode.BineryTreeNode <T> parent;

                current = this.FindWithParent(value, out parent);
                if (current == null)
                {
                    return(false);
                }

                Count--;

                // Первый вариант: удаляемый узел не имеет правого потомка
                if (current.Rigth == null)
                {
                    if (parent == null)
                    {
                        _head = current.Left;
                    }
                    else
                    {
                        var result = parent.CompareNode(current);

                        if (result > 0)
                        {
                            parent.Left = current.Left;
                        }
                        else
                        if (result < 0)
                        {
                            parent.Rigth = current.Left;
                        }
                    }
                }
                // Второй вариант: удаляемый узел имеет правого потомка, у которого нет левого потомка
                else if (current.Rigth.Left == null)
                {
                    current.Rigth.Left = current.Left;

                    if (parent == null)
                    {
                        _head = current.Rigth;
                    }
                    else
                    {
                        var result = parent.CompareTo(value);

                        if (result > 0)
                        {
                            parent.Left = current.Rigth;
                        }
                        else
                        {
                            parent.Rigth = current.Rigth;
                        }
                    }
                }
                // Третий вариант: удаляемый узел имеет правого потомка у которого есть левый потомок
                else
                {
                    _001_TreeNode.BineryTreeNode <T> leftmost       = current.Rigth.Left;
                    _001_TreeNode.BineryTreeNode <T> leftmostParent = current.Rigth;

                    while (leftmost != null)
                    {
                        leftmostParent = leftmost;
                        leftmost       = leftmost.Left;
                    }
                    // правое поддерево крайнего левого узла, становится левым поддеревом его родительского узла
                    leftmostParent.Left = leftmost.Rigth;

                    leftmost.Rigth = current.Rigth;
                    leftmost.Left  = current.Left;


                    if (parent == null)
                    {
                        _head = leftmost;
                    }
                    else
                    {
                        var result = parent.CompareTo(current.Value);

                        if (result > 0)
                        {
                            parent.Left = leftmost;
                        }
                        else
                        {
                            parent.Rigth = leftmost;
                        }
                    }
                }

                return(true);
            }