543. 二叉树的直径

543. 二叉树的直径
     已解答
     给你一棵二叉树的根节点，返回该树的 直径 。

二叉树的 直径 是指树中任意两个节点之间最长路径的 长度 。这条路径可能经过也可能不经过根节点 root 。

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

示例 1：

输入：root = [1,2,3,4,5]
输出：3
解释：3 ，取路径 [4,2,1,3] 或 [5,2,1,3] 的长度。
示例 2：

输入：root = [1,2]
输出：1

提示：

树中节点数目在范围 [1, 104] 内
-100 <= Node.val <= 100

#include <complex>
#include <iostream>
#include<iterator>
#include <vector>
#include <fstream>
#include <string>

using namespace std;


 struct TreeNode {
      int val;  
      TreeNode *left;
      TreeNode *right;
      TreeNode() : val(0), left(nullptr), right(nullptr) {}
      TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
      TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  };

class Solution {
public:
    int maxDiameter = 0;//用于记录最大直径
    int maxdepth(TreeNode* root) //求一个节点的最大深度
    //注意这里要按照传引用，外部的值才会改变，不能用值传递
    {
        if (root == nullptr) //当前节点为空，最大深度为0
            return 0;
        
        
            int left_depth = maxdepth(root->left);//递归计算左子树最大深度
            int right_depth = maxdepth(root->right);//递归计算右子树最大深度
            maxDiameter = max(maxDiameter, left_depth + right_depth);
            //左子树最大深度+右子树最大深度即为直径
            //并不断更新最大直径
        
        /*return max(maxdepth(root->left, maxDiameter), maxdepth(root->right, maxDiameter)) + 1;
        在 return 语句中，你又多次调用 maxdepth(root->left, maxDiameter) 和 maxdepth(root->right, maxDiameter)：
            这会导致重复递归计算，影响效率。
            left_depth 和 right_depth 在函数内部已经计算过，不需要重复调用。*/

        return max(left_depth, right_depth) + 1;

        //这里必须要返回当前节点的最大深度，也是为了帮助父节点计算直径+父节点左右子树深度，完成递归
    };

    int diameterOfBinaryTree(TreeNode* root) {//求二叉树最大直径
        
        if (root == nullptr) //如果根节点为空,直径为0
            return 0;
        maxdepth(root);
        return maxDiameter;
        
    }
};


int main()  //这里的自测主函数为模板，可以自己更换名字和值
{
    Solution solution;

    TreeNode nodes[7];

	nodes[0].val = 1;
    nodes[0].left = &nodes[1];
    nodes[0].right = &nodes[2];

    nodes[1].val = 2;
    nodes[1].left = &nodes[3];
    nodes[1].right = nullptr;

    nodes[2].val = 2;
    nodes[2].left = nullptr;
    nodes[2].right = &nodes[4];

    nodes[3].val = 3;
    nodes[3].left = &nodes[5];
    nodes[3].right = nullptr;

    nodes[4].val = 3;
    nodes[4].left = nullptr;
    nodes[4].right = &nodes[6];

    nodes[5].val = 4;
    nodes[5].left = nullptr;
    nodes[5].right = nullptr;

    nodes[6].val = 4;
    nodes[6].left = nullptr;
    nodes[6].right = nullptr;

    int x = solution.diameterOfBinaryTree(&nodes[0]);

    //vector<int> a = solution.inorderTraversal(nums);
}```