求二叉树中节点的最大距离...

求二叉树中节点的最大距离...

如果我们把二叉树看成一个图，
父子节点之间的连线看成是双向的，
我们姑且定义"距离"为两节点之间边的个数。
写一个程序，
求一棵二叉树中相距最远的两个节点之间的距离。

 

计算一个二叉树的最大距离有两个情况:

• 情况A: 路径经过左子树的最深节点，通过根节点，再到右子树的最深节点。
• 情况B: 路径不穿过根节点，而是左子树或右子树的最大距离路径，取其大者。

只需要计算这两个情况的路径距离，并取其大者，就是该二叉树的最大距离。

 

C# codes as below:

 

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            TreeNode<int> node1 = new TreeNode<int>();
            node1.Data = 1;

            TreeNode<int> node2 = new TreeNode<int>();
            node2.Data = 2;

            TreeNode<int> node3 = new TreeNode<int>();
            node3.Data = 3;

            TreeNode<int> node4 = new TreeNode<int>();
            node4.Data = 4;

            TreeNode<int> node5 = new TreeNode<int>();
            node5.Data = 5;

            TreeNode<int> node6 = new TreeNode<int>();
            node6.Data = 6;

            TreeNode<int> node7 = new TreeNode<int>();
            node7.Data = 7;

            TreeNode<int> node8 = new TreeNode<int>();
            node8.Data = 8;

            TreeNode<int> node9 = new TreeNode<int>();
            node9.Data = 9;

            node1.LeftSon = node2;
            node1.RightSon = node3;

            node3.LeftSon = node4;
            node3.RightSon = node5;

            node4.LeftSon = node7;

            node5.RightSon = node6;

            Tree<int> tree = new Tree<int>();
            tree.Root = node1;

            Console.WriteLine(Tree<int>.CountMaxLength(node1));

            Tree<int>.Print2(tree);

            Console.ReadKey();
        }
    }

    class Tree<T>
    {
        public TreeNode<T> Root;

        /// <summary>
        /// 求二叉树中节点的最大距离
        /// </summary>
        public static int CountMaxLength(TreeNode<T> node)
        {
            if (node == null)
            {
                return -1;
            }

            int length1 = MaxLevelCount(node.LeftSon, 0) + MaxLevelCount(node.RightSon, 0) + 2;

            int length2 = CountMaxLength(node.LeftSon);

            int length3 = CountMaxLength(node.RightSon);

            if (length1 > length2)
            {
                length2 = length1;
            }

            if (length2 > length3)
            {
                length3 = length2;
            }

            return length3;
        }

        /// <summary>
        /// 计算二叉树的深度
        /// </summary>
        private static int MaxLevelCount(TreeNode<T> root, int level)
        {
            if (root == null)
            {
                return -1;
            }
            else if (root.LeftSon == null && root.RightSon == null)
            {
                return level;
            }
            else
            {
                int leftLevel = MaxLevelCount(root.LeftSon, level + 1);
                int rightLevel = MaxLevelCount(root.RightSon, level + 1);
                return leftLevel > rightLevel ? leftLevel : rightLevel;
            }
        }

        /// <summary>
        /// 广度优先遍历二叉树
        /// </summary>
        public static void Print2(Tree<T> tree)
        {
            if (tree.Root == null)
            {
                return;
            }
            else
            {
                Queue<TreeNode<T>> queue = new Queue<TreeNode<T>>();
                queue.Enqueue(tree.Root);

                while (queue.Count != 0)
                {
                    int currentLevelCount = queue.Count;

                    for (int i = 0; i < currentLevelCount; i++)
                    {
                        TreeNode<T> node = queue.Dequeue();

                        if (node.Data != null)
                        {
                            Console.Write(node.Data);
                        }

                        if (node.LeftSon != null)
                        {
                            queue.Enqueue(node.LeftSon);
                        }

                        if (node.RightSon != null)
                        {
                            queue.Enqueue(node.RightSon);
                        }
                    }

                    Console.WriteLine();
                }
            }
        }
    }

    class TreeNode<T>
    {
        public T Data;

        public TreeNode<T> LeftSon;
        public TreeNode<T> RightSon;
    }
}