问题
I have written a code for finding diameter of Binary Tree. Need suggestions for the following:
- Can I do this without using static variable at class level?
Is the algorithm fine/any suggestions?
public class DiameterOfTree { public static int diameter = 0; public static int getDiameter(BinaryTreeNode root) { if (root != null) { int leftCount = getDiameter(root.getLeft()); int rightCount = getDiameter(root.getRight()); if (leftCount + rightCount > diameter) { diameter = leftCount + rightCount; System.out.println("---diameter------------->" + diameter); } if ( leftCount > rightCount) { return leftCount + 1; } return rightCount + 1; } return 0; } }
回答1:
There are three cases to consider when trying to find the longest path between two nodes in a binary tree (diameter):
- The longest path passes through the root,
- The longest path is entirely contained in the left sub-tree,
- The longest path is entirely contained in the right sub-tree.
The longest path through the root is simply the sum of the heights of the left and right sub-trees + 1 (for the root node), and the other two can be found recursively:
public static int getDiameter(BinaryTreeNode root) {
if (root == null)
return 0;
int rootDiameter = getHeight(root.getLeft()) + getHeight(root.getRight()) + 1;
int leftDiameter = getDiameter(root.getLeft());
int rightDiameter = getDiameter(root.getRight());
return Math.max(rootDiameter, Math.max(leftDiameter, rightDiameter));
}
public static int getHeight(BinaryTreeNode root) {
if (root == null)
return 0;
return Math.max(getHeight(root.getLeft()), getHeight(root.getRight())) + 1;
}
回答2:
Here is an O(n) solution with minimal changes to the accepted answer:
public static int[] getDiameter(BinaryTreeNode root) {
int[] result = new int[]{0,0}; //1st element: diameter, 2nd: height
if (root == null) return result;
int[] leftResult = getDiameter(root.getLeft());
int[] rightResult = getDiameter(root.getRight());
int height = Math.max(leftResult[1], rightResult[1]) + 1;
int rootDiameter = leftResult[1] + rightResult[1] + 1;
int leftDiameter = leftResult[0];
int rightDiameter = rightResult[0];
result[0] = Math.max(rootDiameter, Math.max(leftDiameter, rightDiameter));
result[1] = height;
return result;
}
It just calculates height and diameter at the same time. And since Java does not have pass-by-reference I defined an int[] to return the result.
回答3:
Here is a solution in Java that has O(N) time complexity.
It calculates the height in the same recursion when calculating the diameter.
Reference Link
private class HeightWrapper {
int height = 0;
}
private int getDiameter_helper(BinaryTreeNode root, HeightWrapper wrapper) {
if (root == null) {
return 0; // diameter and height are 0
}
/* wrappers for heights of the left and right subtrees */
HeightWrapper lhWrapper = new HeightWrapper();
HeightWrapper rhWrapper = new HeightWrapper();
/* get heights of left and right subtrees and their diameters */
int leftDiameter = getDiameter_helper(root.left, lhWrapper);
int rightDiameter = getDiameter_helper(root.right, rhWrapper);
/* calculate root diameter */
int rootDiameter = lhWrapper.height + rhWrapper.height + 1;
/* calculate height of current node */
wrapper.height = Math.max(lhWrapper.height, rhWrapper.height) + 1;
/* calculate the diameter */
return Math.max(rootDiameter, Math.max(leftDiameter, rightDiameter));
}
public int getDiameter(BinaryTreeNode root) {
HeightWrapper wrapper = new HeightWrapper();
return getDiameter_helper(root, wrapper);
}
回答4:
You don't need to store the result in the static field diameter. Simply use the static method like that:
public class DiameterOfTree {
public static long getDiameter(BinaryTreeNode root) {
if (root != null) {
long leftDiameter = getDiameter(root.getLeft());
long rightDiameter = getDiameter(root.getRight());
long leftHeight = getHeight(root.getLeft());
long rightHeight = getHeight(root.getRight());
return Math.max(leftHeight + rightHeight + 1, Math.max(leftDiameter, rightDiameter));
}
return 0;
}
public static long getHeight(BinaryTreeNode root) {
if (root != null) {
long leftHeight = getHeight(root.getLeft());
long rightHeight = getHeight(root.getRight());
return 1 + Math.max(leftHeight, rightHeight);
}
return 0;
}
}
回答5:
The diameter of a tree T is
Diameter(T) = max( Diameter(T.left), Diameter(T.right), Height(T.left)+Height(T.right)+1 )
private class Data {
public int height;
public int diameter;
}
private void diameter(TreeNode root, Data d) {
if (root == null) {
d.height = 0; d.diameter = 0; return;
}
diameter(root.left, d); // get data in left subtree
int hLeft = d.height;
int dLeft = d.diameter;
diameter(root.right, d); // overwrite with data in right tree
d.diameter = Math.max(Math.max(dLeft, d.diameter), hLeft+d.height+1);
d.height = Math.max(hLeft, d.height) + 1;
}
public int diameter(TreeNode root) {
Data data = new Data();
diameter(root, data);
return data.diameter;
}
回答6:
There is a minimal O(n) answer compared to the accepted one.
int DiameterTree(BinaryTreeNode root, int diameter) {
int left, right;
if (!root) return 0;
left = DiameterTree(root.getLeft(), diameter);
right = DiameterTree(root.getRight(), diameter);
if (left + right > diameter) diameter = left + right;
return Math.max(left, right) + 1;
}
Assume diameter is a static variable in class.
回答7:
public class NodeWrap{
int height = 0;
int maxLength = 0;
public NodeWrap(int h, int m){
height = s;
maxLength = m;
}
}
public NodeWrap getDiameter(BinaryNode root){
if(root == null){
return new NodeWrap(0, 0);
}
NodeWrap left = getDiameter(root.left);
NodeWrap right = getDiameter(root.right);
int height = Math.max(left.height + right.height) + 1;
int maxLength = Math.max(left.maxLength, right.maxLength);
if(left.height != 0 && right.height != 0){
maxLength = Math.max(left.height + right.height + 1, maxLength);
}
return new NodeWrap(singleLength, maxLength);
}
回答8:
One more O(n) solution in python,
code is self explanatory, only issue with this code is it returns tuple containing both height and diameter of the tree.
def diameter(node, height):
if node is None:
return 0, 0
leftheight = 0
rightheight = 0
leftdiameter, leftheight = diameter(node.left, leftheight)
rightdiameter, rightheight = diameter(node.right, rightheight)
rootheight = 1 + max(leftheight, rightheight )
rootdiameter = ( leftheight + rightheight + 1 )
return max( rootdiameter, leftdiameter, rightdiameter ), rootheight
回答9:
Neat and clean solution:
// way to use below util function:
prop p = new prop();
diameterUtil(root, p);
System.out.println(p.d);
class prop {
int h;
int d;
}
private void diameterUtil(Node n, prop p) {
if (n == null) {
p.h = 0;
p.d = 0;
return;
}
prop lp = new prop();
prop rp = new prop();
diameterUtil(n.left, lp);
diameterUtil(n.right, rp);
p.h = Math.max(lp.h, rp.h) + 1;
p.d = Math.max((lp.h + rp.h + 1), Math.max(lp.d, rp.d));
}
回答10:
Here is one recursive solution in C++ which gives you the height as well as diameter of binary tree.
struct tree
{
int height = -1;
int diameter = 0;
};
struct tree BSTDiameter(struct node *root)
{
struct tree currentTree, leftTree, rightTree;
if (root == NULL)
{
currentTree.height = -1;
currentTree.diameter = 0;
return currentTree;
}
leftTree = BSTDiameter(root->left);
rightTree = BSTDiameter(root->right);
currentTree.height = ((leftTree.height > rightTree.height) ? leftTree.height : rightTree.height) + 1;
if (leftTree.height == -1 || rightTree.height == -1)
currentTree.diameter = 0;
else
currentTree.diameter = (leftTree.height + rightTree.height + 3) > (rightTree.diameter > leftTree.diameter ? rightTree.diameter : leftTree.diameter) ? (leftTree.height + rightTree.height + 3) : (rightTree.diameter > leftTree.diameter ? rightTree.diameter : leftTree.diameter);
return currentTree;
}
The time complexity of this is O(h) where h is height of the tree. Hope that helped you.
来源：https://stackoverflow.com/questions/11897088/diameter-of-binary-tree-better-design