Diameter of Binary Tree 二叉树的直径

给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过根结点。

示例 :
给定二叉树

          1
         / \
        2   3
       / \     
      4   5    

返回 3, 它的长度是路径 [4,2,1,3] 或者 [5,2,1,3]。

注意：两结点之间的路径长度是以它们之间边的数目表示。

思路：

这道题本来不知道怎么做没有思路，结果题目描述里给了提示：路径可能穿过根节点。直观感觉便是如果能找到能穿过根节点且能保证左右length最长，便是答案。由于前面我们有depth函数用来求一个节点的树深度，则我们首先对根节点root求左右深度然后相加便是经过root的length，然后我们依次对树的每个节点都做一次这样的操作，用一个全集变量求每个节点作为根节点的length的最大值。由于depth函数的时间复杂度是O(logn)，遍历一次树需要O(n)复杂度，一共需要O(nlogn)的时间复杂度。

代码如下：

//求节点root的深度
   int depth(TreeNode* root) {
	   if (!root) {
		   return 0;
	   }
	   return max(depth(root->left), depth(root->right)) + 1;
   }
   
   int diameterOfBinaryTree(TreeNode* root) {
	   if (!root) {
		   return 0;
	   }
	   int max_ = 0;
	   //求经过root根节点的length
	   max_ = max((depth(root->left) + depth(root->right)), max_);
	   //求经过左节点为根节点的length
	   max_ = max(diameterOfBinaryTree(root->left), max_);
	   //求经过右节点为根节点的length
	   max_ = max(diameterOfBinaryTree(root->right), max_);
	   return max_;
   }

submission结果令人捉急！！！！

于是我们想一想能不能用空间换时间，改进算法。

方法二（内存超了，不过思路）：

我们在求depth的时候，用一个map来保存每个节点的深度信息（key为TreeNode*，value为深度），这样root节点遍历完一次后，其他节点再调用depth函数时则直接返回结果。由于需要保存每个节点深度信息，空间复杂度为O(n)，时间复杂度降为）O(logn)。下面贴上代码，不过结果嘛。。。

   //得到树深度
   int depth(TreeNode* root, map<TreeNode*, int>& tree_node_depth) {
	   if (!root) {
		   return 0;
	   }
	   //如果存过该节点树深度，则直接返回，不需要递归调用
	   if (tree_node_depth[root]) {
		   return tree_node_depth[root];
	   }
	   else {
		   int max_ = max(depth(root->left, tree_node_depth), depth(root->right, tree_node_depth)) + 1;
		   tree_node_depth[root] = max_;
		   return max_;
	   }
   }

   int diameterOfBinaryTree(TreeNode* root) {
	   if (!root) {
		   return 0;
	   }
	   int max_ = 0;
	   map<TreeNode*, int> tree_node_depth;
	   //判断左子树和右子树深度，相加便是经过root的length
	   max_ = max((depth(root->left, tree_node_depth) + depth(root->right, tree_node_depth)), max_);
	   //判断经过左节点作为根节点的length，与经过父节点的length取最大
	   max_ = max(diameterOfBinaryTree(root->left), max_);
	   //判断经过右节点作为根节点的length，与经过父节点的length取最大
	   max_ = max(diameterOfBinaryTree(root->right), max_);
	   return max_;
   }

结果过了105/106个test case。。。然后内存超了。。。

方法三：

观察到对于方法一，我们先对每个节点求depth，又调用他的左右节点求depth，其实重复调用了很多次depth，我们想办法改进下depth函数，由于函数depth只能求一个节点的深度，而最后我们希望得到每个节点的左右节点的depth和的最大值。发现有相同的地方，那么我们其实遍历一次树就可以，用一个全局变量max_来保存每一个节点左右节点的depth之和，然后每次调用时不断更新max_即可。

   int depth(TreeNode* root, int &max_) {
	   if (!root) {
		   return 0;
	   }
	   else {
		   //求左节点深度
		   int left = depth(root->left, max_);
		   //求右节点深度
		   int right = depth(root->right, max_);
		   //求左右节点深度之和与之前最大值max_的最大值
		   max_ = max(left + right, max_);
		   //求根节点root的深度
		   return max(left, right) + 1;
	   }
   }

   int diameterOfBinaryTree(TreeNode* root) {
	   if (!root) {
		   return 0;
	   }
	   int max_ = 0;
	   depth(root, max_);
	   return max_;
   }

我们求根节点root深度的函数返回值没变，只是在求根节点深度时我们会调用求左右节点的深度（自身递归），刚好可以顺便拿来保存每个节点左右节点的depth信息，这样我们时间复杂度为O(logn)，空间复杂度为O(1)。而且相当于只对root求了个depth函数，时间大大缩短（缩短了近一半）：