C#二叉树

public class Node

    {
        public int data;//数据在树中的位置
        public object obj;//存放真正的数据
        public Node right;
        public Node left;
        //输出
        public void DisplayNode()
        {
            Console.WriteLine(data);
        }
    }
    public class BinarySearchTree
    {
        public Node root;
        public BinarySearchTree()
        {
            root = null;
        }
        //插入数据
        public void Insert(int i)// public void Insert(int i,object obj)就可以添加其他数据类型
        {
            Node newNode = new Node();
            newNode.data = i;
            //如果是没有首节点则作为首节点
            if (root == null)
            {
                root = newNode;
            }
            else
            {
                Node current = root;
                Node parent;
                while (true)
                {
                    parent = current;
                    //如果小于父节点则插入左节点
                    if (i < current.data)
                    {
                        current = current.left;
                        if (current == null)
                        {
                            parent.left = newNode;
                            break;
                        }
                    }
                    //如果大于父节点则插入右节点
                    else
                    {
                        current = current.right;
                        if (current == null)
                        {
                            parent.right = newNode;
                            break;
                        }
                    }
                }
            }
        }
        //中序遍历法data从小到大
        public void InOrder(Node theRoot)
        {
            if (!(theRoot == null))
            {
                InOrder(theRoot.left);
                theRoot.DisplayNode();
                InOrder(theRoot.right);
            }
        }
        //先序遍历先父节点再左节点最好又节点
        public void PreOrder(Node theRoot)
        {
            if (!(theRoot == null))
            {
                theRoot.DisplayNode();
                PreOrder(theRoot.left);
                PreOrder(theRoot.right);
            }
        }
        //后序遍历法先左节点在右节点最后父节点
        public void PostOrder(Node theRoot)
        {
            if (!(theRoot == null))
            {
                PostOrder(theRoot.left);
                PostOrder(theRoot.right);
                theRoot.DisplayNode();
            }
        }
        //查找最小值
        public int FindMin()
        {
            Node current = root;
            while (!(current.left == null))
                current = current.left;
            return current.data;
        }
        //查找最大值
        public int FindMax()
        {
            Node current = root;
            while (!(current.right == null))
                current = current.right;
            return current.data;
        }
        //查找key
        public Node Find(int key)
        {
            Node current = root;
            while (current.data != key)
            {
                if (key < current.data)
                    current = current.left;
                else
                    current = current.right;
                if (current == null)
                    return null;
            }
            return current;
        }
        //删除有有两个节点时候 查找删除节点后继节点
        public Node GetSuccesor(Node delNode)
        {
            Node successorparent = delNode.right;
            Node successor = delNode;
            Node current = delNode.right;
            //为了找到后继节点，要到原始节点的右子节点上，根据定义这个节点必须比原始节点大。
            //然后开始沿着左子节点直到null为止，沿着这条路径到达末端就会找到大于原始节点的最小节点
            while (!(current == null))
            {
                int i = 0;
                if (i != 0)
                    //获取那最小节点的上一节点，
                    successorparent = successorparent.left;
                //获取那最小节点
                successor = current;
                current = current.left;
                i++;
            }
            if (!(successor == delNode.right))
            {
                //让最小节点的右节点 为 那删除节点的右节点
                successor.right = delNode.right;
                //让最小节点上一节点的 左节点也就是 那移动了最小节点为null
                successorparent.left = null;
            }
            return successor;
        }
        //删除节点
        public bool Delete(int key)
        {
            Node current = root;
            Node parent = root;
            bool isleftchilde = true;
            //查找到要删除的节点 parent是要删除节点的上一节点
            while (current.data != key)
            {
                parent = current;
                //小于所以在左节点
                if (key < current.data)
                {
                    isleftchilde = true;
                    current = current.left;
                }
                //大于就在右节点
                else
                {
                    isleftchilde = false;
                    current = current.right;
                }
                //为空则返回空
                if (current == null)
                    return false;
            }
            //这是在要删除节点无子节点的情况下
            if ((current.left == null) && (current.right == null))
            {
                //如果是首节点这为空
                if (current == root)
                {
                    root = null;
                }
                //在左节点 则让要删除节点上一节点的左子节（即为要删除的节点）点为null
                else if (isleftchilde)
                {
                    parent.left = null;
                }
                //在右节点 则让要删除节点上一节点的右子节点（即为要删除的节点）点为null
                else
                {
                    parent.right = null;
                }
            }
            //要删除的节点具有左节点无右节点  则让要删除节点上一节点子节（即为要删除的节点）为该节点的左子节点
            else if (current.right == null)
            {
                if (current == root)
                    root = current.left;
                else if (isleftchilde)
                    //该删除节点是父节点的左节点  则让父节点的左节点设置为删除节点的左节点
                    parent.left = current.left;
                else
                    //该删除节点是父节点的右节点  则让父节点的左节点设置为删除节点的左节点
                    parent.right = current.left;
            }
            //要删除的节点具有右节点无左节点  则让要删除节点上一节点子节（即为要删除的节点）为该节点的右子节点
            else if ((current.left == null))
            {
                if (current == root)
                {
                    root = current.right;
                }
                else if (isleftchilde)
                {
                    //该删除节点是父节点的右节点 则让父节点的有节点设置为删除节点的右节点
                    parent.left = current.right;
                }
                else
                {
                    //该删除节点是父节点的右节点 则让父节点的有节点设置为删除节点的右节点
                    parent.right = current.right;
                }
            }
            else
            {
                Node successor = GetSuccesor(current);
                if (current == root)
                    root = successor;
                else if (isleftchilde)
                    //该删除节点是父节点的左节点 等于移动上来的那个节点
                    parent.left = successor;
                else
                    //该删除节点是父节点的右节点 等于移动上来的那个节点
                    parent.right = successor;
                //让移动上来的节点的左节点 等于那删除了的节点的左节点
                successor.left = current.left;
            }
            return true;
        }