编程之美：第三章 结构之法 3.8求二叉树中结点的最大距离

/*
求二叉树中节点的最大距离:
如果我们把二叉树看成一个图，父子之间的连线是双向的，定义距离为:两个节点之间边的个数

写一个程序求一颗二叉树中相距最远的两个节点之间的距离

分析:
相距最远的两个节点，一定是两个叶子节点，或者是一个叶子节点到它的根节点（假如这棵树只有左子树或只有右子树的话）

解法1:
相距最远的两个节点一定是叶子节点:
对于任意一个节点，以该节点为根，假设这个根有k个孩子节点，那么相距最远的两个节点U和V之间的路径与这个根节点的关系有两种:
1若路径经过根Root,则U和V是属于不同子树的，且他们都是该子树中到根节点最远的节点。
2若路径不经过Root,那么他们一定属于根的k个子树之一，并且他们也是该子树中相距最远的两个顶点。相距最远的节点在某个子树之下。
转化为在子树上的解，从而能够利用动态规划来解决。

设第k棵子树中相距最远的两个节点：Uk,Vk。其距离定义为d(Uk,Vk)，那么节点Uk或者Vk即为子树K到根节点Rk距离最长的节点。设Uk为子树K中到根节点
Rk距离最长的节点，其到根节点的距离定义为d(Uk,R)。取d(Ui,R)(1<=i<=k)中最大的两个值max1和max2，经过根节点R的最长路径为max1+max2+2
,所以树R中相距最远的两个点的距离为:max{d(U1,V1),...,d(Uk,Vk),max1+max2+2}

采用深度优先搜索，只需要遍历所有节点一次，时间复杂度为O(|E|) = O(|V|-1)，其中V为点的集合，E为边的集合
*/

#include <stdio.h>
#include <string.h>
#include <iostream>

using namespace std;

const int MAXSIZE = 10000;

typedef struct Node
{
	Node* _pLeft;
	Node* _pRight;
	int _iMaxLeft;//左子树中的最长距离
	int _iMaxRight;
	char _chValue;//该节点的值
}Node;

Node g_nodeArr[MAXSIZE];
int g_iIndex;


Node* createNode()
{
	++g_iIndex;
	g_nodeArr[g_iIndex]._pLeft = g_nodeArr[g_iIndex]._pRight = NULL;
	return &g_nodeArr[g_iIndex];
}

int g_iMaxLen = 0;

/*
算法思路:
遍历到叶子节点，返回；左子树为空，该节点左边最长距离为0；
                            不空，递归寻找左子树的最长距离
递归主体:
计算左子树最长节点距离:
设置临时最大距离为0，如果该根节点的左子树的左孩子最长距离 > 右孩子最长距离 ： 令临时最长距离 = 左孩子最长距离。然后另根节点的左边最长距离为临时最长
距离+1。
最后:
计算根节点的左孩子最长距离+根节点的右孩子的最长距离 > 最长距离
最长距离进行更新，最终返回。
                                                              1
								2                                                            3
				4                              5                             0                                    0
		6               7             8                 9
	0        0      0       0    0         0       0          0



输入:
19
1 2 4 6 0 0 7 0 0 5 8 0 0 9 0 0 3 0 0
输出:
4
*/

/*
关键:
1 	if(!pRoot->_pLeft)//左子树为空，那么该节点的左边最长距离为0
	{
		pRoot->_iMaxLeft = 0;//遍历到叶子节点，返回；左子树为空，该节点左边最长距离为0；
2	if(pRoot->_pLeft)//左子树不空，递归寻找左子树
	{
		findMaxLen(pRoot->_pLeft); //不空，递归寻找左子树的最长距离
3	if(pRoot->_pLeft)//本题采用后根遍历的方法，递归主体，计算根节点左子树的最长距离
	{
		pRoot->_iMaxLeft = max(pRoot->_pLeft->_iMaxLeft,pRoot->_pLeft->_iMaxRight) + 1;
递归主体:
计算左子树最长节点距离:
设置临时最大距离为0，如果该根节点的左子树的左孩子最长距离 > 右孩子最长距离 ： 令临时最长距离 = 左孩子最长距离。然后另根节点的左边最长距离为临时最长
距离+1。
4 	if(pRoot->_iMaxLeft + pRoot->_iMaxRight > g_iMaxLen)//计算根节点最长距离
	{
		g_iMaxLen = pRoot->_iMaxLeft + pRoot->_iMaxRight;
最后:
计算根节点的左孩子最长距离+根节点的右孩子的最长距离 > 最长距离
最长距离进行更新，最终返回。
*/

int max(int a,int b)
{
	return a > b ? a : b;
}

//关于树中的递归:先搞清楚递归的顺序。递归中，需要后续的调用完成，假设后面的长度已经计算出来。分析递归体的逻辑。考虑推出条件
void findMaxLen(Node* pRoot)//寻找树中最长的两段距离
{
	if(!pRoot)
	{
		return ;
	}
	if(!pRoot->_pLeft)//左子树为空，那么该节点的左边最长距离为0
	{
		pRoot->_iMaxLeft = 0;
	}
	if(!pRoot->_pRight)
	{
		pRoot->_iMaxRight = 0;
	}
	if(pRoot->_pLeft)//左子树不空，递归寻找左子树
	{
		findMaxLen(pRoot->_pLeft);
	}
	if(pRoot->_pRight)
	{
		findMaxLen(pRoot->_pRight);
	}
	if(pRoot->_pLeft)//本题采用后根遍历的方法，递归主体，计算根节点左子树的最长距离
	{
		pRoot->_iMaxLeft = max(pRoot->_pLeft->_iMaxLeft,pRoot->_pLeft->_iMaxRight) + 1;
	}
	if(pRoot->_pRight)
	{
		pRoot->_iMaxRight = max(pRoot->_pRight->_iMaxLeft,pRoot->_pRight->_iMaxRight) + 1;
	}
	if(pRoot->_iMaxLeft + pRoot->_iMaxRight > g_iMaxLen)//计算根节点最长距离
	{
		g_iMaxLen = pRoot->_iMaxLeft + pRoot->_iMaxRight;
	}
}

//这里给定前序序列，来建立二叉树。注意这里的根节点在局部函数中给出
Node* buildTree(char* str,int iLen,int& iPos)
{
	if(!str || iLen < 0 || iPos < 0)
	{
		return NULL;
	}
	Node* pRoot;
	if(str[iPos] == '0')//如果是叶节点
	{
		iPos++;
		return NULL;
	}
	if(iPos < iLen)//如果还没有超过长度，持续建立
	{
		pRoot = createNode();
		pRoot->_chValue = str[iPos++];
		pRoot->_pLeft = buildTree(str,iLen,iPos);
		pRoot->_pRight = buildTree(str,iLen,iPos);
	}
	return pRoot;
}

void process()
{
	int n;
	while(EOF != scanf("%d",&n))
	{
		char str[MAXSIZE];
		for(int i = 0 ; i < n ; i++)
		{
			cin >> str[i];
		}
		int iPos = 0;
		g_iIndex = 0;
		memset(g_nodeArr,NULL,sizeof(g_nodeArr));
		Node* pRoot = buildTree(str,n,iPos);
		g_iMaxLen = 0;
		findMaxLen(pRoot);//建完树之后，我们应该计算树中最长的两段距离
		printf("%d\n",g_iMaxLen);
	}
}

int main(int argc,char* argv[])
{
	process();
	getchar();
	return 0;
}