求一个二叉树中任意两个节点间的距离，

网易有道笔试：
(1).
求一个二叉树中任意两个节点间的距离，
两个节点的距离的定义是 这两个节点间边的个数，
比如某个孩子节点和父节点间的距离是1，和相邻兄弟节点间的距离是2，优化时间空间复杂度。

 

C# codes as below:

 

using System;

 

namespace ConsoleApp

{

    class RunClass

    {

        static void Main()

        {

            Node<int> i1 = new Node<int>() { Value = 4 };

            Node<int> i2 = new Node<int>() { Value = 8 };

            Node<int> i3 = new Node<int>() { Value = 12 };

            Node<int> i4 = new Node<int>() { Value = 16 };

            Node<int> i5 = new Node<int>() { Value = 6, Left = i1, Right = i2 };

            Node<int> i6 = new Node<int>() { Value = 14, Left = i3, Right = i4 };

            Node<int> i7 = new Node<int>() { Value = 10, Left = i5, Right = i6 };

            Tree<int> tree = new Tree<int>() { Root = i7 };

 

 

 

            int distance = new Helper().GetDistance<int>(tree, i4, i1);

 

            Console.WriteLine(distance);

           

            Console.ReadLine();

        }

    }

 

    class Helper

    {

        public int GetDistance<T>(Tree<T> tree, Node<T> node1, Node<T> node2)

        {

            int length = (int)Math.Pow(2, CountMaxDepth<T>(tree) + 1) - 1;

 

            Node<T>[] nodes = new Node<T>[length];

 

            Node<T> root = tree.Root;

 

            AddNodes<T>(nodes, root);

 

            int index1 = FindNode<T>(nodes, node1);

            int index2 = FindNode<T>(nodes, node2);

 

            return CountDistance(index1, index2);

        }

 

        public int CountDistance(int i, int j)

        {

            if (i < j)

            {

                int k = i;

                i = j;

                j = k;

            }

 

            int distance = 0;

 

            if (i != j)

            {

                distance += 1;

                if (i % 2 == 1)

                    i = (i - 1) / 2;

                else

                    i = i / 2 - 1;

                distance += CountDistance(i, j);

            }

 

            return distance;

        }

 

        public int FindNode<T>(Node<T>[] nodes, Node<T> node)

        {

            for (int i = 0; i < nodes.Length; i++)

            {

                if (object.ReferenceEquals(nodes[i], node))

                    return i;

            }

 

            return -1;

        }

 

        private void AddNodes<T>(Node<T>[] nodes, Node<T> node, int currentIndex = 0)

        {

            nodes[currentIndex] = node;

 

            if (node.Left != null)

            {

                AddNodes<T>(nodes, node.Left, 2 * currentIndex + 1);

            }

 

            if (node.Right != null)

            {

                AddNodes<T>(nodes, node.Right, 2 * currentIndex + 2);

            }

        }

 

        public int CountMaxDepth<T>(Tree<T> tree)

        {

            if (tree == null||tree.Root==null)

                return 0;

 

            Node<T> root = tree.Root;

 

            if (root.Left == null && root.Right == null)

                return 0;

 

            Tree<T> leftTree = new Tree<T>() { Root = root.Left };

            Tree<T> rightTree = new Tree<T>() { Root = root.Right };

            int leftMaxLevel = CountMaxDepth<T>(leftTree);

            int rightMaxLevel = CountMaxDepth<T>(rightTree);

 

            return leftMaxLevel > rightMaxLevel ? leftMaxLevel + 1 : rightMaxLevel + 1;

        }

    }

 

    class Tree<T>

    {

        public Node<T> Root { get; set; }

    }

 

    class Node<T>

    {

        public Node<T> Left { get; set; }

        public Node<T> Right { get; set; }

 

        public T Value { get; set; }

    }

}