给定一棵二叉树，任务是打印从根节点到叶节点的最长路径。如果有多个答案，请打印其中任何一个。
例子：
Input:
4
/ \
3 6
/ \
5 7
Output:
4 -> 6 -> 7
Explanation:
Longest paths from root to leaf
are (4 -> 6 -> 5)
and (4 -> 6 -> 7).
Print any of them.
Input:
1
/ \
2 3
/ \
4 5
\
6
Output:
1 -> 2 -> 5 -> 6
朴素的方法：想法是生成从根节点到所有叶节点的所有可能路径，跟踪最大长度的路径，最后打印最长的路径。
时间复杂度： O(N 2 )
Efficient Approach：想法是使用递归来有效地解决这个问题。主要思想是递归地从左子树和右子树中获取最长路径，然后将当前节点添加到具有更大长度的节点上，它将是从当前节点到叶子的最长路径。从根节点开始，对每个递归调用的节点执行以下步骤。
- 如果根节点为空，则不存在路径，则返回一个空向量。
- 通过递归遍历root -> right，从向量rightvect 中的右子树获取最长路径。
- 类似地，通过递归遍历root -> left得到向量leftvect 中左子树的最长路径。
- 比较rightvect和leftvect的长度，并将当前节点附加到两者中较长的一个并返回该向量。
按照上述步骤，树遍历结束时得到的向量就是可能的最长路径。反向打印向量作为从根到叶的最长路径。
查看此图像以了解如何使用来自左子树和右子树的节点的最长路径来获取来自当前节点的最长路径：
下面是上述方法的实现：
C++
// C++ Program to print Longest Path
// from root to leaf in a Binary tree
#include
using namespace std;
// Tree node Structure
struct Node {
int data;
Node *left, *right;
};
struct Node* newNode(int data)
{
struct Node* node = new Node;
node->data = data;
node->left = node->right = NULL;
return (node);
}
// Function to find and return the
// longest path
vector longestPath(Node* root)
{
// If root is null means there
// is no binary tree so
// return a empty vector
if (root == NULL) {
vector temp
= {};
return temp;
}
// Recursive call on root->right
vector rightvect
= longestPath(root->right);
// Recursive call on root->left
vector leftvect
= longestPath(root->left);
// Compare the size of the two vectors
// and insert current node accordingly
if (leftvect.size() > rightvect.size())
leftvect.push_back(root->data);
else
rightvect.push_back(root->data);
// Return the appropriate vector
return (leftvect.size() > rightvect.size()
? leftvect
: rightvect);
}
// Driver Code
int main()
{
struct Node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
root->left->right->right = newNode(6);
vector output = longestPath(root);
int n = output.size();
cout << output[n - 1];
for (int i = n - 2; i >= 0; i--) {
cout << " -> " << output[i];
}
return 0;
} Java
// Java program to print Longest Path
// from root to leaf in a Binary tree
import java.io.*;
import java.util.ArrayList;
class GFG{
// Binary tree node
static class Node
{
Node left;
Node right;
int data;
};
// Function to create a new
// Binary node
static Node newNode(int data)
{
Node temp = new Node();
temp.data = data;
temp.left = null;
temp.right = null;
return temp;
}
// Function to find and return the
// longest path
public static ArrayList longestPath(Node root)
{
// If root is null means there
// is no binary tree so
// return a empty vector
if(root == null)
{
ArrayList output = new ArrayList<>();
return output;
}
// Recursive call on root.right
ArrayList right = longestPath(root.right);
// Recursive call on root.left
ArrayList left = longestPath(root.left);
// Compare the size of the two ArrayList
// and insert current node accordingly
if(right.size() < left.size())
{
left.add(root.data);
}
else
{
right.add(root.data);
}
// Return the appropriate ArrayList
return (left.size() >
right.size() ? left :right);
}
// Driver Code
public static void main(String[] args)
{
Node root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.left = newNode(4);
root.left.right = newNode(5);
root.left.right.right = newNode(6);
ArrayList output = longestPath(root);
int n = output.size();
System.out.print(output.get(n - 1));
for(int i = n - 2; i >= 0; i--)
{
System.out.print(" -> " + output.get(i));
}
}
}
// This code is contributed by HamreetSingh Python3
# Python3 program to print longest path
# from root to leaf in a Binary tree
# Tree node Structure
class Node:
def __init__(self, key):
self.data = key
self.left = None
self.right = None
# Function to find and return the
# longest path
def longestPath(root):
# If root is null means there
# is no binary tree so
# return a empty vector
if (root == None):
return []
# Recursive call on root.right
rightvect = longestPath(root.right)
# Recursive call on root.left
leftvect = longestPath(root.left)
# Compare the size of the two vectors
# and insert current node accordingly
if (len(leftvect) > len(rightvect)):
leftvect.append(root.data)
else:
rightvect.append(root.data)
# Return the appropriate vector
if len(leftvect) > len(rightvect):
return leftvect
return rightvect
# Driver Code
if __name__ == '__main__':
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)
root.left.right.right = Node(6)
output = longestPath(root)
n = len(output)
print(output[n - 1], end = "")
for i in range(n - 2, -1, -1):
print(" ->", output[i], end = "")
# This code is contributed by mohit kumar 29C#
// C# program to print
// longest Path from
// root to leaf in a
// Binary tree
using System;
using System.Collections.Generic;
class GFG{
// Binary tree node
class Node
{
public Node left;
public Node right;
public int data;
};
// Function to create a new
// Binary node
static Node newNode(int data)
{
Node temp = new Node();
temp.data = data;
temp.left = null;
temp.right = null;
return temp;
}
// Function to find and
// return the longest path
static List longestPath(Node root)
{
// If root is null means there
// is no binary tree so
// return a empty vector
if(root == null)
{
List output = new List();
return output;
}
// Recursive call on root.right
List right = longestPath(root.right);
// Recursive call on root.left
List left = longestPath(root.left);
// Compare the size of the two List
// and insert current node accordingly
if(right.Count < left.Count)
{
left.Add(root.data);
}
else
{
right.Add(root.data);
}
// Return the appropriate List
return (left.Count >
right.Count ?
left :right);
}
// Driver Code
public static void Main(String[] args)
{
Node root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.left = newNode(4);
root.left.right = newNode(5);
root.left.right.right = newNode(6);
List output = longestPath(root);
int n = output.Count;
Console.Write(output[n - 1]);
for(int i = n - 2; i >= 0; i--)
{
Console.Write(" -> " + output[i]);
}
}
}
// This code is contributed by 29AjayKumar 输出
1 -> 2 -> 5 -> 6
时间复杂度： O(N)
辅助空间： O(N)
如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live