# Minimum distance between two given nodes in an N-ary tree

Last Updated : 16 Sep, 2021

Given a N ary Tree consisting of N nodes, the task is to find the minimum distance from node A to node B of the tree.

Examples:

Input:
1
/         \
2            3
/  \       /  \   \
4   5    6    7   8
A = 4, B = 3
Output: 3
Explanation: The path 4->2->1->3 gives the minimum distance from A to B.

Input:
1
/         \
2            3
/  \  \
6    7   8
A = 6, B = 7
Output: 2

Approach: This problem can be solved by using concept of LCA(Lowest Common Ancestor). Minimum distance between two given nodes A and B can be found out by using formula –
mindistance(A, B) = dist (LCA, A) + dist (LCA, B)
Follow the steps below to solve the problem:

1. Find path from root node to the nodes A and B, respectively and simultaneously store the two paths in two arrays.
2. Now iterate until values of both the arrays are same and value just before mismatch is the LCA node value.
3. The value just before mismatch is the LCA node value.
4. Find distance from the LCA node to node A and B, which can be found with the given steps:
• In first array, iterate from LCA node value and increase count until value of node A is found, which is dist (LCA, A).
• In the second array, iterate from LCA node value and increase count until value of node B is found, which is dist (LCA, B)
5. Return the sum of those distances i.e dist (LCA, A) + dist (LCA, B).

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Structure of Node` `struct` `Node {` `    ``int` `val;` `    ``vector child;` `};`   `// Utility function to create a` `// new tree node` `Node* newNode(``int` `key)` `{` `    ``Node* temp = ``new` `Node;` `    ``temp->val = key;` `    ``return` `temp;` `}`   `bool` `flag;`   `// Function to get the path` `// from root to a node` `void` `findPath(Node* root, ``int` `key,` `              ``vector<``int``>& arr)` `{` `    ``if` `(!root)` `        ``return``;` `    ``arr.push_back(root->val);` `    ``// if key is found set flag and return` `    ``if` `(root->val == key) {` `        ``flag = 1;` `        ``return``;` `    ``}` `    ``// recur for all children` `    ``for` `(``int` `i = 0; i < root->child.size(); i++) {`   `        ``findPath(root->child[i], key, arr);`   `        ``// if key is found dont need to pop values` `        ``if` `(flag == 1)` `            ``return``;` `    ``}`   `    ``arr.pop_back();` `    ``return``;` `}`   `void` `findMinDist(Node* root, ``int` `A, ``int` `B)` `{` `    ``if` `(root == NULL)` `        ``return``;` `    ``int` `val = root->val;`   `    ``// vector to store both paths` `    ``vector<``int``> arr1, arr2;`   `    ``// set flag as false;` `    ``flag = ``false``;`   `    ``// find path from root to node a` `    ``findPath(root, A, arr1);`   `    ``// set flag again as false;` `    ``flag = ``false``;`   `    ``// find path from root to node b` `    ``findPath(root, B, arr2);`   `    ``// to store index of LCA node` `    ``int` `j;`   `    ``// if unequal values are found` `    ``// return previous value` `    ``for` `(``int` `i = 1; i < min(arr1.size(), arr2.size()); i++) {` `        ``if` `(arr1[i] != arr2[i]) {` `            ``val = arr1[i - 1];` `            ``j = i - 1;` `            ``break``;` `        ``}` `    ``}` `    ``int` `d1 = 0, d2 = 0;`   `    ``// iterate for finding distance` `    ``// between LCA(a, b) and a` `    ``for` `(``int` `i = j; i < arr1.size(); i++)` `        ``if` `(arr1[i] == A)` `            ``break``;` `        ``else` `            ``d1 += 1;`   `    ``// iterate for finding distance` `    ``// between LCA(a, b) and b` `    ``for` `(``int` `i = j; i < arr2.size(); i++)` `        ``if` `(arr2[i] == B)` `            ``break``;` `        ``else` `            ``d2 += 1;` `    ``// get distance` `    ``val = d1 + d2;` `    ``cout << val << ``'\n'``;` `}`   `// Driver Code` `int` `main()`   `{` `    ``Node* root = newNode(1);` `    ``(root->child).push_back(newNode(2));` `    ``(root->child).push_back(newNode(3));` `    ``(root->child[0]->child).push_back(newNode(4));` `    ``(root->child[0]->child).push_back(newNode(5));` `    ``(root->child[1]->child).push_back(newNode(6));` `    ``(root->child[1])->child.push_back(newNode(7));` `    ``(root->child[1]->child).push_back(newNode(8));` `    ``int` `A = 4, B = 3;`   `    ``// get min distance` `    ``findMinDist(root, A, B);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.*;` `public` `class` `Main` `{` `    ``// Structure of Node` `    ``static` `class` `Node {` `        `  `        ``public` `int` `val;` `        ``public` `Node left, right;` `        ``public` `Vector child;` `        `  `        ``public` `Node(``int` `key)` `        ``{` `            ``val = key;` `            ``left = right = ``null``;` `            ``child = ``new` `Vector();` `        ``}` `    ``}` `    `  `    ``// Utility function to create a` `    ``// new tree node` `    ``static` `Node newNode(``int` `key)` `    ``{` `        ``Node temp = ``new` `Node(key);` `        ``return` `temp;` `    ``}` `     `  `    ``static` `int` `flag;` `     `  `    ``// Function to get the path` `    ``// from root to a node` `    ``static` `void` `findPath(Node root, ``int` `key,` `                  ``Vector arr)` `    ``{` `        ``if` `(root==``null``)` `            ``return``;` `        ``arr.add(root.val);` `        ``// if key is found set flag and return` `        ``if` `(root.val == key) {` `            ``flag = ``1``;` `            ``return``;` `        ``}` `        ``// recur for all children` `        ``for` `(``int` `i = ``0``; i < root.child.size(); i++) {` `     `  `            ``findPath(root.child.get(i), key, arr);` `     `  `            ``// if key is found dont need to pop values` `            ``if` `(flag == ``1``)` `                ``return``;` `        ``}` `     `  `        ``arr.remove(arr.size()-``1``);` `        ``return``;` `    ``}` `     `  `    ``static` `void` `findMinDist(Node root, ``int` `A, ``int` `B)` `    ``{` `        ``if` `(root == ``null``)` `            ``return``;` `        ``int` `val = root.val;` `     `  `        ``// vector to store both paths` `        ``Vector arr1 = ``new` `Vector();` `        ``Vector arr2 = ``new` `Vector();` `     `  `        ``// set flag as false;` `        ``flag = ``0``;` `     `  `        ``// find path from root to node a` `        ``findPath(root, A, arr1);` `     `  `        ``// set flag again as false;` `        ``flag = ``0``;` `     `  `        ``// find path from root to node b` `        ``findPath(root, B, arr2);` `     `  `        ``// to store index of LCA node` `        ``int` `j=``0``;` `     `  `        ``// if unequal values are found` `        ``// return previous value` `        ``for` `(``int` `i = ``1``; i < Math.min(arr1.size(), arr2.size()); i++) {` `            ``if` `(arr1.get(i) != arr2.get(i)) {` `                ``val = arr1.get(i - ``1``);` `                ``j = i - ``1``;` `                ``break``;` `            ``}` `        ``}` `        ``int` `d1 = ``0``, d2 = ``0``;` `     `  `        ``// iterate for finding distance` `        ``// between LCA(a, b) and a` `        ``for` `(``int` `i = j; i < arr1.size(); i++)` `            ``if` `(arr1.get(i) == A)` `                ``break``;` `            ``else` `                ``d1 += ``1``;` `     `  `        ``// iterate for finding distance` `        ``// between LCA(a, b) and b` `        ``for` `(``int` `i = j; i < arr2.size(); i++)` `            ``if` `(arr2.get(i) == B)` `                ``break``;` `            ``else` `                ``d2 += ``1``;` `        ``// get distance` `        ``val = d1 + d2;` `        ``System.out.println(val);` `    ``}` `    `  `    ``public` `static` `void` `main(String[] args) {` `        ``Node root = newNode(``1``);` `        ``(root.child).add(newNode(``2``));` `        ``(root.child).add(newNode(``3``));` `        ``(root.child.get(``0``).child).add(newNode(``4``));` `        ``(root.child.get(``0``).child).add(newNode(``5``));` `        ``(root.child.get(``1``).child).add(newNode(``6``));` `        ``(root.child.get(``1``)).child.add(newNode(``7``));` `        ``(root.child.get(``1``).child).add(newNode(``8``));` `        ``int` `A = ``4``, B = ``3``;` `     `  `        ``// get min distance` `        ``findMinDist(root, A, B);` `    ``}` `}`   `// This code is contributed by mukesh07.`

