给定一棵二叉树，任务是构造一个数组，使得数组的第i个索引包含存在于给定二叉树的第i个垂直级别的所有节点的 GCD。
例子：
Input: Below is the given Tree:
5
/ \
4 7
/ \ \
8 10 6
\
8
Output: {8, 4, 5, 7, 6}
Explanation:
Vertical level I -> GCD(8) = 8.
Vertical level II -> GCD(4, 8) = 4.
Vertical level II -> GCD(5, 10) = 5.
Vertical level IV -> GCD(7) = 7.
Verticleal level V -> GCD(6) = 6
Input: Below is the given Tree:
4
/ \
2 3
/ \ / \
3 2 4 5
Output: {3, 2, 2, 3, 5}
方法：可以通过执行给定树的垂直顺序遍历并存储出现在相同垂直线上的每个节点的值，然后打印为每个级别存储的所有值的 GCD 来解决给定的问题。请按照以下步骤解决此问题：
- 初始化一个 Map M来存储执行遍历时每条垂直线的所有节点的 GCD。
- 初始化一个变量，比如hd为0以跟踪水平距离。
- 递归遍历给定的树并执行以下步骤：
- 将当前节点的值存储在映射M 中作为键作为hd和值作为节点的值。
- 将变量hd减1并递归调用左子树。
- 将变量hd增加1并递归调用右子树。
- 遍历地图，以每个水平距离找到地图中存储的所有节点的GCD作为key，打印得到的GCD值。
下面是上述方法的实现：
C++
// C++ program for the above approach
#include
using namespace std;
// Class for node of binary tree
struct TreeNode
{
int val;
TreeNode *left, *right;
TreeNode(int x)
{
val = x;
left = right = NULL;
}
};
// Function to find GCD of two numbers
int GCD(int a, int b)
{
if (!b)
return a;
// Recursively find the GCD
return GCD(b, a % b);
}
// Stores the element for each
// vertical distance
unordered_map mp;
// Function to traverse the tree
void Trav(TreeNode *root, int hd)
{
if (!root)
return;
// Store the values in the map
if (mp[hd] == 0)
mp[hd] = root->val;
else
mp[hd] = GCD(mp[hd], root->val);
// Recursive Calls
Trav(root->left, hd - 1);
Trav(root->right, hd + 1);
}
// Function to construct array from
// vertically positioned nodes
void constructArray(TreeNode *root)
{
Trav(root, 0);
// Get range of horizontal distances
int lower = INT_MAX, upper = 0;
for(auto it:mp)
{
lower = min(lower, it.first);
upper = max(upper, it.first);
}
vector ans;
// Extract the array of values
for(int i = lower; i < upper + 1; i++)
ans.push_back(mp[i]);
// Print the constructed array
cout << "[";
for(int i = 0; i < ans.size() - 1; i++)
cout << ans[i] << ", ";
cout << ans[ans.size() - 1] << "]";
}
// Driver code
int main()
{
TreeNode *root = new TreeNode(5);
root->left = new TreeNode(4);
root->right = new TreeNode(7);
root->left->left = new TreeNode(8);
root->left->left->right = new TreeNode(8);
root->left->right = new TreeNode(10);
root->right->right = new TreeNode(6);
// Function Call
constructArray(root);
return 0;
}
// This code is contributed by mohit kumar 29 Java
// Java program for the above approach
import java.lang.*;
import java.util.*;
// Class containing the left and right
// child of current node and the
// key value
class Node
{
int val;
Node left, right;
// Constructor of the class
public Node(int item)
{
val = item;
left = right = null;
}
}
class GFG{
Node root;
// Stores the element for each
// vertical distance
static Map mp = new HashMap<>();
// Function to find GCD of two numbers
static int GCD(int a, int b)
{
if (b == 0)
return a;
// Recursively find the GCD
return GCD(b, a % b);
}
// Function to traverse the tree
static void Trav(Node root, int hd)
{
if (root == null)
return;
// Store the values in the map
if (!mp.containsKey(hd))
mp.put(hd, root.val);
else
mp.put(hd, GCD(mp.get(hd), root.val));
// Recursive Calls
Trav(root.left, hd - 1);
Trav(root.right, hd + 1);
}
// Function to construct array from
// vertically positioned nodes
static void constructArray(Node root)
{
Trav(root, 0);
// Get range of horizontal distances
int lower = Integer.MAX_VALUE, upper = 0;
for(Map.Entry it:mp.entrySet())
{
lower = Math.min(lower, it.getKey());
upper = Math.max(upper, it.getKey());
}
ArrayList ans = new ArrayList<>();
// Extract the array of values
for(int i = lower; i < upper + 1; i++)
ans.add(mp.getOrDefault(i,0));
// Print the constructed array
System.out.print("[");
for(int i = 0; i < ans.size() - 1; i++)
System.out.print(ans.get(i) + ", ");
System.out.print(ans.get(ans.size() - 1) + "]");
}
// Driver code
public static void main(String[] args)
{
GFG tree = new GFG();
Node root = new Node(5);
root.left = new Node(4);
root.right = new Node(7);
root.left.left = new Node(8);
root.left.left.right = new Node(8);
root.left.right = new Node(10);
root.right.right = new Node(6);
// Function Call
constructArray(root);
}
}
// This code is contributed by offbeat Python3
# Python3 program for the above approach
# Class for node of binary tree
class TreeNode:
def __init__(self, val ='', left = None, right = None):
self.val = val
self.left = left
self.right = right
# Function to find GCD of two numbers
def GCD(a, b):
if not b:
return a
# Recursively find the GCD
return GCD(b, a % b)
# Function to construct array from
# vertically positioned nodes
def constructArray(root):
# Stores the element for each
# vertical distance
mp = {}
# Function to traverse the tree
def Trav(root, hd):
if not root:
return
# Store the values in the map
if hd not in mp:
mp[hd] = root.val
else:
mp[hd] = GCD(mp[hd], root.val)
# Recursive Calls
Trav(root.left, hd-1)
Trav(root.right, hd + 1)
Trav(root, 0)
# Get range of horizontal distances
lower = min(mp.keys())
upper = max(mp.keys())
ans = []
# Extract the array of values
for i in range(lower, upper + 1):
ans.append(mp[i])
# Print the constructed array
print(ans)
# Driver Code
# Given Tree
root = TreeNode(5)
root.left = TreeNode(4)
root.right = TreeNode(7)
root.left.left = TreeNode(8)
root.left.left.right = TreeNode(8)
root.left.right = TreeNode(10)
root.right.right = TreeNode(6)
# Function Call
constructArray(root)[8, 4, 5, 7, 6]时间复杂度： O(N*log N)
辅助空间： O(N)
如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live