Find the kth node in vertical order traversal of a Binary Tree

Last Updated : 17 Oct, 2024

Given a binary tree and an integer k, the task is to return the kth node in the vertical order traversal of a binary tree. If no such node exists then return -1.
The vertical order traversal of a binary tree means to print it vertically.

Examples:

Input: k = 3

Output: 1
Explanation: The below image shows the horizontal distances used to print vertical traversal starting from the leftmost level to the rightmost level. The complete vertical order will be 4 2 1 5 6 3 8 7 9.

Approach:

The idea is to perform vertical order traversal of the binary tree, which involves visiting nodes column by column from left to right. Check if the current node is the kth node then return its value, if number of nodes in the tree is less than k then return -1.

Below is the implementation of the above approach:

C++

// C++ code of Find the kth node in vertical
// order traversal
#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node* left;
    Node* right;

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

// The verticalOrder function to print vertical order 
// of a binary tree with given root
vector<int> verticalOrder(Node* root) {
  
    // Base case
    if (!root)
        return {};

    // Create a map and store vertical order in
    // map using function getVerticalOrder()
    map<int, vector<int>> mp;
    int hd = 0;

    // Create queue to do level order traversal.
    // Every item of queue contains node and
    // horizontal distance.
    queue<pair<Node*, int>> q;
    q.push(make_pair(root, hd));

    while (!q.empty()) {
      
        // pop from queue front
        pair<Node*, int> curr = q.front();
        q.pop();
        hd = curr.second;
        Node* node = curr.first;

        // insert this node's data in vector of map
        mp[hd].push_back(node->data);

        if (node->left != nullptr)
            q.push(make_pair(node->left, hd - 1));
        if (node->right != nullptr)
            q.push(make_pair(node->right, hd + 1));
    }
	
  	vector<int> result;
  
    // Traverse the map and print nodes at
    // every horizontal distance (hd)
    for (auto& entry : mp) {
        for (int key : entry.second)
          	result.push_back(key);
    }
  	return result;
}

int main() {
  
    //    Tree structure:
    //            1
    //          /   \
    //         2     3
    //        / \   / \
    //       4   5 6   7
    //              \   \
    //               8   9

    // Create binary tree
    Node* root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->left->left = new Node(4);
    root->left->right = new Node(5);
    root->right->left = new Node(6);
    root->right->right = new Node(7);
    root->right->left->right = new Node(8);
    root->right->right->right = new Node(9);
  	int k = 5;

    vector<int> result = verticalOrder(root);

    if(k < result.size()) {
     	cout << result[k-1];
    }
  	else{
      	cout << -1;
    }

    return 0;
}

Java

// Java code of Find the kth node in vertical
// order traversal

import java.util.*;

class Node {
    int data;
    Node left, right;

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

class GfG {
	
  	// The verticalOrder function to print vertical order 
	// of a binary tree with given root
 	static List<Integer> verticalOrder(Node root) {
      
        // Base case
        if (root == null)
            return new ArrayList<>();
        
        // Create a map and store vertical order in
        // map using function getVerticalOrder()
        Map<Integer, List<Integer>> mp = new TreeMap<>();
        int hd = 0;
      
        // Create queue to do level order traversal.
        // Every item of queue contains node and
        // horizontal distance.
        Queue<Pair> q = new LinkedList<>();
        q.add(new Pair(root, hd));

        while (!q.isEmpty()) {
          
            // pop from queue front
            Pair curr = q.poll();
            hd = curr.hd;
            Node node = curr.node;

            // insert this node's data in vector of map
            if (!mp.containsKey(hd)) {
                mp.put(hd, new ArrayList<>());
            }
            mp.get(hd).add(node.data);

            if (node.left != null)
                q.add(new Pair(node.left, hd - 1));
            if (node.right != null)
                q.add(new Pair(node.right, hd + 1));
        }
        
        List<Integer> result = new ArrayList<>();
      
        // Traverse the map and print nodes at
        // every horizontal distance (hd)
        for (Map.Entry<Integer, 
             List<Integer>> entry : mp.entrySet()) {
            result.addAll(entry.getValue());
        }
        return result;
    }

    static class Pair {
        Node node;
        int hd;
        Pair(Node node, int hd) {
            this.node = node;
            this.hd = hd;
        }
    }

    public static void main(String[] args) {
      
        //    Tree structure:
        //            1
        //          /   \
        //         2     3
        //        / \   / \
        //       4   5 6   7
        //              \   \
        //               8   9

        // Create binary tree
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
        root.right.left = new Node(6);
        root.right.right = new Node(7);
        root.right.left.right = new Node(8);
        root.right.right.right = new Node(9);
        int k = 5;

        List<Integer> result = verticalOrder(root);

        if (k < result.size()) {
            System.out.println(result.get(k - 1));
        }
      	 else{
            System.out.println(-1);
        }
    }
}

Python

# Python code of Find the kth node in vertical
# order traversal

from collections import deque, defaultdict

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

# The verticalOrder function to print vertical order
# of a binary tree with given root
def verticalOrder(root):
    
