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

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

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

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

• 情况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;
}
}