C#数据结构与算法学习笔记 删除树中元素，计算树的最大高度

1.删除最大和最小元素

找到最小值、最大值：

        public E Min()
        {
            if (IsEmpty)
                throw new ArgumentException("空树！");

            return Min(root).e;
        }
        //返回以node为根的二叉查找树的最小值所在的节点
        private Node Min(Node node)
        {
            if (node.left == null)
                return node;

            return Min(node.left);
        }

        public E Max()
        {
            if (IsEmpty)
                throw new ArgumentException("空树！");

            return Max(root).e;
        }
        //返回以node为根的二叉查找树的最大值所在的节点
        private Node Max(Node node)
        {
            if (node.right == null)
                return node;

            return Max(node.right);
        }

删除最小值、最大值：

        //从二叉查找树中删除最小值所在节点
        public E RemoveMin()
        {
            E ret = Min();
            root = RemoveMin(root);
            return ret;
        }
        //删除掉以node为根的二叉查找树中的最小节点
        //返回删除节点后新的二叉查找树的根
        private Node RemoveMin(Node node)
        {
            if (node.left == null)
            {
                N--;
                return node.right;
            }

            node.left = RemoveMin(node.left);
            return node;
        }

        //从二叉查找树中删除最大值所在节点
        public E RemoveMax()
        {
            E ret = Max();
            root = RemoveMax(root);
            return ret;
        }
        //删除掉以node为根的二叉查找树中的最大节点
        //返回删除节点后新的二叉查找树的根
        private Node RemoveMax(Node node)
        {
            if (node.right == null)
            {
                N--;
                return node.left;
            }

            node.right = RemoveMax(node.right);
            return node;
        }

测试：

    class Program
    {
        static void Main(string[] args)
        {
            int[] a = { 8, 4, 12, 2, 6, 10, 14 };

            ///
            //         8         //
            //     /       \     //
            //    4        12    //
            //  /   \     /   \  //
            // 2     6   10   14 //
            ///

            BST1<int> bst = new BST1<int>();

            for (int i = 0; i < a.Length; i++)
                bst.Add(a[i]);

            bst.InOrder();
            Console.WriteLine();

            Console.WriteLine("删除最小值：");
            bst.RemoveMin();
            bst.InOrder();
            Console.WriteLine();

            Console.WriteLine("删除最大值：");
            bst.RemoveMax();
            bst.InOrder();

            Console.Read();
        }
    }

2.删除任意元素

        public void Remove(E e)
        {
            root= Remove(root, e);
        }

        //删除以node为根的二叉查找树中值为e的节点
        //返回删除节点后新的二叉查找树的根
        private Node Remove(Node node, E e)
        {
            if (node == null)
                return null;

            if (e.CompareTo(node.e) < 0)
            {
                node.left = Remove(node.left, e);
                return node;
            }
            else if (e.CompareTo(node.e) > 0)
            {
                node.right = Remove(node.right, e);
                return node;
            }
            else   //e.CompareTo(node.e)>0
            {
                if (node.right == null)
                {
                    N--;
                    return node.left;
                }
                if (node.left == null)
                {
                    N--;
                    return node.right;
                }
                //要删除的节点左右都有孩子
                //找到比待删除节点大的最小节点，即待删除节点右子树的最小节点
                //用这个节点顶替待删除节点的位置
                Node s = Min(node.right);
                s.right=RemoveMin(node.right);
                s.left = node.left;

                return s;
            }
        }

测试：

    class Program
    {
        static void Main(string[] args)
        {
            int[] a = { 8, 4, 12, 2, 6, 10, 14 };

            ///
            //         8         //
            //     /       \     //
            //    4        12    //
            //  /   \     /   \  //
            // 2     6   10   14 //
            ///

            BST1<int> bst = new BST1<int>();

            for (int i = 0; i < a.Length; i++)
                bst.Add(a[i]);

            bst.Remove(10);
            bst.InOrder();

            Console.Read();
        }
    }

3.树的最大高度及性能分析

计算二叉树的最大高度：

        //二叉树的最大高度
        public int MaxHeigh()
        {
            return MaxHeigh(root);
        }
        //计算以node为根的二叉树的最大高度
        private int MaxHeigh(Node node)
        {
            if (node == null)
                return 0;

            //计算左右子树的高度
            int l = MaxHeigh(node.left);
            int r = MaxHeigh(node.right);

            return Math.Max(l, r) + 1;
        }

测试：

    class Program
    {
        static void Main(string[] args)
        {
            int[] a = { 8, 4, 12, 2, 6, 10, 14 };

            ///
            //         8         //
            //     /       \     //
            //    4        12    //
            //  /   \     /   \  //
            // 2     6   10   14 //
            ///

            BST1<int> bst = new BST1<int>();

            for (int i = 0; i < a.Length; i++)
                bst.Add(a[i]);

            Console.WriteLine(bst.MaxHeigh());

            Console.Read();
        }
    }