# Diameter of a Binary Indexed Tree with N nodes

• Difficulty Level : Expert
• Last Updated : 08 Mar, 2022

Given a Binary Indexed Tree with N nodes except root node 0 (Numbered from 1 to N), Find its diameter.
Binary Indexed Tree is a tree where parent of a node number X = X – (X & (X – 1)) i.e. last bit is unset in X. The diameter of a tree is the longest simple path between any two leaves.
Examples:

Input: N = 12
Output:
Explanation: Path from node 7 to node 11. Input : n = 15
Output : 7

Approach:

• In a BIT, root is always node 0. In first level, all nodes are of power of 2 . (1, 2, 4, 8, ….)
• Consider any node in the first level (1, 2, 4, 8, ) its sub-tree will include all the nodes which has same number of bits as that of the root.
1. Sub-Tree with root 1 will have no child.
2. Sub-Tree with root 2 will have 3 as a child.
3. Sub-Tree with root 4 will have 5, 6, 7 as a child.
4. Sub-Tree with root 8 will have 9, 10, 11, 12, 13, 14, 15 as a child. (Double the size of the previous subtree)
5. So subtree with root K will have K nodes including root. And the height of each subtree would be equal:
• for subtree with root 1
• for subtree with root 2
• for subtree with root 4
• Now, we need to find the subtree in which N lies. Say, the height of subtree just before the subtree in which N lies is H and size is L. So, the following cases are possible :
• Case 1 : When N >= L*2 – 1, in such a scenario N is in last level of its subtree. Thus, the diameter will be 2*H + 1. (Path from the lowest level leaf of the previous subtree to the N ).

• Case 2 : When N >= L + L/2 – 1, in such a scenario N is at level H in its subtree. Thus, diameter will be 2*H.

• Case 3 : Otherwise, it is optimal to consider the maximum path length between leaf nodes of two subtree just before the subtree in which N lies i.e diameter is 2*H – 1.

Below are the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;` `// Function to find diameter``// of BIT with N + 1 nodes``int` `diameter(``int` `n)``{``    ``// L is size of subtree just before subtree``    ``// in which N lies``    ``int` `L, H, templen;``    ``L = 1;` `    ``// H is the height of subtree just before``    ``// subtree in which N lies``    ``H = 0;` `    ``// Base Cases``    ``if` `(n == 1) {``        ``return` `1;``    ``}``    ``if` `(n == 2) {``        ``return` `2;``    ``}``    ``if` `(n == 3) {``        ``return` `3;``    ``}` `    ``// Size of subtree are power of 2``    ``while` `(L * 2 <= n) {``        ``L *= 2;``        ``H++;``    ``}` `    ``// 3 Cases as explained in Approach``    ``if` `(n >= L * 2 - 1)``        ``return` `2 * H + 1;``    ``else` `if` `(n >= L + (L / 2) - 1)``        ``return` `2 * H;``    ``return` `2 * H - 1;``}` `// Driver Code``int` `main()``{``    ``int` `n = 15;``    ``cout << diameter(n) << endl;``}`

## Java

 `// Java implementation of the approach``class` `GFG``{` `// Function to find diameter``// of BIT with N + 1 nodes``static` `int` `diameter(``int` `n)``{``    ``// L is size of subtree just before subtree``    ``// in which N lies``    ``int` `L, H, templen;``    ``L = ``1``;`` ` `    ``// H is the height of subtree just before``    ``// subtree in which N lies``    ``H = ``0``;`` ` `    ``// Base Cases``    ``if` `(n == ``1``) {``        ``return` `1``;``    ``}``    ``if` `(n == ``2``) {``        ``return` `2``;``    ``}``    ``if` `(n == ``3``) {``        ``return` `3``;``    ``}`` ` `    ``// Size of subtree are power of 2``    ``while` `(L * ``2` `<= n) {``        ``L *= ``2``;``        ``H++;``    ``}`` ` `    ``// 3 Cases as explained in Approach``    ``if` `(n >= L * ``2` `- ``1``)``        ``return` `2` `* H + ``1``;``    ``else` `if` `(n >= L + (L / ``2``) - ``1``)``        ``return` `2` `* H;``    ``return` `2` `* H - ``1``;``}`` ` `// Driver Code``public` `static` `void` `main(String []args)``{``    ``int` `n = ``15``;` `    ``System.out.println(diameter(n));``}``}` `// This code contributed by PrinciRaj1992`

## Python3

 `# Python3 implementation of the approach` `# Function to find diameter``# of BIT with N + 1 nodes``def` `diameter(n):``    ` `    ``# L is size of subtree just before``    ``# subtree in which N lies``    ``L, H, templen ``=` `0``, ``0``, ``0``;``    ``L ``=` `1``;` `    ``# H is the height of subtree just before``    ``# subtree in which N lies``    ``H ``=` `0``;` `    ``# Base Cases``    ``if` `(n ``=``=` `1``):``        ``return` `1``;``    ` `    ``if` `(n ``=``=` `2``):``        ``return` `2``;``    ` `    ``if` `(n ``=``=` `3``):``        ``return` `3``;` `    ``# Size of subtree are power of 2``    ``while` `(L ``*` `2` `<``=` `n):``        ``L ``*``=` `2``;``        ``H ``+``=` `1``;``    ` `    ``# 3 Cases as explained in Approach``    ``if` `(n >``=` `L ``*` `2` `-` `1``):``        ``return` `2` `*` `H ``+` `1``;``    ``elif` `(n >``=` `L ``+` `(L ``/` `2``) ``-` `1``):``        ``return` `2` `*` `H;``    ``return` `2` `*` `H ``-` `1``;` `# Driver Code``n ``=` `15``;``print``(diameter(n));` `# This code is contributed by Rajput-Ji`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{` `// Function to find diameter``// of BIT with N + 1 nodes``static` `int` `diameter(``int` `n)``{``    ``// L is size of subtree just before subtree``    ``// in which N lies``    ``int` `L, H;``    ``L = 1;` `    ``// H is the height of subtree just before``    ``// subtree in which N lies``    ``H = 0;` `    ``// Base Cases``    ``if` `(n == 1)``    ``{``        ``return` `1;``    ``}``    ``if` `(n == 2)``    ``{``        ``return` `2;``    ``}``    ``if` `(n == 3)``    ``{``        ``return` `3;``    ``}` `    ``// Size of subtree are power of 2``    ``while` `(L * 2 <= n)``    ``{``        ``L *= 2;``        ``H++;``    ``}` `    ``// 3 Cases as explained in Approach``    ``if` `(n >= L * 2 - 1)``        ``return` `2 * H + 1;``    ``else` `if` `(n >= L + (L / 2) - 1)``        ``return` `2 * H;``    ``return` `2 * H - 1;``}` `// Driver Code``public` `static` `void` `Main(String []args)``{``    ``int` `n = 15;` `    ``Console.WriteLine(diameter(n));``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``
Output:
`7`

Time Complexity: O(log n)

Auxiliary Space: O(1)

My Personal Notes arrow_drop_up