Linked List in Binary Tree - Practice Coding Problems

Linked List in Binary Tree - Problem

Linked List in Binary Tree

You're given two data structures: a binary tree with root node and a linked list starting from the head node. Your task is to determine if there exists a downward path in the binary tree that matches the exact sequence of values in the linked list.

A downward path means you start at any node in the binary tree and follow parent-to-child connections going downwards. The path doesn't need to start from the root - it can begin at any node and go down to any descendant.

Goal: Return True if you can find such a matching downward path, False otherwise.

Example: If your linked list is [4,2,8] and your binary tree contains a path where some node has value 4, its child has value 2, and that child's child has value 8, then return True.

Input & Output

example_1.py — Basic Match Found

$ Input: head = [4,2,8], root = [1,4,4,null,2,2,null,1,null,6,8,null,null,null,null,1,3]

› Output: true

💡 Note: The linked list [4,2,8] can be found as a downward path in the binary tree starting from the node with value 4 (left child of root), then its left child 2, then its right child 8.

example_2.py — No Match Found

$ Input: head = [1,4,2,6], root = [1,4,4,null,2,2,null,1,null,6,8,null,null,null,null,1,3]

› Output: false

💡 Note: Although all individual values [1,4,2,6] exist in the tree, there is no downward path that contains this exact sequence. The paths get broken - we can't find 6 as a child of any node with value 2 that follows the pattern.

example_3.py — Single Node Match

$ Input: head = [1,4,2,6,8], root = [1,4,4,null,2,2,null,1,null,6,8,null,null,null,null,1,3]

› Output: false

💡 Note: The sequence [1,4,2,6,8] is too long. While we can match [1,4,2,6] starting from root, we cannot extend this path further to include 8 as the next child, since 6 doesn't have 8 as a child in the required downward path.

Constraints

The number of nodes in the tree is in the range [1, 2500]
The number of nodes in the list is in the range [1, 100]
1 ≤ Node.val ≤ 100
Both tree and linked list nodes can have duplicate values
Tree nodes and list nodes are guaranteed to be integers

Visualization

Tap to expand

Understanding the Visualization

Find Starting Points

Visit each node in the binary tree as a potential starting point for our sequence

Validate Downward Path

From each starting point, check if we can follow children that match our linked list sequence

Match Complete Sequence

Ensure the entire linked list can be matched by following one continuous downward path

Return Success

Return true as soon as we find any valid path, or false if no path exists

Key Takeaway

🎯 Key Insight: Separate tree exploration from path validation - use DFS to find all potential starting nodes, then use a helper function to verify if the complete linked list sequence can be matched by following a single downward path.

Asked in

a Amazon 42 ⊞ Microsoft 28 G Google 21 f Meta 15

The optimal approach uses DFS traversal with a separate path matching function. For each tree node, we attempt to match the linked list sequence starting from that node going downward. The key insight is to separate the tree exploration (finding potential starting points) from path validation (checking if a complete sequence exists). Time complexity is O(N × min(L,H)) where N is tree nodes, L is list length, and H is tree height.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Node)	O(N × min(L,H))	O(H)	For each tree node, check if a downward path starting from it matches the linked list
KMP + DFS Optimization	O(N + L)	O(L + H)	Preprocess linked list with KMP algorithm, then use DFS with optimized backtracking

Brute Force (Check Every Node) — Algorithm Steps

Start DFS traversal from the root of the binary tree
For each node visited, call a helper function to check path matching
The helper function compares current tree node value with current linked list node value
If they match, recursively check both left and right children with the next linked list node
If we reach the end of the linked list, we found a valid path
Return true if any starting node produces a valid path

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Root

Begin DFS from root, check if path starting here matches linked list

Check Left Subtree

Recursively check all nodes in left subtree as potential starting points

Check Right Subtree

Recursively check all nodes in right subtree as potential starting points

Path Validation

For each potential start node, validate complete downward path

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

// Definition for singly-linked list.
struct ListNode {
    int val;
    struct ListNode *next;
};

// Definition for a binary tree node.
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

bool dfsMatch(struct TreeNode* treeNode, struct ListNode* listNode) {
    if (!listNode) return true;
    if (!treeNode) return false;
    
    if (treeNode->val == listNode->val) {
        return dfsMatch(treeNode->left, listNode->next) || dfsMatch(treeNode->right, listNode->next);
    }
    return false;
}

bool isSubPath(struct ListNode* head, struct TreeNode* root) {
    if (!root) return false;
    return dfsMatch(root, head) || isSubPath(head, root->left) || isSubPath(head, root->right);
}

Time & Space Complexity

Time Complexity

⏱️

O(N × min(L,H))

N is the number of tree nodes, L is linked list length, H is tree height. For each node we potentially traverse down min(L,H) levels

✓ Linear Growth

Space Complexity

O(H)

Recursion stack depth is at most the height of the tree

✓ Linear Space

73.2K Views

Medium-High Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check Every Node) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler