Exemple #1
0
 // walk left-right-root
 public void PrintTreeLrRoot(BinNode <T> startNode)
 {
     if (startNode != null)
     {
         PrintTreeLrRoot(startNode.LeftNode);
         PrintTreeLrRoot(startNode.RightNode);
         Console.Write(startNode.Data);
     }
 }
Exemple #2
0
        // Find member
        public BinNode <T> FindNode(T data, BinNode <T> startWithNode = null)
        {
            startWithNode = startWithNode ?? _rootNode;
            int result;

            return((result = data.CompareTo(startWithNode.Data)) == 0 ?
                   startWithNode
                : result < 0 ?
                   startWithNode.LeftNode == null ?
                   null
                        : FindNode(data, startWithNode.LeftNode)
                    : startWithNode.RightNode == null
                        ? null
                        : FindNode(data, startWithNode.RightNode));
        }
Exemple #3
0
 // Encapsulated overloaded nethod | show tree
 private void PrintTree(BinNode <T> startNode, string indent = "", Side?side = null)
 {
     if (startNode != null)
     {
         const int indentStep = 1;
         var       delim      = indent == "" ? "" : ":";
         var       maxLevel   = indent == "" ? $" (max.height:{_maxLevel - 1})" : "";
         var       nodeLevel  = indent != "" ? $" (level:{startNode.Level})" : "";
         var       nodeSide   = side == null ? "" : side == Side.Left ? "L" : "R";
         Console.Write($"{startNode.Level}|");
         Console.WriteLine($"{indent}{nodeSide}{delim}{startNode.Data}{maxLevel}{nodeLevel}");
         indent += new string(' ', indentStep);
         // recursive call for left branch
         PrintTree(startNode.LeftNode, indent, Side.Left);
         // recursive call for right branch
         PrintTree(startNode.RightNode, indent, Side.Right);
     }
 }
Exemple #4
0
        // Add member to root node
        public BinNode <T> Add(BinNode <T> node, BinNode <T> currentNode = null)
        {
            if (_rootNode == null)
            {
                node.ParentNode = null;
                node.Level      = 1;
                return(_rootNode = node);
            }

            currentNode     = currentNode ?? _rootNode;
            node.ParentNode = currentNode;
            node.Level      = node.ParentNode.Level++;
            if (node.Level > _maxLevel)
            {
                _maxLevel = node.Level;
            }
            int result;

            return((result = node.Data.CompareTo(currentNode.Data)) == 0 ?
                   currentNode :
                   result < 0 ?
                   currentNode.LeftNode == null ? currentNode.LeftNode = node : Add(node, currentNode.LeftNode)
                    : currentNode.RightNode == null ? currentNode.RightNode = node : Add(node, currentNode.RightNode));
        }
Exemple #5
0
        // Remove method | logic
        public void Remove(BinNode <T> node)
        {
            if (node == null)
            {
                return;
            }

            var currentNodeSide = node.NodeSide;

            // delete if has not contains subnodes
            if (node.LeftNode == null && node.RightNode == null)
            {
                if (currentNodeSide == Side.Left)
                {
                    node.ParentNode.LeftNode = null;
                }
                else
                {
                    node.ParentNode.RightNode = null;
                }
            }
            // Right to removal site ( if there is no left )
            else if (node.LeftNode == null)
            {
                if (currentNodeSide == Side.Left)
                {
                    node.ParentNode.LeftNode = node.RightNode;
                }
                else
                {
                    node.ParentNode.RightNode = node.RightNode;
                }

                node.RightNode.ParentNode = node.ParentNode;
            }
            // Left to removal site ( if there is no right )
            else if (node.RightNode == null)
            {
                if (currentNodeSide == Side.Left)
                {
                    node.ParentNode.LeftNode = node.LeftNode;
                }
                else
                {
                    node.ParentNode.RightNode = node.LeftNode;
                }

                node.LeftNode.ParentNode = node.ParentNode;
            }
            // If both are present, right to remove, left to right
            else
            {
                switch (currentNodeSide)
                {
                case Side.Left:
                    node.ParentNode.LeftNode  = node.RightNode;
                    node.RightNode.ParentNode = node.ParentNode;
                    Add(node.LeftNode, node.RightNode);
                    break;

                case Side.Right:
                    node.ParentNode.RightNode = node.RightNode;
                    node.RightNode.ParentNode = node.ParentNode;
                    Add(node.LeftNode, node.RightNode);
                    break;

                default:
                    var bufLeft       = node.LeftNode;
                    var bufRightLeft  = node.RightNode.LeftNode;
                    var bufRightRight = node.RightNode.RightNode;
                    node.Data      = node.RightNode.Data;
                    node.RightNode = bufRightRight;
                    node.LeftNode  = bufRightLeft;
                    Add(bufLeft, node);
                    break;
                }
            }
        }