## Python3

 `# Python3 program for the above approach`   `# Structure of Node` `class` `Node:` `    ``def` `__init__(``self``, key):` `        ``self``.val ``=` `key` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None` `        ``self``.child ``=` `[]`   `# Utility function to create a` `# new tree node` `def` `newNode(key):` `    ``temp ``=` `Node(key)` `    ``return` `temp`   `flag ``=` `0`   `# Function to get the path` `# from root to a node` `def` `findPath(root, key, arr):` `    ``global` `flag` `    ``if` `(root``=``=``None``):` `        ``return` `    ``arr.append(root.val)` `    ``# if key is found set flag and return` `    ``if` `(root.val ``=``=` `key):` `        ``flag ``=` `1` `        ``return` `    ``# recur for all children` `    ``for` `i ``in` `range``(``len``(root.child)):` `        ``findPath(root.child[i], key, arr)`   `        ``# if key is found dont need to pop values` `        ``if` `(flag ``=``=` `1``):` `            ``return`   `    ``arr.pop()` `    ``return`   `def` `findMinDist(root, A, B):` `    ``global` `flag` `    ``if` `(root ``=``=` `None``):` `        ``return` `    ``val ``=` `root.val`   `    ``# vector to store both paths` `    ``arr1 ``=` `[]` `    ``arr2 ``=` `[]`   `    ``# set flag as false;` `    ``flag ``=` `0`   `    ``# find path from root to node a` `    ``findPath(root, A, arr1)`   `    ``# set flag again as false;` `    ``flag ``=` `0`   `    ``# find path from root to node b` `    ``findPath(root, B, arr2)`   `    ``# to store index of LCA node` `    ``j``=``0`   `    ``# if unequal values are found` `    ``# return previous value` `    ``for` `i ``in` `range``(``min``(``len``(arr1), ``len``(arr2))):` `        ``if` `(arr1[i] !``=` `arr2[i]):` `            ``val ``=` `arr1[i ``-` `1``]` `            ``j ``=` `i ``-` `1` `            ``break` `    ``d1, d2 ``=` `0``, ``0`   `    ``# iterate for finding distance` `    ``# between LCA(a, b) and a` `    ``for` `i ``in` `range``(j, ``len``(arr1)):` `        ``if` `(arr1[i] ``=``=` `A):` `            ``break` `        ``else``:` `            ``d1 ``+``=` `1`   `    ``# iterate for finding distance` `    ``# between LCA(a, b) and b` `    ``for` `i ``in` `range``(j, ``len``(arr2)):` `        ``if` `(arr2[i] ``=``=` `B):` `            ``break` `        ``else``:` `            ``d2 ``+``=` `1` `    ``# get distance` `    ``val ``=` `d1 ``+` `d2` `    ``print``(val)`   `root ``=` `newNode(``1``)` `(root.child).append(newNode(``2``))` `(root.child).append(newNode(``3``))` `(root.child[``0``].child).append(newNode(``4``))` `(root.child[``0``].child).append(newNode(``5``))` `(root.child[``1``].child).append(newNode(``6``))` `(root.child[``1``]).child.append(newNode(``7``))` `(root.child[``1``].child).append(newNode(``8``))` `A, B ``=` `4``, ``3`   `# get min distance` `findMinDist(root, A, B)`   `# This code is contributed by rameshtravel07.`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;`   `// Structure of Node` `class` `GFG{`   `    ``public` `class` `Node {` `        ``public` `int` `val;` `        ``public` `Node left=``null``, right=``null``;` `        ``public` `List child = ``new` `List();` `    ``}`   `// Utility function to create a` `// new tree node` `static` `Node newNode(``int` `key)` `{` `    ``Node temp = ``new` `Node();` `    ``temp.val = key;` `    ``return` `temp;` `}`   `static` `int` `flag;`   `// Function to get the path` `// from root to a node` `static` `void` `findPath(Node root, ``int` `key,` `              ``List<``int``> arr)` `{` `    ``if` `(root==``null``)` `        ``return``;` `    ``arr.Add(root.val);` `    ``// if key is found set flag and return` `    ``if` `(root.val == key) {` `        ``flag = 1;` `        ``return``;` `    ``}` `    ``// recur for all children` `    ``for` `(``int` `i = 0; i < root.child.Count; i++) {`   `        ``findPath(root.child[i], key, arr);`   `        ``// if key is found dont need to pop values` `        ``if` `(flag == 1)` `            ``return``;` `    ``}`   `    ``arr.RemoveAt(arr.Count-1);` `    ``return``;` `}`   `static` `void` `findMinDist(Node root, ``int` `A, ``int` `B)` `{` `    ``if` `(root == ``null``)` `        ``return``;` `    ``int` `val = root.val;`   `    ``// vector to store both paths` `    ``List<``int``> arr1 = ``new` `List<``int``>();` `    ``List<``int``> arr2 = ``new` `List<``int``>();`   `    ``// set flag as false;` `    ``flag = 0;`   `    ``// find path from root to node a` `    ``findPath(root, A, arr1);`   `    ``// set flag again as false;` `    ``flag = 0;`   `    ``// find path from root to node b` `    ``findPath(root, B, arr2);`   `    ``// to store index of LCA node` `    ``int` `j=0;`   `    ``// if unequal values are found` `    ``// return previous value` `    ``for` `(``int` `i = 1; i < Math.Min(arr1.Count, arr2.Count); i++) {` `        ``if` `(arr1[i] != arr2[i]) {` `            ``val = arr1[i - 1];` `            ``j = i - 1;` `            ``break``;` `        ``}` `    ``}` `    ``int` `d1 = 0, d2 = 0;`   `    ``// iterate for finding distance` `    ``// between LCA(a, b) and a` `    ``for` `(``int` `i = j; i < arr1.Count; i++)` `        ``if` `(arr1[i] == A)` `            ``break``;` `        ``else` `            ``d1 += 1;`   `    ``// iterate for finding distance` `    ``// between LCA(a, b) and b` `    ``for` `(``int` `i = j; i < arr2.Count; i++)` `        ``if` `(arr2[i] == B)` `            ``break``;` `        ``else` `            ``d2 += 1;` `    ``// get distance` `    ``val = d1 + d2;` `    ``Console.WriteLine(val);` `}`   `// Driver Code` `public` `static` `void` `Main()`   `{` `    ``Node root = newNode(1);` `    ``(root.child).Add(newNode(2));` `    ``(root.child).Add(newNode(3));` `    ``(root.child[0].child).Add(newNode(4));` `    ``(root.child[0].child).Add(newNode(5));` `    ``(root.child[1].child).Add(newNode(6));` `    ``(root.child[1]).child.Add(newNode(7));` `    ``(root.child[1].child).Add(newNode(8));` `    ``int` `A = 4, B = 3;`   `    ``// get min distance` `    ``findMinDist(root, A, B);` `}` `}`   `// This code is contributed by SURENDRA_GANGWAR.`

## Javascript

 ``

Output

`3`

Time complexity: O(N).
Auxiliary Space: O(N).

Previous Article
Next Article
Article Tags :
Practice Tags :