Изменить обход по дереву

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace InformationSystemKadri
{
    /// <summary>
    /// Node of tree, which contains information about object of tree and next leafs.
    /// </summary>
    public class BinaryTreeNode<T>
    {
 
        #region Fields
 
        /// <summary>
        /// Data in node.
        /// </summary>
        private T _data;
 
        /// <summary>
        /// Left node.
        /// </summary>
        private BinaryTreeNode<T> leftNode;
 
        /// <summary>
        /// Right node.
        /// </summary>
        private BinaryTreeNode<T> rightNode;
 
        /// <summary>
        /// Parent node.
        /// </summary>
        private BinaryTreeNode<T> parentNode;
        
        /// <summary>
        /// Offset - left to right (0 is center)
        /// </summary>
        private int _offset;                 
 
        /// <summary>
        /// Depth - top to bottom.
        /// </summary>
        private int _depth;
 
        #endregion
 
        /// <summary>
        /// Constructor with parameters.
        /// </summary>
        /// <param name="data">Data.</param>
        public BinaryTreeNode(T data)
        {
            _data = data;
        }
 
        #region Properties        
 
        public BinaryTreeNode<T> Left
        {
            get { return leftNode; }
            set { leftNode = value; }
        }
 
        public BinaryTreeNode<T> Right
        {
            get { return rightNode; }
            set { rightNode = value; }
        }
 
        public BinaryTreeNode<T> Parent
        {
            get { return parentNode; }
            set { parentNode = value; }
        }
 
        public T Data
        {
            get { return _data; }
            set { _data = value; }
        }
 
        public int Offset
        {
            get { return _offset; }
            set { _offset = value; }
        }
 
        public int Depth
        {
            get { return _depth; }
            set { _depth = value; }
        }
 
        #endregion
                     
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
using System.Reflection;
 
namespace InformationSystemKadri.Classes
{    
 
    /// <summary>
    /// Generic class, which allow to work with information with help of binary tree.
    /// </summary>
    /// <typeparam name="T">Type of data, what conatains node of tree.</typeparam>
    public class BinaryTree<T> where T : IComparable
    {
        /// <summary>
        /// Root of tree.
        /// </summary>
        private BinaryTreeNode<T> _center;        
 
        /// <summary>
        /// Property for access to root of tree.
        /// </summary>
        public BinaryTreeNode<T> Center
        {
            get { return _center; }
        }               
 
        /// <summary>
        /// Method for adding new node to the tree.
        /// </summary>
        /// <param name="data">New data.</param>
        /// <returns>New node.</returns>
        public BinaryTreeNode<T> Add(T data)
        {
            if (_center == null)
            {
                _center = new BinaryTreeNode<T>(data);
                _center.Depth = 1;
                _center.Offset = 0;
                return _center;
            }
            else
            {
                BinaryTreeNode<T> current = _center;
                BinaryTreeNode<T> next;
                int nodeDepth = _center.Depth;
                int nodeOffset = _center.Offset;
                while (true)
                {
                    nodeDepth++;
                    if (data.CompareTo(current.Data) <= 0)
                    {
                        nodeOffset--;
                        next = current.Left;
                        if (next == null)
                        {
                            current.Left = new BinaryTreeNode<T>(data);                            
                            current.Left.Parent = current;
                            if (nodeDepth == current.Depth)
                            {
                                nodeDepth++;
                            }
                            current.Left.Depth = nodeDepth;                            
                            current.Left.Offset = nodeOffset;
                            return current.Left;                            
                        }
                    }
                    else
                    {
                        nodeOffset++;
                        next = current.Right;
                        if (next == null)
                        {
                            current.Right = new BinaryTreeNode<T>(data);
                            current.Right.Parent = current;
                            if (nodeDepth == current.Depth)
                            {
                                nodeDepth++;
                            }
                            current.Right.Depth = nodeDepth;
                            current.Right.Offset = nodeOffset;
                            return current.Right;                            
                        }
                    }
                    current = next;
                }
 
            }
        }
 
        /// <summary>
        /// Remove node from the tree.
        /// </summary>
        /// <param name="node"></param>
        public void Remove(BinaryTreeNode<T> node)
        {
            // If node is null.
            if (node == null) return;            
 
            // If children are null.
            if (node.Right == null && node.Left == null)
            {                
                if (node == node.Parent.Left) node.Parent.Left = null;
                else node.Parent.Right = null;
            }            
            else 
            {                                                           
                if (node == node.Parent.Left)
                {
                    node.Parent.Left = node.Left;
                    if (node.Left == null)
                    {
                        node.Parent.Left = node.Right;
                        SetDepth(node.Parent, node.Parent.Depth, node.Parent.Offset);
                    }
                    else
                    {
                        node.Parent.Left.Depth = node.Parent.Depth + 1;
                        BinaryTreeNode<T> rightBranch = MostRightNode(node.Parent);
                        rightBranch.Right = node.Right;
                        SetDepth(rightBranch.Right, rightBranch.Depth + 1, rightBranch.Offset - 1);
                    }
                }
                else
                {
                    node.Parent.Right = node.Right;
                    if (node.Right == null)
                    {
                        node.Parent.Right = node.Left;
                        SetDepth(node.Parent, node.Parent.Depth, node.Parent.Offset);
                    }
                    else
                    {
                        node.Parent.Right.Depth = node.Parent.Depth + 1;
                        BinaryTreeNode<T> leftBranch = MostLeftNode(node.Parent);
                        leftBranch.Left = node.Left;
                        SetDepth(leftBranch.Left, leftBranch.Depth + 1, leftBranch.Offset + 1);
                    }
                }                
            }
        }
 
        /// <summary>
        /// Finds the most right node of the given node childs.
        /// </summary>
        /// <param name="node">Parent node.</param>
        /// <returns>Most right node.</returns>
        private BinaryTreeNode<T> MostRightNode(BinaryTreeNode<T> node)
        {
            if (node.Right != null)
                return MostRightNode(node.Right);
            else return node;            
        }
 
        /// <summary>
        /// Finds the most left node of the given node childs.
        /// </summary>
        /// <param name="node">Parent node.</param>
        /// <returns>Most left node.</returns>
        private BinaryTreeNode<T> MostLeftNode(BinaryTreeNode<T> node)
        {   
            if (node.Left != null)
                return MostLeftNode(node.Left);
            else return node;
        }
 
        /// <summary>
        /// Bypassing tree(recursion method).
        /// </summary>
        /// <param name="node">Parent node.</param>
        /// <param name="data">Data, what needs to find.</param>
        /// <returns>Finded node, or null.</returns>
        public BinaryTreeNode<T> TreeBypass(BinaryTreeNode<T> node, T data)
        {
            // Compare two objects.
            if (Treatment(node.Data, data) == true) return node;
 
            // If left node is not null.
            if (node.Left != null && data.CompareTo(node.Data) <= 0)
                return TreeBypass(node.Left, data);
 
            // If right node is not null.
            if (node.Right != null && data.CompareTo(node.Data) > 0)
                return TreeBypass(node.Right, data);
            return null;            
        }
 
        /// <summary>
        /// Bypasing tree(recursion method), and format list of nodes.
        /// </summary>
        /// <param name="node">Parent node.</param>
        /// <param name="nodes">List of nodes.</param>
        public void TreeBypass(BinaryTreeNode<T> node, List<BinaryTreeNode<T>> nodes)
        {
            nodes.Add(node);
            if (node.Left != null)
                TreeBypass(node.Left, nodes);
            if (node.Right != null)
                TreeBypass(node.Right, nodes);
        }
 
        /// <summary>
        /// Compare two data objects.
        /// </summary>
        /// <param name="data1">First data object.</param>
        /// <param name="data2">Second data object.</param>
        /// <returns>Returns true if data1 equals data2, otherwise - false.</returns>
        private bool Treatment(T data1, T data2)
        {
            if (data1.Equals(data2))            
                return true;            
            else return false;                   
        }                       
 
        /// <summary>
        /// Change data of node.
        /// </summary>
        /// <param name="node">Node, which data needs to change.</param>
        /// <param name="data">New data.</param>
        /// <param name="radical">If changes key - true, otherwise - false.</param>
        public void ChangeData(BinaryTreeNode<T> node, T data, bool radical = true)
        {
            if (node != _center && radical == true)
            {
                Remove(node);
                Add(data);
            }
            else
            {
                node.Data = data;
            }
        }       
 
        /// <summary>
        /// Set depth, for graphical output of tree.
        /// </summary>
        /// <param name="node">Parent node.</param>
        /// <param name="depth">Depth of node.</param>
        /// <param name="offset">Offset of node.</param>
        private void SetDepth(BinaryTreeNode<T> node, int depth, int offset)
        {            
            if (node != null)
            {
                node.Depth = depth;
                node.Offset = offset;
                if (node.Left != null)
                {
                    SetDepth(node.Left, depth + 1, offset - 1);
                }
                if (node.Right != null)
                {
                    SetDepth(node.Right, depth + 1, offset + 1);
                }                
            }            
        }        
    }
}