    # Base case
    if not root:
        return []
    
    # Create a map and store vertical order in
    # map using function getVerticalOrder()
    m = defaultdict(list)
    hd = 0

    # Create queue to do level order traversal.
    # Every item of queue contains node and
    # horizontal distance.
    q = deque([(root, hd)])

    while q:
      
        # pop from queue front
        curr = q.popleft()
        node = curr[0]
        hd = curr[1]

        # insert this node's data in 
        # vector of map
        m[hd].append(node.data)

        if node.left is not None:
            q.append((node.left, hd - 1))
        if node.right is not None:
            q.append((node.right, hd + 1))
    
    result = []
    
    # Traverse the map and print nodes at
    # every horizontal distance (hd)
    for key in sorted(m):
        result.extend(m[key])

    return result

if __name__ == '__main__':
  
    #    Tree structure:
    #            1
    #          /   \
    #         2     3
    #        / \   / \
    #       4   5 6   7
    #              \   \
    #               8   9

    # Create binary tree
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.left.left = Node(4)
    root.left.right = Node(5)
    root.right.left = Node(6)
    root.right.right = Node(7)
    root.right.left.right = Node(8)
    root.right.right.right = Node(9)
    
    k = 5

    result = verticalOrder(root)

    if k < len(result):
        print(result[k-1])
    else: 
        print(-1)

// C# code of Find the kth node in
// vertical order traversal

using System;
using System.Collections.Generic;

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

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

class GfG {
  
  	// The verticalOrder function to print vertical order 
	// of a binary tree with given root
     static List<int> verticalOrder(Node root) {
      
        // Base case
        if (root == null)
            return new List<int>();

        // Create a map and store vertical order in
        // map using function getVerticalOrder()
        SortedDictionary<int, List<int>> map = 
          new SortedDictionary<int, List<int>>();
        int hd = 0;

        // Create queue to do level order traversal.
        // Every item of queue contains node and
        // horizontal distance.
        Queue<(Node, int)> q = new Queue<(Node, int)>();
        q.Enqueue((root, hd));

        while (q.Count > 0) {
          
            // pop from queue front
            var curr = q.Dequeue();
            hd = curr.Item2;
            Node node = curr.Item1;

            // insert this node's data in 
          	// vector of map
            if (!map.ContainsKey(hd)) {
                map[hd] = new List<int>();
            }
            map[hd].Add(node.data);

            if (node.left != null)
                q.Enqueue((node.left, hd - 1));
            if (node.right != null)
                q.Enqueue((node.right, hd + 1));
        }
        
        List<int> result = new List<int>();
       
        // Traverse the map and print nodes at
        // every horizontal distance (hd)
        foreach (var entry in map) {
            result.AddRange(entry.Value);
        }
        return result;
    }

     static void Main() {
      
        //    Tree structure:
        //            1
        //          /   \
        //         2     3
        //        / \   / \
        //       4   5 6   7
        //              \   \
        //               8   9

        // Create binary tree
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
        root.right.left = new Node(6);
        root.right.right = new Node(7);
        root.right.left.right = new Node(8);
        root.right.right.right = new Node(9);
        int k = 5;

        List<int> result = verticalOrder(root);

        if (k < result.Count) {
            Console.WriteLine(result[k - 1]);
        } 
       	else {
            Console.WriteLine(-1);
        } 
    }
}

JavaScript

// Javascript code of Find the kth node in
// vertical order traversal
class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}

// The verticalOrder function to print vertical order 
// of a binary tree with given root
function verticalOrder(root) {

    // Base case
    if (!root) return [];

    // Create a map and store vertical order in
    // map using function getVerticalOrder()
    let m = new Map();
    let hd = 0;

    // Create queue to do level order traversal.
    // Every item of queue contains node and
    // horizontal distance.
    let q = [];
    let index = 0;
    q.push({ node: root, hd: hd });

    while (index < q.length) {
    
        // pop from queue front
        let curr = q[index++];
        let node = curr.node;
        hd = curr.hd;

        // insert this node's data in 
        // vector of map
        if (!m.has(hd)) {
            m.set(hd, []);
        }
        m.get(hd).push(node.data);

        if (node.left !== null) {
            q.push({ node: node.left, hd: hd - 1 });
        }
        if (node.right !== null) {
            q.push({ node: node.right, hd: hd + 1 });
        }
    }

    let result = [];
    
    // Traverse the map and print nodes at
    // every horizontal distance (hd)
    [...m.keys()].sort((a, b) => a - b).forEach(key => {
        result.push(...m.get(key));
    });
    
    return result;
}

//    Tree structure:
//            1
//          /   \
//         2     3
//        / \   / \
//       4   5 6   7
//              \   \
//               8   9
const root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.right.left = new Node(6);
root.right.right = new Node(7);
root.right.left.right = new Node(8);
root.right.right.right = new Node(9);

const k = 5;

const result = verticalOrder(root);

if (k <= result.length) {
    console.log(result[k - 1]);
} else {
    console.log("-1");
}