给定一个由N个节点和一个整数K组成的二叉树，任务是在二叉树中找到值为K的节点的深度和高度。
The depth of a node is the number of edges present in path from the root node of a tree to that node.
The height of a node is the number of edges present in the longest path connecting that node to a leaf node.
例子：
Input: K = 25,
5
/ \
10 15
/ \ / \
20 25 30 35
\
45
Output:
Depth of node 25 = 2
Height of node 25 = 1
Explanation:
The number of edges in the path from root node to the node 25 is 2. Therefore, depth of the node 25 is 2.
The number of edges in the longest path connecting the node 25 to any leaf node is 1. Therefore, height of the node 25 is 1.
Input: K = 10,
5
/ \
10 15
/ \ / \
20 25 30 35
\
45
Output:
Depth of node 10 = 1
Height of node 10 = 2
方法：可以根据以下观察结果解决问题：
Depth of a node K (of a Binary Tree) = Number of edges in the path connecting the root to the node K = Number of ancestors of K (excluding K itself).
请按照以下步骤查找给定节点的深度：
- 如果树为空，则打印-1。
- 否则，请执行以下步骤：
- 初始化一个变量，说dist为-1 。
- 检查节点K是否等于给定节点。
- 否则，通过分别递归地检查左侧和右侧子树，检查它是否存在于任何一个子树中。
- 如果发现是真的，则打印dist + 1的值。
- 否则，输出dist 。
Height of a node K (of a Binary Tree) = Number of edges in the longest path connecting K to any leaf node.
请按照以下步骤查找给定节点的高度：
- 如果树为空，则打印-1。
- 否则，请执行以下步骤：
- 递归计算左子树的高度。
- 递归计算右子树的高度。
- 通过将上一步中获得的两个高度的最大值加1来更新当前节点的高度。将高度存储在变量中，例如ans 。
- 如果当前节点等于给定的节点K，则打印ans的值作为所需答案。
下面是上述方法的实现：
C++
// C++ program for the above approach
#include
using namespace std;
// Structure of a Binary Tree Node
struct Node {
int data;
Node *left, *right;
};
// Utility function to create
// a new Binary Tree Node
Node* newNode(int item)
{
Node* temp = new Node;
temp->data = item;
temp->left = temp->right = NULL;
return temp;
}
// Function to find the depth of
// a given node in a Binary Tree
int findDepth(Node* root, int x)
{
// Base case
if (root == NULL)
return -1;
// Initialize distance as -1
int dist = -1;
// Check if x is current node=
if ((root->data == x)
// Otherwise, check if x is
// present in the left subtree
|| (dist = findDepth(root->left, x)) >= 0
// Otherwise, check if x is
// present in the right subtree
|| (dist = findDepth(root->right, x)) >= 0)
// Return depth of the node
return dist + 1;
return dist;
}
// Helper function to find the height
// of a given node in the binary tree
int findHeightUtil(Node* root, int x,
int& height)
{
// Base Case
if (root == NULL) {
return -1;
}
// Store the maximum height of
// the left and right subtree
int leftHeight = findHeightUtil(
root->left, x, height);
int rightHeight
= findHeightUtil(
root->right, x, height);
// Update height of the current node
int ans = max(leftHeight, rightHeight) + 1;
// If current node is the required node
if (root->data == x)
height = ans;
return ans;
}
// Function to find the height of
// a given node in a Binary Tree
int findHeight(Node* root, int x)
{
// Store the height of
// the given node
int h = -1;
// Stores height of the Tree
int maxHeight = findHeightUtil(root, x, h);
// Return the height
return h;
}
// Driver Code
int main()
{
// Binary Tree Formation
Node* root = newNode(5);
root->left = newNode(10);
root->right = newNode(15);
root->left->left = newNode(20);
root->left->right = newNode(25);
root->left->right->right = newNode(45);
root->right->left = newNode(30);
root->right->right = newNode(35);
int k = 25;
// Function call to find the
// depth of a given node
cout << "Depth: "
<< findDepth(root, k) << "\n";
// Function call to find the
// height of a given node
cout << "Height: " << findHeight(root, k);
return 0;
} Java
// Java program for the above approach
import java.util.*;
class GFG
{
static int height = -1;
// Structure of a Binary Tree Node
static class Node
{
int data;
Node left;
Node right;
};
// Utility function to create
// a new Binary Tree Node
static Node newNode(int item)
{
Node temp = new Node();
temp.data = item;
temp.left = temp.right = null;
return temp;
}
// Function to find the depth of
// a given node in a Binary Tree
static int findDepth(Node root, int x)
{
// Base case
if (root == null)
return -1;
// Initialize distance as -1
int dist = -1;
// Check if x is current node=
if ((root.data == x)||
// Otherwise, check if x is
// present in the left subtree
(dist = findDepth(root.left, x)) >= 0 ||
// Otherwise, check if x is
// present in the right subtree
(dist = findDepth(root.right, x)) >= 0)
// Return depth of the node
return dist + 1;
return dist;
}
// Helper function to find the height
// of a given node in the binary tree
static int findHeightUtil(Node root, int x)
{
// Base Case
if (root == null)
{
return -1;
}
// Store the maximum height of
// the left and right subtree
int leftHeight = findHeightUtil(root.left, x);
int rightHeight = findHeightUtil(root.right, x);
// Update height of the current node
int ans = Math.max(leftHeight, rightHeight) + 1;
// If current node is the required node
if (root.data == x)
height = ans;
return ans;
}
// Function to find the height of
// a given node in a Binary Tree
static int findHeight(Node root, int x)
{
// Stores height of the Tree
findHeightUtil(root, x);
// Return the height
return height;
}
// Driver Code
public static void main(String []args)
{
// Binary Tree Formation
Node root = newNode(5);
root.left = newNode(10);
root.right = newNode(15);
root.left.left = newNode(20);
root.left.right = newNode(25);
root.left.right.right = newNode(45);
root.right.left = newNode(30);
root.right.right = newNode(35);
int k = 25;
// Function call to find the
// depth of a given node
System.out.println("Depth: " + findDepth(root, k));
// Function call to find the
// height of a given node
System.out.println("Height: " + findHeight(root, k));
}
}
// This code is contributed by SURENDRA_GANGWARPython3
# Python3 program for the above approach
# Structure of a Binary Tree Node
class Node:
def __init__(self, x):
self.data = x
self.left = None
self.right = None
# Function to find the depth of
# a given node in a Binary Tree
def findDepth(root, x):
# Base case
if (root == None):
return -1
# Initialize distance as -1
dist = -1
# Check if x is current node=
if (root.data == x):
return dist + 1
dist = findDepth(root.left, x)
if dist >= 0:
return dist + 1
dist = findDepth(root.right, x)
if dist >= 0:
return dist + 1
return dist
# Helper function to find the height
# of a given node in the binary tree
def findHeightUtil(root, x):
global height
# Base Case
if (root == None):
return -1
# Store the maximum height of
# the left and right subtree
leftHeight = findHeightUtil(root.left, x)
rightHeight = findHeightUtil(root.right, x)
# Update height of the current node
ans = max(leftHeight, rightHeight) + 1
# If current node is the required node
if (root.data == x):
height = ans
return ans
# Function to find the height of
# a given node in a Binary Tree
def findHeight(root, x):
global height
# Stores height of the Tree
maxHeight = findHeightUtil(root, x)
# Return the height
return height
# Driver Code
if __name__ == '__main__':
# Binary Tree Formation
height = -1
root = Node(5)
root.left = Node(10)
root.right = Node(15)
root.left.left = Node(20)
root.left.right = Node(25)
root.left.right.right = Node(45)
root.right.left = Node(30)
root.right.right = Node(35)
k = 25
# Function call to find the
# depth of a given node
print("Depth: ",findDepth(root, k))
# Function call to find the
# height of a given node
print("Height: ",findHeight(root, k))
# This code is contributed by mohit kumar 29.C#
// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG{
static int height = -1;
// Structure of a Binary Tree Node
class Node
{
public int data;
public Node left;
public Node right;
};
// Utility function to create
// a new Binary Tree Node
static Node newNode(int item)
{
Node temp = new Node();
temp.data = item;
temp.left = temp.right = null;
return temp;
}
// Function to find the depth of
// a given node in a Binary Tree
static int findDepth(Node root, int x)
{
// Base case
if (root == null)
return -1;
// Initialize distance as -1
int dist = -1;
// Check if x is current node=
if ((root.data == x)||
// Otherwise, check if x is
// present in the left subtree
(dist = findDepth(root.left, x)) >= 0 ||
// Otherwise, check if x is
// present in the right subtree
(dist = findDepth(root.right, x)) >= 0)
// Return depth of the node
return dist + 1;
return dist;
}
// Helper function to find the height
// of a given node in the binary tree
static int findHeightUtil(Node root, int x)
{
// Base Case
if (root == null)
{
return -1;
}
// Store the maximum height of
// the left and right subtree
int leftHeight = findHeightUtil(root.left, x);
int rightHeight = findHeightUtil(root.right, x);
// Update height of the current node
int ans = Math.Max(leftHeight, rightHeight) + 1;
// If current node is the required node
if (root.data == x)
height = ans;
return ans;
}
// Function to find the height of
// a given node in a Binary Tree
static int findHeight(Node root, int x)
{
// Stores height of the Tree
findHeightUtil(root, x);
// Return the height
return height;
}
// Driver Code
public static void Main()
{
// Binary Tree Formation
Node root = newNode(5);
root.left = newNode(10);
root.right = newNode(15);
root.left.left = newNode(20);
root.left.right = newNode(25);
root.left.right.right = newNode(45);
root.right.left = newNode(30);
root.right.right = newNode(35);
int k = 25;
// Function call to find the
// depth of a given node
Console.WriteLine("Depth: " + findDepth(root, k));
// Function call to find the
// height of a given node
Console.WriteLine("Height: " + findHeight(root, k));
}
}
// This code is contributed by ipg2016107输出：
Depth: 2
Height: 1时间复杂度： O(N)
辅助空间： O(1)