给定一个二叉树，找到最长的路径，这个路径中的每个节点具有相同值。 这条路径可以经过也可以不经过根节点。
注意：两个节点之间的路径长度由它们之间的边数表示。
示例 1:
输入:
5
/ \
4 5
/ \ \
1 1 5
输出:
2
示例 2:
输入:
1
/ \
4 5
/ \ \
4 4 5
输出:
2
注意: 给定的二叉树不超过10000个结点。 树的高度不超过1000。
分析：
1.如果不仔细观察，很容易陷入到一个TreeNode误区，对于用java解答的小伙伴，在IDE中解这道题，很容导包 import javax.swing.tree.TreeNode;，结果发现，这个TreeNode是个interface呀，这怎么办？难道要找它的实现子类？一脸茫然。淡定，这个时候就需要考验审题能力了，在平台给出的答案区上方给出了注释状态的一段代码，不知道读者有没有留意到？
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
其实这个就是本题需要的TreeNode，当我们在平台上提交答案的时候，不需要定义这个class，平台验收答案时是带着这个实现的；而当我们在IDE上进行编码调试的时候，需要把这个TreeNode代码拷贝到IDE中，解开注释。然后，就可以正式开始解题了。
2.我们来分析一下题目的关键点。
二叉树：一个节点只有两个子节点，左和右。
路径：节点与节点之间的连线就是一条路径
同值路径：节点和与子节点或者父节点之间的值相同，那么这就是一条同值路径，本题求的就是这个最大值。
边数：可以理解为题目示例中连接节点的直线。
3.这一类问题，需要用递归的方法解决。在二叉树中，只能从根节点向下递归调用，可以通过root.left和root.right的方法得到两个子节点的TreeNode对象，由此一层一层递归调用下去，直到最底端的叶节点。
4.第一个可能遇到的坑：如果当前节点与左节点的值不同，那么左边的同值路径就会断掉，同理，如果和右节点值不同，右边的同值路径就会断掉。一旦断掉，那么当前节点的同值路径值就应该清零。
5.第二个可能遇到的坑：如果当前节点与子节点的值不同，那么从子节点连过来的同值路径就断掉了，而如果当前节点和父节点的值相同，需要注意，会从本节点向父节点连一个新的同值路径，与从子节点来的同值路径无关，不可累加。本题求解的是多条同值路径中最长的那条。
6.第三个可能遇到的坑：先看下图，这是平台在验证答案时给出的测试用例。
看图，这个二叉树的最大同值路径就是由根节点26组成的路径，从根节点开始，能连起来的，值为26的节点一共是6个，它们之间的连线一共是5条，那么答案就是5吗？NONO，平台的期望值是4，明白了吗？这里有一个隐含条件，同值路径必须是单向的，就是用纸笔能一笔画完的，不能倒退着连。
根据这些分析，java解答如下：
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public int longestUnivaluePath(TreeNode root) {
if (root == null) {
return 0;
}
int[] longestPath = new int[1];
getUnivaluePathCount(root, longestPath);
return longestPath[0];
}
private int getUnivaluePathCount(TreeNode node, int[] longestPath) {
int left = 0;
if (node.left != null) {
left += getUnivaluePathCount(node.left, longestPath);
if (node.val == node.left.val) {
/* 如果本节点和左节点值相同，路径能继续，再累加1 */
left += 1;
} else {
/* 否则，就说明左边的路径已经断开，本节点的左方向的单向路径值清零 */
left = 0;
}
}
int right = 0;
if (node.right != null) {
right += getUnivaluePathCount(node.right, longestPath);
if (node.val == node.right.val) {
/* 如果本节点和右节点值相同，路径能继续，再累加1 */
right += 1;
} else {
/* 否则，就说明右边的路径已经断开，本节点的右方向的单向路径值清零 */
right = 0;
}
}
int currentLongestPath;
if (node.left != null && node.right != null && node.left.val == node.right.val) {
/* 如果左右节点的值相同，那么可以相加连接起来。但如果左右相同但和本节点值不同，那么left和right的值都是0 */
currentLongestPath = left + right;
} else {
/* 否则，最大的路径值只能是左右路径的最大值 */
currentLongestPath = Math.max(left, right);
}
if (currentLongestPath > longestPath[0]) {
/* 最终返回的结果在这里，每次递归都是以当前节点为核心，计算最大路径值，在多次递归当中，仅保留最大的值 */
longestPath[0] = currentLongestPath;
}
/* 递归返回的是本节点与左右两个子节点的同值路径的最大值，注意，如果本节点的值与左右节点的值都不同，那么返回的是0 */
return Math.max(left, right);
}
}
最后说一下，本答案中的 int[] longestPath 用的java引用传递的特性，这并不是唯一的方法，还可以定义一个成员变量 private int longestPath; 来记录所有的递归过程最大的同值路径，那样会让递归方法少一个参数，在大量的递归调用过程中速度会更快。希望读者们能学到这两种方法，在今后的开发中根据实际情况合理使用。
