Question

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

我的代码段：

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) );

逻辑：它实际上是后序逻辑。变量＆＃39; d＆＃39;指的是子树的直径（在该迭代中）。当发现一些较大的值时，它将被更新。＆＃39; LH＆＃39;指的是：左子树的高度。＆＃39; rh的＆＃39;指的是：右子树的高度。

但是它给出了错误的输出。

考虑树：

空闲输出：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

Algo需要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（）函数，它将树的根作为参数并返回树的高度。使用此值并在递归的帮助下，我们可以计算树的直径。这是它的代码.....

计算直径的函数： -

<!DOCTYPE html>
<html>
  <head>
    <title>Angular 2 QuickStart</title>
    ...

  </head>

  <!-- 3. Display the application -->
  <body>
    <my-app>Loading...</my-app>
  </body>

</html>

计算树高的功能： -

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));
}

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);
            }
        }
    }
}

找到二叉树的直径

7 个答案: