Диаметр дерева

public class Solution
{
    private static int diameter;

    public static int FindDiameter(TreeNode root)
    {
        diameter = 0;
        Dfs(root);
        return diameter;
    }

    private static int Dfs(TreeNode node)
    {
        if (node == null)
        {
            return 0;
        }

        int left = Dfs(node.left);
        int right = Dfs(node.right);

        // Обновляем диаметр, но возвращаем высоту
        diameter = Math.Max(diameter, left + right);

        return Math.Max(left, right) + 1;
    }
}

#include <vector>
#include <algorithm>

using namespace std;

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

int dfs(TreeNode* node, int& diameter) {
    if (node == nullptr) {
        return 0;
    }

    int left = dfs(node->left, diameter);
    int right = dfs(node->right, diameter);

    // обновляем диаметр, но возвращаем высоту
    diameter = max(diameter, left + right);

    return max(left, right) + 1;
}

int findDiameter(TreeNode* root) {
    int diameter = 0;
    dfs(root, diameter);
    return diameter;
}

package main

func findDiameter(root *TreeNode) int {
    diameter := 0

    var dfs func(*TreeNode) int
    dfs = func(node *TreeNode) int {
        if node == nil {
            return 0
        }

        left := dfs(node.Left)
        right := dfs(node.Right)

        // обновляем диаметр, но возвращаем высоту
        diameter = max(diameter, left+right)

        return max(left, right) + 1
    }

    dfs(root)
    return diameter
}

import java.util.*;

public class Solution {
    private int diameter = 0;

    public int findDiameter(TreeNode root) {
        dfs(root);
        return diameter;
    }

    private int dfs(TreeNode node) {
        if (node == null) {
            return 0;
        }

        int left = dfs(node.left);
        int right = dfs(node.right);

        // обновляем диаметр, но возвращаем высоту
        diameter = Math.max(diameter, left + right);

        return Math.max(left, right) + 1;
    }
}

def find_diameter(root: TreeNode) -> int:
    diameter = 0

    def dfs(node: TreeNode) -> int:
        if node is None:
            return 0

        left = dfs(node.left)
        right = dfs(node.right)

        # обновляем диаметр, но возвращаем высоту
        nonlocal diameter
        diameter = max(diameter, left + right)

        return max(left, right) + 1

    dfs(root)
    return diameter

/**
 * @param {TreeNode} root
 * @returns {number}
 */
export function findDiameter(root) {
  let diameter = 0;

  function dfs(node) {
    if (node === null) {
      return 0;
    }

    const left = dfs(node.left);
    const right = dfs(node.right);

    // обновляем диаметр, но возвращаем высоту
    diameter = Math.max(diameter, left + right);

    return Math.max(left, right) + 1;
  }

  dfs(root);
  return diameter;
}