力扣687----最长同值路径

给定一个二叉树，找到最长的路径，这个路径中的每个节点具有相同值。 这条路径可以经过也可以不经过根节点。

注意：两个节点之间的路径长度由它们之间的边数表示。

示例 1:

输入:

              5
             / \
            4   5
           / \   \
          1   1   5

输出:

2

示例 2:

输入:

              1
             / \
            4   5
           / \   \
          4   4   5

输出:

2

1、二叉树递归迭代的顺序规律

class Solution {
    int res=0;
public:
    int longestUnivaluePath(TreeNode* root) 
    {
        long(root);
        return res;       
    }
    int long(TreeNode *root)
    {
        if(root==NULL) return 0;

        int left=long(root->left);
        int right=long(root->right);

        left=(root->left!=NULL)&&(root->val==root->left->val)?left+1 : 0;
        right=(root->right!=NULL)&&(root->val==root->right->val)?right+1 : 0;
        
        res=max(res,right+left);
        return max(right,left);
    }
};

class Solution {
public:
    int longestUnivaluePath(TreeNode* root) {
        //原理分解为子问题就是左边的最长路径加上右边的最长路径，然后再自底向上相加。、
        if(root==NULL) return 0;  //为空情况
        int ans=0;
        childproblem(root,ans);
        return ans;
    } 
    int childproblem(TreeNode * root,int &ans){   //这一步要用引用
        if(root==NULL) return 0;   //终止条件
        int leftn=childproblem(root->left,ans);  //遍历完再去遍历右子树，几乎都是这样，写树的时候一定要走到子树为空（左结点右结点全为空，再向上模拟步骤）
        int rightn=childproblem(root->right,ans);
        if(root->left!=NULL)    leftn=root->left->val==root->val?++leftn:0;   //当不同时，该结点左结点就为清空。
        if(root->right!=NULL)   rightn=root->right->val==root->val?++rightn:0;
        ans=max(ans,leftn+rightn);
        return max(leftn,rightn);//?????
    } 
};

这里这个问题还有点问题

120100220

画出来是2个但是他做出一个没报错

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 *///试试这个例子[1，2，0，1，0，0，2，2，0]
////这个应该是2但是他好像忽略了
 //[1,2,0,1,0,0,2,2,0]这个例子过不去
class Solution {
    int ans=0;
public:
    int longestUnivaluePath(TreeNode* root) {
        //if(root==NULL)return 0;
        longest(root);//在这里我们定义一个递归函数来迭代计算
         return ans;
    }
    int longest(TreeNode* root)
    {
        if(root==NULL)return 0;
        int leftlength=longest(root->left);//这里遍历先左后右
        int rightlength=longest(root->right);

        leftlength=(root->left!=NULL)&&(root->val==root->left->val)?leftlength+1:0;//这里迭代直到指向空
        rightlength=(root->right!=NULL)&&(root->val==root->right->val)?rightlength+1:0;

        // if(root->left!=NULL)
        // leftlength=root->val==root->left->val?leftlength+1:0;

        ans=max(ans,rightlength+leftlength);
        return max(leftlength,rightlength);
    }
   
};