在下小白一个 如果有错误请指正

上代码：

 

using System;
//数据结构

namespace DataStructure
{
    /// <summary>
    /// 二叉树的实现
    /// </summary>
    /// 

    #region 二叉树的分类

    //     满二叉树
    //        4
    //      /   \
    //     3     5
    //    / \   / \
    //   2   6 1   7

    //     完全二叉树 只有最下面节点数可以小于2并且最下层叶节点集中到左侧
    //         4
    //        / \
    //       3   5
    //      /\   /
    //     2  7 1
    //       /
    //      6

    //     二叉查找树 节点中包含关键字key

    #endregion

    /// <summary>
    /// 二叉树节点
    /// </summary>
    public class TreeNode<T> where T : IComparable<T>
    {
        /// <summary>
        /// key
        /// </summary>
        public T MKey;

        /// <summary>
        /// 父节点
        /// </summary>
        public TreeNode<T> ParentNode;

        /// <summary>
        /// 左侧子节点
        /// </summary>
        public TreeNode<T> LeftChildNodes;

        /// <summary>
        /// 右侧子节点
        /// </summary>
        public TreeNode<T> RightChildNodes;

        /// <summary>
        /// 颜色
        /// </summary>
        public ColorType Mcolor;

        public TreeNode(T key, TreeNode<T> parentNode, TreeNode<T> leftNode, TreeNode<T> rightNode)
        {
            MKey = key;
            ParentNode = parentNode;
            LeftChildNodes = leftNode;
            RightChildNodes = rightNode;
        }

        public TreeNode()
        {
            LeftChildNodes = null;
            RightChildNodes = null;
        }
    }

    public class BinaryTree<T> where T : IComparable<T>
    {
        public TreeNode<T> MRoot;

        public BinaryTree()
        {
            MRoot = null;
        }

        /// <summary>
        /// 增加节点(增)
        /// </summary>
        /// <param name="tree"></param>
        /// <param name="node1"></param>要插入的树
        protected virtual void InsetNode(BinaryTree<T> tree, TreeNode<T> node1)
        {
            int cmp;
            TreeNode<T> node2 = null;
            TreeNode<T> node = tree.MRoot;
            while (node != null)
            {
                node2 = node;
                cmp = node1.MKey.CompareTo(node.MKey);
                node = cmp < 0 ? node.LeftChildNodes : node.RightChildNodes;
            }

            node1.ParentNode = node2;
            if (node2 == null)
                tree.MRoot = node1;

            else
            {
                cmp = node1.MKey.CompareTo(node2.MKey);
                if (cmp > 0)
                    node2.RightChildNodes = node1;
                else
                    node2.LeftChildNodes = node1;
            }

        }

        /// <summary>
        /// 插入树 给定节点
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public virtual void InsetNode(T key)
        {
            TreeNode<T> node = new TreeNode<T>(key, null, null, null);
            InsetNode(this, node);
        }

        /// <summary>
        /// 删除节点（删）并返回删除的节点
        /// </summary>
        private TreeNode<T> RemoveNode(BinaryTree<T> tree, TreeNode<T> removeNode)
        {
            TreeNode<T> node = null;
            TreeNode<T> node1 = null;
            if (removeNode.LeftChildNodes == null || removeNode.RightChildNodes == null)
                node1 = removeNode;
            else
                node1 = FindSucceedNode(removeNode);

            if (node1.LeftChildNodes != null)
                node = node1.LeftChildNodes;
            else
                node = node1.LeftChildNodes;

            if (node != null)
                node.ParentNode = node1.ParentNode;

            if (node1.ParentNode == null)
            {
                tree.MRoot = node;
            }
            else if (node1 == node1.ParentNode.LeftChildNodes)
            {
                node1.ParentNode.LeftChildNodes = node;
            }
            else
            {
                node1.ParentNode.RightChildNodes = node;
            }
            if (node1 != removeNode)
                node1.MKey = removeNode.MKey;
            return node1;
        }

        /// <summary>
        /// 删除节点
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public virtual void RemoveNode(T key)
        {
            TreeNode<T> findNode;
            if ((findNode = FindNode(key, MRoot)) != null)
            {
                TreeNode<T> removeNode = RemoveNode(this, findNode);
                // ReSharper disable once RedundantCheckBeforeAssignment
                if (removeNode != null)
                    removeNode = null;
            }
        }

        /// <summary>
        /// 销毁二叉树
        /// </summary>
        /// <param name="tree"></param>
        protected void DestroyNode(TreeNode<T> tree)
        {
            if (tree == null)
                return;
            if (tree.LeftChildNodes != null)
                DestroyNode(tree.LeftChildNodes);
            if (tree.RightChildNodes != null)
                DestroyNode(tree.RightChildNodes);

            tree = null;
        }

        public void DestroyNode()
        {
            DestroyNode(MRoot);
            MRoot = null;
        }

        /// <summary>
        /// 查找节点1（查）
        /// </summary>
        /// <param name="key"></param>
        /// <param name="treeNode"></param>
        /// <returns></returns>
        public TreeNode<T> FindNode(T key, TreeNode<T> treeNode)
        {
            if (treeNode == null)
            {
                return null;
            }

            int comparable = key.CompareTo(treeNode.MKey);
            if (comparable < 0)
            {
                return FindNode(key, treeNode.LeftChildNodes);
            }
            else if (comparable > 0)
            {
                return FindNode(key, treeNode.RightChildNodes);
            }
            else
            {
                return treeNode;
            }
        }

