C#二叉查找树实现

public class BinarySerachTree
    {
        private TreeNode HeadNode;

        public BinarySerachTree(TreeNode headNode)
        {
            HeadNode = headNode;
        }

        #region 插入查找二叉树
        public void Insert(int data)
        {
            TreeNode InsertNode = new TreeNode(data);
            if (HeadNode == null)
            {
                HeadNode = InsertNode;
                return;
            }
            //指针指向头部
            TreeNode CurrentNode=HeadNode;
           
            while (CurrentNode!=null)
            {
                TreeNode parentNode = CurrentNode;
                if(data>CurrentNode.data)
                {
                    CurrentNode = CurrentNode.Right;
                    if(CurrentNode==null)
                    {
                        parentNode.Right = InsertNode;
                    }
                }
                else
                {
                    CurrentNode = CurrentNode.Left;
                    if(CurrentNode==null)
                    {
                        parentNode.Left = InsertNode;
                    }
                }
            }
        }
        #endregion
        #region 中序遍历
        public void InOrder()
        {
            DebugOrder(HeadNode);
        }

        private void DebugOrder(TreeNode tree)
        {
            if (tree != null)
            {
                DebugOrder(tree.Left);
                Console.WriteLine(tree.data);
                DebugOrder(tree.Right);
            }
        }
        #endregion
        #region 前序遍历
        public void InPre()
        {
            DebugPre(HeadNode);
        }
        private void DebugPre(TreeNode tree)
        {
            if(tree != null)
            {
                Console.WriteLine(tree.data);
                DebugPre(tree.Left);
                DebugPre(tree.Right);
            }
        }
        #endregion
        #region 后序遍历
        public void InLast()
        {
            DebugLast(HeadNode);
        }

        private void DebugLast(TreeNode tree)
        {
            if (tree != null)
            {
                DebugLast(tree.Left);
                DebugLast(tree.Right);
                Console.WriteLine(tree.data);
            }
        }
        #endregion

        public bool DeleteNode(int data)
        {
            //指向当前节点的父节点
            TreeNode parent= HeadNode;
            //指向当前遍历到的节点
            TreeNode current = HeadNode;
            //判断是否是子节点是否在左边
            bool isLeft=true;
            //遍历查找树直到找到数据相同的子节点
            while(current.data != data)
            {
                //指针指向父节点
                parent = current;
                //当当前节点的储存的数大于查找节点时遍历左子树否则遍历右子树
                if (current.data>data)
                {
                    current = current.Left;
                    isLeft = true;
                }
                else
                {
                    current = current.Right;
                    isLeft = false;
                }
            }
            //没查找到返回flse
            if (current == null)
            {
                return false;
            }
            //当当前节点左右节点都为空时即当前节点是叶子节点时
            if(current.Left==null&& current.Right==null)
            {
                //当前节点是左子节点时父节点的左子节点置为空(删除当前左节点)
                if(isLeft)
                {
                    parent.Left = null;
                }
                else
                {
                    //当前节点是右子节点时父节点的右子节点置为空(删除当前右节点)
                    parent.Right = null;
                }
                return true;
            }
            //当当前节点的左子树为空时(右子树同理下面的注释就不写了)
            else if(current.Left==null)
            {
                //如果当前节点等于头节点那么代表了当前二叉查找树只有右子树
                if(current==HeadNode)
                {
                    //删除头节点并指向右子树
                    HeadNode = current.Right;
                }
                //如果当前节点是父节点的左子树的话，父节点左子树指向当前节点的右子树
                else if(isLeft)
                {
                    parent.Left = current.Right;
                }
                //如果当前节点是父节点的右子树的话，父节点右子树指向当前节点的右子树
                else
                {
                    parent.Right = current.Right;
                }
            }
            else if(current.Right == null)
            {
                if (current == HeadNode)
                {
                    HeadNode = current.Left;
                }
                else if (isLeft)
                {
                    parent.Left = current.Left;
                }
                else
                {
                    parent.Right = current.Left;
                }
            }
            //当当前节点左右节点都不为空时
            else
            {
                TreeNode delNode = current;
                TreeNode nodeOrder = GetSuccessor(delNode);
                //如果当前节点为头节点时头节点指向该后继节点
                if(current==HeadNode)
                {
                    nodeOrder.Left = HeadNode.Left;
                    nodeOrder.Right = HeadNode.Right;
                    HeadNode = nodeOrder;
                    return true;
                }
                if (isLeft)
                {
                    parent.Left = nodeOrder;
                }
                else
                {
                    parent.Right = nodeOrder;
                }
                //重新连接后继节点和当前的子树
                nodeOrder.Right = current.Right;
                nodeOrder.Left = current.Left;
                //delNode.data = node.data;
            }
            return true;
        }
        /// <summary>
        /// 得到要删除的后继节点
        /// </summary>
        /// <param name="delNode"></param>
        /// <returns></returns>
        private TreeNode GetSuccessor(TreeNode delNode)
        {
            //指针指向当前节点的父节点
            TreeNode parent = delNode;
            //当前节点为要删除的节点的右子树
            TreeNode currentNode = delNode.Right;
            //遍历得到当前节点的后继节点
            while(currentNode.Left != null)
            {
                parent = currentNode;
                currentNode = currentNode.Left;
            }
            //当当前节点的右子树不为空时要将后继节点删除时
            //父节点的左子树指向当前节点的右子树
            //由于这是最小的节点，所以不会有左子树
            if(currentNode.Right!=null)
            {
                parent.Left = currentNode.Right;
            }
            else
            {
                //当当前节点的右子树为空时将后继节点删除时
                //直接将当前左子树置为空
                parent.Left = null;
            }
            //返回后继节点
            return currentNode;
        }
    }

一下是TreeNode类

public class TreeNode
 {
     public int data;

     public TreeNode Left;

     public TreeNode Right;

     public TreeNode(int data)
     {
         this.data = data;
         Left = null;
         Right = null;
     }
 }