Open In App

Check if given sorted sub-sequence exists in binary search tree

Last Updated : 23 Jul, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report

Given a binary search tree and a sorted sub-sequence, the task is to check if the given sorted sub-sequence exists in the binary search tree or not.

Examples:

Input: seq[] = {4, 6, 8, 14}

Check-if-given-sorted-sub-sequence-exists-in-binary-search-tree

Output: True

Input: seq[] = {4, 6, 8, 12, 13}

Check-if-given-sorted-sub-sequence-exists-in-binary-search-tree

Output: False

A simple solution is to store inorder traversal in an auxiliary array and then by matching elements of sorted sub-sequence one by one with inorder traversal of tree , we can if sub-sequence exist in BST or not. Time complexity for this approach will be O(n) but it requires extra space O(n) for storing traversal in an array.

Table of Content

[Naive Approach] Using In-order traversal - O(n) Time and O(h) Space

An efficient solution is to match elements of sub-sequence while we are traversing BST in inorder fashion. We take index as a iterator for given sorted sub-sequence and start inorder traversal of given bst, if current node matches with seq[index] then move index in forward direction by incrementing 1 and after complete traversal of BST if index==n that means all elements of given sub-sequence have been matched and exist as a sorted sub-sequence in given BST. 

Below is the implementation of the above approach: 

C++ 
// C++ program to find if given array exists as a
// subsequence in BST
#include<bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node *left, *right;
    Node (int x) {
        data = x;
        left = nullptr;
        right = nullptr;
    }
};

// Function to traverse the tree in in-order traversal and 
// compare the values of sequence and tree/
void inOrder(Node *root, vector<int> seq, int &index) {
    if (root == nullptr) return;

    // We traverse left subtree first in Inorder
    inOrder(root->left, seq, index);

    // If current node matches with se[index] then move
    // forward in sub-sequence
    if (index < seq.size() && root->data == seq[index])
        index++;

    // We traverse left subtree in the end in Inorder
    inOrder(root->right, seq, index);
}

bool seqExist(Node *root, vector<int> seq) {
    
    // Initialize index in seq[]
    int index = 0;

    // Do an inorder traversal and find if all
    // elements of seq[] were present
    inOrder(root, seq, index);

    // index would become n if all elements of
    // seq[] were present
    return (index == seq.size());
}


int main() {
    
    // Structure of BST
    //         8
    //       /   \
    //     3      10
    //    / \       \
    //   1   6      14
    //      / \    /
    //     4   7  13
    Node* root = new Node(8);
    root->left = new Node(3);
    root->right = new Node(10);
    root->left->left = new Node(1);
    root->left->right = new Node(6);
    root->left->right->left = new Node(4);
    root->left->right->right = new Node(7);
    root->right->right = new Node(14);
    root->right->right->left = new Node(13);

    vector<int> seq = {4, 6, 8, 14};

    if (seqExist(root, seq)) {
        cout << "True";
    }
    else {
        cout << "False";
    }
    return 0;
}
Java 
// Java program to find if given array exists as a
// subsequence in BST

import java.util.ArrayList;

class Node {
    int data;
    Node left, right;

