如何避免在此处使用全局变量？

Question

所以问题是找到二叉树的直径。我的方法是为每个节点找到左侧节点的高度和右侧节点的高度。然后，如果height（左侧节点）+1（对于当前节点）+ height（右侧节点）大于当前的最大直径，则更新最大直径。我最初是为此使用全局变量，但改为使用大小为1（直径[int []直径）的数组。我知道这很骇人，不是在编程采访中有人会喜欢的东西，那么有人有更好的建议吗？我知道在C语言中我只能使用一个指针，但不幸的是，我对Java并不满意。

public static int height(TreeNode node, int[] diameter) {
    if (node == null) {
        return 0;
    }
    int leftHeight = height(node.left, diameter);
    int rightHeight = height(node.right, diameter);
    diameter[0] = Math.max(diameter[0], leftHeight + 1 + rightHeight);
    return 1 + Math.max(leftHeight, rightHeight);
}
public int diameter(TreeNode root) {
    int[] diameterArr = new int[1];
    int heightRoot = height(root, diameterArr);
    return diameterArr[0];
}

Answer 1

您可以使用此代码解决问题：

// Recursive optimized Java program to find the diameter of a
// Binary Tree

/* Class containing left and right child of current
node and key value*/
class Node
{
    int data;
    Node left, right;

    public Node(int item)
    {
        data = item;
        left = right = null;
    }
}

/* Class to print the Diameter */
class BinaryTree
{
    Node root;

    /* Method to calculate the diameter and return it to main */
    int diameter(Node root)
    {
        /* base case if tree is empty */
        if (root == null)
            return 0;

        /* get the height of left and right sub trees */
        int lheight = height(root.left);
        int rheight = height(root.right);

        /* get the diameter of left and right subtrees */
        int ldiameter = diameter(root.left);
        int rdiameter = diameter(root.right);

        /* Return max of following three
        1) Diameter of left subtree
        2) Diameter of right subtree
        3) Height of left subtree + height of right subtree + 1 */
        return Math.max(lheight + rheight + 1,
                Math.max(ldiameter, rdiameter));

    }

    /* A wrapper over diameter(Node root) */
    int diameter()
    {
        return diameter(root);
    }

    /*The function Compute the "height" of a tree. Height is the
    number f nodes along the longest path from the root node
    down to the farthest leaf node.*/
    static int height(Node node)
    {
        /* base case tree is empty */
        if (node == null)
            return 0;

        /* If tree is not empty then height = 1 + max of left
        height and right heights */
        return (1 + Math.max(height(node.left), height(node.right)));
    }


    public static void main(String args[])
    {
        /* creating a binary tree and entering the nodes */
        BinaryTree tree = new BinaryTree();
        tree.root = new Node(1);
        tree.root.left = new Node(2);
        tree.root.right = new Node(3);
        tree.root.left.left = new Node(4);
        tree.root.left.right = new Node(5);

        System.out.println("The diameter of given binary tree is : "
                + tree.diameter());
    }
}

Answer 2

您可以使用AtomicInteger方法的任何更改都会影响调用者

    public static int height(TreeNode node, AtomicInteger max) {
        if (node == null) {
            return 0;
        }
        int leftHeight = height(node.left, max);
        int rightHeight = height(node.right, max);
        max.set(Math.max(max.intValue(), leftHeight + 1 + rightHeight));
        return 1 + Math.max(leftHeight, rightHeight);
    }

    public int diameter(TreeNode root) {
        AtomicInteger max;
        height(root, max);
        return max.intValue();
    }