求二叉树的直径

Question

我试图在java中找到二叉树的直径（树中任意两个节点之间的路径长度，包含最大节点数。）。

我的代码 sn-p:

public int diametre(Node node, int d)
{
    if(node==null)
        return 0;

    lh=diametre(node.left, d);
    rh=diametre(node.right, d);

    if(lh+rh+1>d)
        d=lh+rh+1;

    return findMax(lh, rh)+1;
}

在主方法中：

 System.out.println( bst.diametre(root,0) );

逻辑： 它实际上是后订单逻辑。变量“d”指的是子树的直径（在那次迭代中）。当发现一些更大的值时，它将被更新。 'lh' 指的是：左子树的高度。 'rh' 指的是：右子树的高度。

但它给出了错误的输出。

考虑的树：

   5
  / \
 /   \
1     8
 \    /\
  \  /  \
  3  6   9

空闲输出：5

但是这段代码给出的是 3。

谁能找出问题出在哪里...

Answer 1

public int diameter (Node root)
{
    if (root == null) return 0;
    else return Math.max (
        diameter (root.left), 
        Math.max (
            diameter (root.right),
            height (root.left) + height (root.right) + 1));
}

public int height (Node root)
{
    if (root == null) return 0;
    else return 1 + Math.max (height (root.left), height (root.right));
}

Answer 2

通过从任何节点运行BFS，然后从最远的节点（在第一个 BFS 期间最后访问的节点）运行另一个 BFS，您可以找到树的直径。直径由第一个 BFS 中最后访问的节点和第一个 BFS 中最后访问的节点组成。树是二叉树这一事实并不影响算法。

编辑：在您编写的代码中更改 d 的值不会影响您传递的参数，因为原始类型在 java 中不是通过引用传递的。

Answer 3

我建议如下：

public static TreeAttr calcTreeDiameter(Node root) {
    if (root == null)
        return new TreeAttr(0, 0);

    TreeAttr leftAttr = calcTreeDiameter(root.getLeft());
    TreeAttr rightAttr = calcTreeDiameter(root.getRight());

    int maxDepth = Math.max(leftAttr.depth, rightAttr.depth);
    int maxDiam = Math.max(leftAttr.diameter, rightAttr.diameter);
    maxDiam = Math.max(maxDiam, leftAttr.depth + rightAttr.depth + 1);

    return new TreeAttr(maxDiam, maxDepth + 1);
}

TreeAttr 是一个包含子树直径和深度的简单结构。两者都应该在递归中传递，因为最优值可能来自子树之一，或者来自最长路径的串联。

Answer 4

int max=0;
public int diameter(Tree root) {
  if(root==null) return 0;
  int l=diameter(root.left);
  int r=diameter(root.right);
  max=Math.max(max,l+r+1);
  return l>r:l+1:r+1;
}

max 是最大直径。

Answer 5

算法需要 O(n)。同时计算高度和路径。

public static int findLongestPath(TreeNode root)
{
  // longest path = max (h1 + h2 + 2, longestpath(left), longestpath(right);

  int[] treeInfo = longestPathHelper(root);

  return treeInfo[0];
}

private static int[] longestPathHelper(TreeNode root)
{
  int[] retVal = new int[2];

  if (root == null)
  {
     //height and longest path are 0
     retVal[0] = 0;
     retVal[1] = 0;
  }

  int[] leftInfo = longestPathHelper(root.getLeft());
  int[] rightInfo = longestPathHelper(root.getRight());

  retVal[0] = Math.max(leftInfo[1] + rightInfo[1] + 2, Math.max(leftInfo[0], rightInfo[0]));
  retVal[1] = Math.max(leftInfo[1], rightInfo[1]) + 1;

  return retVal;
}

Answer 6

您应该使用树的高度来计算直径。创建一个 getHeight() 函数，它将树的根作为参数并返回树的高度。使用这个值并在递归的帮助下，我们可以计算出树的直径。这是它的代码.....

计算直径的函数：-

public static int getDiameter(BinaryTreeNode root) {        
  if (root == null)
    return 0;

int rootDiameter = findHeight(root.getLeft()) + findHeight(root.getRight()) + 1;
int leftDiameter = getDiameter(root.getLeft());
int rightDiameter = getDiameter(root.getRight());

return Math.max(rootDiameter, Math.max(leftDiameter, rightDiameter));
}

计算树高的函数：-

public static int findHeight(BinaryTreeNode node) {
if(node == null)
    return 0;

else {
    return 1+Math.max(findHeight(node.left), findHeight(node.right));
}
}

Answer 7

二叉树的直径，O(n)，它会跟踪是否通过根节点的直径，并使用相同的高度函数来跟踪直径。

DiameterOfTree.class

import BinaryTree.BinaryTreeNode;

public class DiameterOfBinaryTree {
    private int DIAMETER = 0;

    public void getDiameterOfBinaryTree(BinaryTreeNode node) {
        getHeightUtil(node, DIAMETER);
        System.out.print("\n\n Maximum Diameter of the tree is : " + DIAMETER);
    }

    private int getHeightUtil(BinaryTreeNode node, Integer maXValue) {
        if (node == null) {
            return 0;
        }

        // Here we get the maximum value returned + 1 for each subtree left or 
        //  right 
        int leftHeight = getHeightUtil(node.getLeft(), maXValue); 
        int rightHeight = getHeightUtil(node.getRight(), maXValue);

        //finding the new diameter at a particular node and adding 1 to 
        //include that particular node as well: leftHeight + rightHeight + 1 
        DIAMETER = Math.max(DIAMETER, leftHeight + rightHeight + 1);

        return 1 + Math.max(leftHeight, rightHeight);
    }
}

Main.java

package BinaryTree;

public class Main {

    public static void main(String[] args) {
        //Initialise root
        BinaryTreeNode root = new BinaryTreeNode(40);

        //Create a binary Tree
        InitialiseBinaryTree initialiseBinaryTree = new InitialiseBinaryTree();
        initialiseBinaryTree.initialise(root);

        // Find the diameter of the binary tree 
        new DiameterOfBinaryTree().getDiameterOfBinaryTree(root);
    }

}

InitialiseBinaryTree.java

package BinaryTree;

class InitialiseBinaryTree {
    void initialise(BinaryTreeNode root) {
        BinaryTreeOperation bto = new BinaryTreeOperation();
        int[] data = {20, 50, 10, 30, 5,8, 25, 32, 33};
        for (int aData : data) {
            bto.insertElementInBinaryTree(root, aData);
        }
    }
}

BinaryTreeOperation.java

package BinaryTree;

class BinaryTreeOperation {
    private boolean findInBinaryTree(BinaryTreeNode node, int data) {
        return node != null &&
                (data == node.getData() || (findInBinaryTree(node.getLeft(), data) || findInBinaryTree(node.getRight(), data)));
    }

    void insertElementInBinaryTree(BinaryTreeNode node, int data) {
        if (node == null) {
            new BinaryTreeNode(data);
        } else {
            insertHelper(node, data);
        }
    }

    private void insertHelper(BinaryTreeNode node, int data) {
        if (node.getData() > data) {
            if (node.getLeft() == null) {
                node.setLeft(new BinaryTreeNode(data));
            } else {
                insertHelper(node.getLeft(), data);
            }
        } else {
            if (node.getRight() == null) {
                node.setRight(new BinaryTreeNode(data));
            } else {
                insertHelper(node.getRight(), data);
            }
        }
    }
}