打印二叉树中的所有 k-sum 路径
给出一棵二叉树和一个数 k。打印树中的每条路径，路径中的节点总和为 k。
路径可以从任意节点开始，到任意节点结束，并且只能向下，即它们不必是根节点和叶节点；树中也可以有负数。
例子：
Input : k = 5
Root of below binary tree:
1
/ \
3 -1
/ \ / \
2 1 4 5
/ / \ \
1 1 2 6
Output :
3 2
3 1 1
1 3 1
4 1
1 -1 4 1
-1 4 2
5
1 -1 5 来源：亚马逊面试体验集-323
请注意，这个问题与查找从根到叶的 k-sum 路径有很大不同。这里每个节点都可以被视为根，因此路径可以在任何节点开始和结束。
解决问题的基本思想是对给定的树进行前序遍历。我们还需要一个容器（向量）来跟踪通向该节点的路径。在每个节点，我们检查是否有任何总和为 k 的路径，如果有，我们打印路径并递归地继续打印每条路径。
下面是相同的实现。
C++
// C++ program to print all paths with sum k.
#include
using namespace std;
// utility function to print contents of
// a vector from index i to it's end
void printVector(const vector& v, int i)
{
for (int j = i; j < v.size(); j++)
cout << v[j] << " ";
cout << endl;
}
// binary tree node
struct Node {
int data;
Node *left, *right;
Node(int x)
{
data = x;
left = right = NULL;
}
};
// This function prints all paths that have sum k
void printKPathUtil(Node* root, vector& path, int k)
{
// empty node
if (!root)
return;
// add current node to the path
path.push_back(root->data);
// check if there's any k sum path
// in the left sub-tree.
printKPathUtil(root->left, path, k);
// check if there's any k sum path
// in the right sub-tree.
printKPathUtil(root->right, path, k);
// check if there's any k sum path that
// terminates at this node
// Traverse the entire path as
// there can be negative elements too
int f = 0;
for (int j = path.size() - 1; j >= 0; j--) {
f += path[j];
// If path sum is k, print the path
if (f == k)
printVector(path, j);
}
// Remove the current element from the path
path.pop_back();
}
// A wrapper over printKPathUtil()
void printKPath(Node* root, int k)
{
vector path;
printKPathUtil(root, path, k);
}
// Driver code
int main()
{
Node* root = new Node(1);
root->left = new Node(3);
root->left->left = new Node(2);
root->left->right = new Node(1);
root->left->right->left = new Node(1);
root->right = new Node(-1);
root->right->left = new Node(4);
root->right->left->left = new Node(1);
root->right->left->right = new Node(2);
root->right->right = new Node(5);
root->right->right->right = new Node(2);
int k = 5;
printKPath(root, k);
return 0;
} Java
// Java program to print all paths with sum k.
import java.util.*;
class GFG {
// utility function to print contents of
// a vector from index i to it's end
static void printVector(Vector v, int i)
{
for (int j = i; j < v.size(); j++)
System.out.print(v.get(j) + " ");
System.out.println();
}
// binary tree node
static class Node {
int data;
Node left, right;
Node(int x)
{
data = x;
left = right = null;
}
};
static Vector path = new Vector();
// This function prints all paths that have sum k
static void printKPathUtil(Node root, int k)
{
// empty node
if (root == null)
return;
// add current node to the path
path.add(root.data);
// check if there's any k sum path
// in the left sub-tree.
printKPathUtil(root.left, k);
// check if there's any k sum path
// in the right sub-tree.
printKPathUtil(root.right, k);
// check if there's any k sum path that
// terminates at this node
// Traverse the entire path as
// there can be negative elements too
int f = 0;
for (int j = path.size() - 1; j >= 0; j--) {
f += path.get(j);
// If path sum is k, print the path
if (f == k)
printVector(path, j);
}
// Remove the current element from the path
path.remove(path.size() - 1);
}
// A wrapper over printKPathUtil()
static void printKPath(Node root, int k)
{
path = new Vector();
printKPathUtil(root, k);
}
// Driver code
public static void main(String args[])
{
Node root = new Node(1);
root.left = new Node(3);
root.left.left = new Node(2);
root.left.right = new Node(1);
root.left.right.left = new Node(1);
root.right = new Node(-1);
root.right.left = new Node(4);
root.right.left.left = new Node(1);
root.right.left.right = new Node(2);
root.right.right = new Node(5);
root.right.right.right = new Node(2);
int k = 5;
printKPath(root, k);
}
}
// This code is contributed by Arnab Kundu Python3
# Python3 program to print all paths
# with sum k
# utility function to print contents of
# a vector from index i to it's end
def printVector(v, i):
for j in range(i, len(v)):
print(v[j], end=" ")
print()
# Binary Tree Node
""" utility that allocates a newNode
with the given key """
class newNode:
# Construct to create a newNode
def __init__(self, key):
self.data = key
self.left = None
self.right = None
# This function prints all paths
# that have sum k
def printKPathUtil(root, path, k):
# empty node
if (not root):
return
# add current node to the path
path.append(root.data)
# check if there's any k sum path
# in the left sub-tree.
printKPathUtil(root.left, path, k)
# check if there's any k sum path
# in the right sub-tree.
printKPathUtil(root.right, path, k)
# check if there's any k sum path that
# terminates at this node
# Traverse the entire path as
# there can be negative elements too
f = 0
for j in range(len(path) - 1, -1, -1):
f += path[j]
# If path sum is k, print the path
if (f == k):
printVector(path, j)
# Remove the current element
# from the path
path.pop(-1)
# A wrapper over printKPathUtil()
def printKPath(root, k):
path = []
printKPathUtil(root, path, k)
# Driver Code
if __name__ == '__main__':
root = newNode(1)
root.left = newNode(3)
root.left.left = newNode(2)
root.left.right = newNode(1)
root.left.right.left = newNode(1)
root.right = newNode(-1)
root.right.left = newNode(4)
root.right.left.left = newNode(1)
root.right.left.right = newNode(2)
root.right.right = newNode(5)
root.right.right.right = newNode(2)
k = 5
printKPath(root, k)
# This code is contributed by
# Shubham Singh(SHUBHAMSINGH10)C#
// C# program to print all paths with sum k.
using System;
using System.Collections.Generic;
class GFG {
// utility function to print contents of
// a vector from index i to it's end
static void printList(List v, int i)
{
for (int j = i; j < v.Count; j++)
Console.Write(v[j] + " ");
Console.WriteLine();
}
// binary tree node
public class Node {
public int data;
public Node left, right;
public Node(int x)
{
data = x;
left = right = null;
}
};
static List path = new List();
// This function prints all paths that have sum k
static void printKPathUtil(Node root, int k)
{
// empty node
if (root == null)
return;
// add current node to the path
path.Add(root.data);
// check if there's any k sum path
// in the left sub-tree.
printKPathUtil(root.left, k);
// check if there's any k sum path
// in the right sub-tree.
printKPathUtil(root.right, k);
// check if there's any k sum path that
// terminates at this node
// Traverse the entire path as
// there can be negative elements too
int f = 0;
for (int j = path.Count - 1; j >= 0; j--) {
f += path[j];
// If path sum is k, print the path
if (f == k)
printList(path, j);
}
// Remove the current element from the path
path.RemoveAt(path.Count - 1);
}
// A wrapper over printKPathUtil()
static void printKPath(Node root, int k)
{
path = new List();
printKPathUtil(root, k);
}
// Driver code
public static void Main(String[] args)
{
Node root = new Node(1);
root.left = new Node(3);
root.left.left = new Node(2);
root.left.right = new Node(1);
root.left.right.left = new Node(1);
root.right = new Node(-1);
root.right.left = new Node(4);
root.right.left.left = new Node(1);
root.right.left.right = new Node(2);
root.right.right = new Node(5);
root.right.right.right = new Node(2);
int k = 5;
printKPath(root, k);
}
}
// This code is contributed by PrinciRaj1992 Javascript
// Tree node class for Binary Tree
// representation
class Node {
constructor(data) {
this.data = data;
this.left = this.right = null;
}
}
function printPathUtil(node, k, path_arr, all_path_arr) {
if (node == null) {
return;
}
let p1 = node.data.toString();
let p2 = '';
if (path_arr.length > 0) {
p2 = path_arr + ',' + p1;
}
else {
p2 = p1;
}
if (node.data == k) {
all_path_arr.add(p1);
}
let sum = 0;
let p2_arr = p2.split(',');
for (let i = 0; i < p2_arr.length; i++) {
sum = sum + Number(p2_arr[i]);
}
if (sum == k) {
all_path_arr.add(p2);
}
printPathUtil(node.left, k, p1, all_path_arr)
printPathUtil(node.left, k, p2, all_path_arr)
printPathUtil(node.right, k, p1, all_path_arr)
printPathUtil(node.right, k, p2, all_path_arr)
}
function printKPath(root, k) {
let all_path_arr = new Set();
printPathUtil(root, k, '', all_path_arr);
return all_path_arr;
}
function printPaths(paths) {
for (let data of paths) {
document.write(data.replaceAll(',', ' '));
document.write('
');
}
}
// Driver code
let root = new Node(1);
root.left = new Node(3);
root.left.left = new Node(2);
root.left.right = new Node(1);
root.left.right.left = new Node(1);
root.right = new Node(-1);
root.right.left = new Node(4);
root.right.left.left = new Node(1);
root.right.left.right = new Node(2);
root.right.right = new Node(5);
root.right.right.right = new Node(2);
let k = 5;
printPaths(printKPath(root, k));
// This code is contributed by gaurav2146输出：
3 2
3 1 1
1 3 1
4 1
1 -1 4 1
-1 4 2
5
1 -1 5 时间复杂度： O(n*h*h) ，因为路径向量的最大大小可以是 h
空间复杂度：O(h)