        /// <summary>
        /// 查找节点2（查）
        /// </summary>
        /// <param name="key"></param>
        /// <param name="treeNode"></param>
        /// <returns></returns>
        protected TreeNode<T> IterativeFindNode(T key, TreeNode<T> treeNode)
        {
            while (treeNode != null && key != null)
            {
                int comparable = key.CompareTo(treeNode.MKey);
                if (comparable > 0)
                {
                    treeNode = treeNode.RightChildNodes;
                }
                else if (comparable < 0)
                {
                    treeNode = treeNode.LeftChildNodes;
                }
            }
            return treeNode;
        }

        /// <summary>
        /// 查找节点
        /// </summary>
        /// <param name="key"></param>根据key
        /// <returns></returns>
        public virtual TreeNode<T> IterativeFindNode(T key)
        {
            return IterativeFindNode(key, MRoot);
        }

        /// <summary>
        /// 查找最大值
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        protected TreeNode<T> FindMaxNode(TreeNode<T> node)
        {
            if (node == null)
                return null;

            while (node.RightChildNodes != null)
            {
                node = node.RightChildNodes;
            }
            return node;
        }

        public T FindMax()
        {
            TreeNode<T> node = FindMaxNode(MRoot);
            if (node != null)
                return node.MKey;
            return default(T);
        }

        /// <summary>
        /// 查找最小值
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        protected TreeNode<T> FindMinNode(TreeNode<T> node)
        {
            if (node == null)
                return null;

            while (node.LeftChildNodes != null)
                node = node.LeftChildNodes;

            return node;
        }

        /// <summary>
        /// 查找最小值 根据key
        /// </summary>
        /// <returns></returns>
        public T FindMin()
        {
            TreeNode<T> node = FindMinNode(MRoot);
            if (node != null)
                return node.MKey;
            return default(T);
        }

        /// <summary>
        /// 寻找前驱
        /// </summary>前驱就是寻找小于该节点的最大节点
        /// <param name="node"></param>
        /// <returns></returns>
        ///          9   
        ///        /   \
        ///       5    12
        ///           /  \
        ///          10  25
        ///         /  \
        ///        8   20 
        ///       / \  
        ///      6  15
        /// 6的前驱节点是5  15的前驱节点是12    12的前驱节点是10
        public TreeNode<T> FindPrecursorNode(TreeNode<T> node)
        {
            if (node == null)
                return null;

            if (node.LeftChildNodes != null)
                return FindMaxNode(node.LeftChildNodes);
            TreeNode<T> parentNode = node.ParentNode;
            while (parentNode != null && parentNode.LeftChildNodes == node)
            {
                node = parentNode;
                parentNode = parentNode.ParentNode;
            }
            return parentNode;
        }

        /// <summary>
        /// 寻找后继
        /// </summary>后继就是寻找大于该节点的最小节点
        ///          9   
        ///        /   \
        ///       5    12
        ///           /  \
        ///          10  25
        ///         /  \
        ///        8   20 
        ///       / \  
        ///      6  15
        /// 6的后继节点是8  15的后继节点是20    12的后继节点是15
        /// <param name="node"></param>
        /// <returns></returns>
        public TreeNode<T> FindSucceedNode(TreeNode<T> node)
        {
            if (node == null)
                return null;
            if (node.RightChildNodes != null)
                return FindMinNode(node.RightChildNodes);

            TreeNode<T> parentNode = node.ParentNode;
            while (parentNode != null && parentNode.RightChildNodes == node)
            {
                node = parentNode;
                parentNode = node.ParentNode;
            }
            return parentNode;
        }

        /// <summary>
        /// 前序遍历
        /// 访问根节点
        /// 遍历左子树
        /// 遍历右子树
        /// </summary>
        protected virtual void PreorderBStree(TreeNode<T> tree)
        {
            if (tree != null)
            {
                Console.Write(tree.MKey + "\n");

                var tree1 = tree as AVLNode<T>;
                if (tree1 != null) Console.Write("high:" + tree1.Mhight + "\n");

                PreorderBStree(tree.LeftChildNodes);
                PreorderBStree(tree.RightChildNodes);
            }
        }

        /// <summary>
        /// 前序遍历
        /// </summary>
        public virtual void PreorderBStree()
        {
            PreorderBStree(MRoot);
        }

        /// <summary>
        /// 中序遍历
        /// 遍历左子树
        /// 访问根节点
        /// 遍历右子树
        /// </summary>
        protected virtual void InorderBStree(TreeNode<T> tree)
        {
            if (tree != null)
            {
                PreorderBStree(tree.LeftChildNodes);
                Console.Write(tree.MKey + "\n");

                var tree1 = tree as AVLNode<T>;
                if (tree1 != null) Console.Write("high:" + tree1.Mhight + "\n");

                PreorderBStree(tree.RightChildNodes);
            }
        }

        /// <summary>
        /// 中序遍历
        /// </summary>
        public virtual void InorderBStree()
        {
            InorderBStree(MRoot);
        }

        /// <summary>
        /// 后序遍历
        /// 遍历左子树
        /// 遍历右子树
        /// 访问根节点
        /// </summary>
        protected virtual void PostorderBStree(TreeNode<T> tree)
        {
            if (tree != null)
            {
                PreorderBStree(tree.LeftChildNodes);
                PreorderBStree(tree.RightChildNodes);
                Console.Write(tree.MKey + "\n");

                var tree1 = tree as AVLNode<T>;
                if (tree1 != null) Console.Write("high:" + tree1.Mhight + "\n");
            }
        }

        /// <summary>
        /// 后序遍历
        /// </summary>
        public virtual void PostorderBStree()
        {
            PostorderBStree(MRoot);
        }
    }
}