    Node(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {
    
    // Function to traverse the tree in in-order traversal and 
    // compare the values of sequence and tree
    static void inOrder(Node root, ArrayList<Integer> seq,
                        int[] index) {
        if (root == null)
            return;

        // We traverse left subtree first in Inorder
        inOrder(root.left, seq, index);

        // If current node matches with seq[index] then move
        // forward in sub-sequence
        if (index[0] < seq.size() && root.data == seq.get(index[0]))
            index[0]++;

        // We traverse right subtree in the end in Inorder
        inOrder(root.right, seq, index);
    }
  
    static boolean seqExist(Node root, ArrayList<Integer> seq) {
        
        // Initialize index in seq[]
        int[] index = { 0 };

        // Do an inorder traversal and find if all
        // elements of seq[] were present
        inOrder(root, seq, index);

        // index would become seq.size() if all elements of
        // seq[] were present
        return (index[0] == seq.size());
    }

    public static void main(String[] args) {
        
        // Structure of BST
        //         8
        //       /   \
        //     3      10
        //    / \       \
        //   1   6      14
        //      / \    /
        //     4   7  13
        Node root = new Node(8);
        root.left = new Node(3);
        root.right = new Node(10);
        root.left.left = new Node(1);
        root.left.right = new Node(6);
        root.left.right.left = new Node(4);
        root.left.right.right = new Node(7);
        root.right.right = new Node(14);
        root.right.right.left = new Node(13);

        ArrayList<Integer> seq = new ArrayList<>();
        seq.add(4);
        seq.add(6);
        seq.add(8);
        seq.add(14);

        if (seqExist(root, seq)) {
            System.out.println("True");
        } else {
            System.out.println("False");
        }
    }
}
Python 
# Python program to find if given array exists as a
# subsequence in BST

class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None

# Function to traverse the tree in in-order traversal and 
# compare the values of sequence and tree
def inOrder(root, seq, index):
    if root is None:
        return
    
    # We traverse left subtree first in Inorder
    inOrder(root.left, seq, index)
    
    # If current node matches with seq[index] then move
    # forward in sub-sequence
    if index[0] < len(seq) and root.data == seq[index[0]]:
        index[0] += 1
    
    # We traverse right subtree in the end in Inorder
    inOrder(root.right, seq, index)
    
def seqExist(root, seq):
    
    # Initialize index in seq[]
    index = [0]
    
    # Do an inorder traversal and find if all
    # elements of seq[] were present
    inOrder(root, seq, index)
    
    # index would become len(seq) if all elements of
    # seq[] were present
    return index[0] == len(seq)

if __name__ == "__main__":
    
    # Structure of BST
    #         8
    #       /   \
    #     3      10
    #    / \       \
    #   1   6      14
    #      / \    /
    #     4   7  13
    root = Node(8)
    root.left = Node(3)
    root.right = Node(10)
    root.left.left = Node(1)
    root.left.right = Node(6)
    root.left.right.left = Node(4)
    root.left.right.right = Node(7)
    root.right.right = Node(14)
    root.right.right.left = Node(13)
    
    seq = [4, 6, 8, 14]

    if seqExist(root, seq):
        print("True")
    else:
        print("False")
C# 
// C# program to find if given array exists as a
// subsequence in BST

using System;
using System.Collections.Generic;

class Node {
    public int data;
    public Node left, right;

    public Node(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {
    
    // Function to traverse the tree in in-order traversal and 
    // compare the values of sequence and tree
    static void inOrder(Node root, List<int> seq, ref int index) {
        if (root == null)
            return;
        
        // We traverse left subtree first in Inorder
        inOrder(root.left, seq, ref index);
        
        // If current node matches with seq[index] then move
        // forward in sub-sequence
        if (index < seq.Count && root.data == seq[index])
            index++;
        
        // We traverse right subtree in the end in Inorder
        inOrder(root.right, seq, ref index);
    }

    static bool seqExist(Node root, List<int> seq) {
        
        // Initialize index in seq[]
        int index = 0;

        // Do an inorder traversal and find if all
        // elements of seq[] were present
        inOrder(root, seq, ref index);

        // index would become seq.Count if all elements of
        // seq[] were present
        return index == seq.Count;
    }

    static void Main(string[] args) {
        
        // Structure of BST
        //         8
        //       /   \
        //     3      10
        //    / \       \
        //   1   6      14
        //      / \    /
        //     4   7  13
        Node root = new Node(8);
        root.left = new Node(3);
        root.right = new Node(10);
        root.left.left = new Node(1);
        root.left.right = new Node(6);
        root.left.right.left = new Node(4);
        root.left.right.right = new Node(7);
        root.right.right = new Node(14);
        root.right.right.left = new Node(13);

        List<int> seq = new List<int> { 4, 6, 8, 14 };

        if (seqExist(root, seq)) {
            Console.WriteLine("True");
        } else {
            Console.WriteLine("False");
        }
    }
}
JavaScript 
// JavaScript program to find if given array exists as a
// subsequence in BST

class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}

// Function to traverse the tree in in-order traversal and 
// compare the values of sequence and tree
function inOrder(root, seq, index) {
    if (root === null) return;

    // We traverse left subtree first in Inorder
    inOrder(root.left, seq, index);

    // If current node matches with seq[index] then move
    // forward in sub-sequence
    if (index[0] < seq.length && root.data === seq[index[0]]) {
        index[0]++;
    }

    // We traverse right subtree in the end in Inorder
    inOrder(root.right, seq, index);
}

function seqExist(root, seq) {
    
    // Initialize index in seq[]
    let index = [0];

    // Do an inorder traversal and find if all
    // elements of seq[] were present
    inOrder(root, seq, index);

    // index would become seq.length if all elements of
    // seq[] were present
    return index[0] === seq.length;
}

// Structure of BST
//         8
//       /   \
//     3      10
//    / \       \
//   1   6      14
//      / \    /
//     4   7  13
let root = new Node(8);
root.left = new Node(3);
root.right = new Node(10);
root.left.left = new Node(1);
root.left.right = new Node(6);
root.left.right.left = new Node(4);
root.left.right.right = new Node(7);
root.right.right = new Node(14);
root.right.right.left = new Node(13);

let seq = [4, 6, 8, 14];

if (seqExist(root, seq)) {
    console.log("True");
} else {
    console.log("False");
}

Output
True

[Alternate Approach] Using Morris Traversal Algorithm - O(n) Time and O(1) Space

The idea is to use Morris Traversal Algorithm to perform in-order traversal. At each node, if the value of node is equal to value at current index. Then increment the index. Then, if the index is equal to size of array, then return true. Else return false.

Below is the implementation of the above approach:

C++ 
// C++ program to find if given array exists as a
// subsequence in BST
#include<bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node *left, *right;
    Node (int x) {
        data = x;
        left = nullptr;
        right = nullptr;
    }
};

// Function to perform Morris Traversal and check
// if array is subsequence in BST
bool seqExist(Node *root, vector<int> seq) {
    
    Node* curr = root;
    int index = 0;
    
    while (curr != nullptr) {
        
        // if left tree does not exists,
        // then compare the curr node with 
        // current value and set curr = curr->right
        if (curr->left == nullptr) {
            
            if (index < seq.size() && seq[index] == curr->data)
                index++;
            curr = curr->right;    
        }
        else {
            Node* pred = curr->left;
            
            // find the inorder predecessor 
            while (pred->right != nullptr && pred->right != curr) {
                pred = pred->right;
            }
            
            // create a linkage between pred and
            // curr and move to left node.
            if (pred->right == nullptr) {
                pred->right = curr;
                curr = curr->left;
            }
            
            // if pred->right = curr, it means 
            // we have processed the left subtree,
            // and we can compare curr node
            else {
                if (index < seq.size() && 
                    seq[index] == curr->data)
                    index++;
                curr = curr->right;
            }
        }
    }
    
    return index == seq.size();
}

int main() {
    
    // Structure of BST
    //         8
    //       /   \
    //     3      10
    //    / \       \
    //   1   6      14
    //      / \    /
    //     4   7  13
    Node* root = new Node(8);
    root->left = new Node(3);
    root->right = new Node(10);
    root->left->left = new Node(1);
    root->left->right = new Node(6);
    root->left->right->left = new Node(4);
    root->left->right->right = new Node(7);
    root->right->right = new Node(14);
    root->right->right->left = new Node(13);

    vector<int> seq = {4, 6, 8, 14};

    if (seqExist(root, seq)) {
        cout << "True";
    }
    else {
        cout << "False";
    }
    return 0;
}
Java 
// Java program to find if given array exists as a
// subsequence in BST
import java.util.ArrayList;

class Node {
    int data;
    Node left, right;

    Node(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {
    
    // Function to perform Morris Traversal and check
    // if array is subsequence in BST
    static boolean seqExist(Node root, ArrayList<Integer> seq) {
        Node curr = root;
        int index = 0;

        while (curr != null) {
            
            // if left tree does not exist,
            // then compare the curr node with
            // current value and set curr = curr.right
            if (curr.left == null) {
                if (index < seq.size() && 
                    seq.get(index) == curr.data)
                    index++;
                curr = curr.right;
            } else {
                Node pred = curr.left;

                // find the inorder predecessor
                while (pred.right != null && pred.right != curr) {
                    pred = pred.right;
                }

                // create a linkage between pred and
                // curr and move to left node.
                if (pred.right == null) {
                    pred.right = curr;
                    curr = curr.left;
                }

                // if pred.right = curr, it means
                // we have processed the left subtree,
                // and we can compare curr node
                else {
                    if (index < seq.size() &&
                        seq.get(index) == curr.data)
                        index++;
                    curr = curr.right;
                }
            }
        }
        
        return index == seq.size();
    }

    public static void main(String[] args) {
        
        // Structure of BST
        //         8
        //       /   \
        //     3      10
        //    / \       \
        //   1   6      14
        //      / \    /
        //     4   7  13
        Node root = new Node(8);
        root.left = new Node(3);
        root.right = new Node(10);
        root.left.left = new Node(1);
        root.left.right = new Node(6);
        root.left.right.left = new Node(4);
        root.left.right.right = new Node(7);
        root.right.right = new Node(14);
        root.right.right.left = new Node(13);

        ArrayList<Integer> seq = new ArrayList<>();
        seq.add(4);
        seq.add(6);
        seq.add(8);
        seq.add(14);

        if (seqExist(root, seq)) {
            System.out.println("True");
        } else {
            System.out.println("False");
        }
    }
}
Python 
# Python program to find if given array exists as a
# subsequence in BST

class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None

# Function to perform Morris Traversal and check
# if array is subsequence in BST
def seqExist(root, seq):
    curr = root
    index = 0

    while curr is not None:
        
        # if left tree does not exist,
        # then compare the curr node with
        # current value and set curr = curr.right
        if curr.left is None:
            if index < len(seq) and seq[index] == curr.data:
                index += 1
            curr = curr.right
        else:
            pred = curr.left

            # find the inorder predecessor
            while pred.right is not None and pred.right != curr:
                pred = pred.right

            # create a linkage between pred and
            # curr and move to left node.
            if pred.right is None:
                pred.right = curr
                curr = curr.left
            else:
                
                # if pred.right = curr, it means
                # we have processed the left subtree,
                # and we can compare curr node
                if index < len(seq) and seq[index] == curr.data:
                    index += 1
                curr = curr.right

    return index == len(seq)

if __name__ == "__main__":
    
    # Structure of BST
    #         8
    #       /   \
    #     3      10
    #    / \       \
    #   1   6      14
    #      / \    /
    #     4   7  13
    root = Node(8)
    root.left = Node(3)
    root.right = Node(10)
    root.left.left = Node(1)
    root.left.right = Node(6)
    root.left.right.left = Node(4)
    root.left.right.right = Node(7)
    root.right.right = Node(14)
    root.right.right.left = Node(13)

    seq = [4, 6, 8, 14]

    if seqExist(root, seq):
        print("True")
    else:
        print("False")
C# 
// C# program to find if given array exists as a
// subsequence in BST
using System;
using System.Collections.Generic;

class Node {
    public int data;
    public Node left, right;

    public Node(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {
    
    // Function to perform Morris Traversal and check
    // if array is subsequence in BST
    static bool seqExist(Node root, List<int> seq) {
        Node curr = root;
        int index = 0;

        while (curr != null) {
            
            // if left tree does not exist,
            // then compare the curr node with
            // current value and set curr = curr.right
            if (curr.left == null) {
                if (index < seq.Count && 
                    seq[index] == curr.data)
                    index++;
                curr = curr.right;
            } else {
                Node pred = curr.left;

                // find the inorder predecessor
                while (pred.right != null && 
                       pred.right != curr) {
                    pred = pred.right;
                }

                // create a linkage between pred and
                // curr and move to left node.
                if (pred.right == null) {
                    pred.right = curr;
                    curr = curr.left;
                } else {
                    
                    // if pred.right = curr, it means
                    // we have processed the left subtree,
                    // and we can compare curr node
                    if (index < seq.Count 
                        && seq[index] == curr.data)
                        index++;
                    curr = curr.right;
                }
            }
        }

        return index == seq.Count;
    }

    static void Main() {
        
        // Structure of BST
        //         8
        //       /   \
        //     3      10
        //    / \       \
        //   1   6      14
        //      / \    /
        //     4   7  13
        Node root = new Node(8);
        root.left = new Node(3);
        root.right = new Node(10);
        root.left.left = new Node(1);
        root.left.right = new Node(6);
        root.left.right.left = new Node(4);
        root.left.right.right = new Node(7);
        root.right.right = new Node(14);
        root.right.right.left = new Node(13);

        List<int> seq = new List<int> { 4, 6, 8, 14 };

        if (seqExist(root, seq)) {
            Console.WriteLine("True");
        } else {
            Console.WriteLine("False");
        }
    }
}
JavaScript 
// JavaScript program to find if given array exists as a
// subsequence in BST

class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}

// Function to perform Morris Traversal and check
// if array is subsequence in BST
function seqExist(root, seq) {
    let curr = root;
    let index = 0;

    while (curr !== null) {
        
        // if left tree does not exist,
        // then compare the curr node with
        // current value and set curr = curr.right
        if (curr.left === null) {
            if (index < seq.length && seq[index] === curr.data)
                index++;
            curr = curr.right;
        } else {
            let pred = curr.left;

            // find the inorder predecessor
            while (pred.right !== null && pred.right !== curr) {
                pred = pred.right;
            }

            // create a linkage between pred and
            // curr and move to left node.
            if (pred.right === null) {
                pred.right = curr;
                curr = curr.left;
            } else {
                
                // if pred.right = curr, it means
                // we have processed the left subtree,
                // and we can compare curr node
                if (index < seq.length && seq[index] === curr.data)
                    index++;
                curr = curr.right;
            }
        }
    }

    return index === seq.length;
}

// Structure of BST
//         8
//       /   \
//     3      10
//    / \       \
//   1   6      14
//      / \    /
//     4   7  13
let root = new Node(8);
root.left = new Node(3);
root.right = new Node(10);
root.left.left = new Node(1);
root.left.right = new Node(6);
root.left.right.left = new Node(4);
root.left.right.right = new Node(7);
root.right.right = new Node(14);
root.right.right.left = new Node(13);

let seq = [4, 6, 8, 14];

if (seqExist(root, seq)) {
    console.log("True");
} else {
    console.log("False");
}

Output
True

K

kartik
Improve
Article Tags :
Lightbox