Top View Of Binary Tree

class Pair{

        int line;

        TreeNode node;

        Pair(int _line, TreeNode _node){

            this.line = _line;

            this.node = _node;

        }

}

public class Solution {

    public static List<Integer> getTopView(TreeNode root) {

        Queue<Pair> q = new LinkedList<>();

        Map<Integer, Integer> map = new TreeMap<>();

        List<Integer> list = new ArrayList<>();

        q.offer(new Pair(0, root));

        while(!q.isEmpty()){

            Pair pair = q.poll();

            int vl = pair.line; //vl-> vertical line

            TreeNode temp = pair.node;

            if(map.get(vl) == null){

                map.put(vl, temp.data);

            }

            if(temp.left != null){

                q.offer(new Pair(vl-1, temp.left));

            }

            if(temp.right != null){

                q.offer(new Pair(vl+1, temp.right));

            }

        }

        for(Map.Entry<Integer,Integer> entry : map.entrySet()){

            list.add(entry.getValue());

        }

        return list;

    }

}

class Pair{

    int hd;

    TreeNode node;

    public Pair(int hd,TreeNode node){

        this.hd = hd;

        this.node = node;

    }

}

public class Solution {

    public static List<Integer> getTopView(TreeNode root) {

        // Write your code here.

        Map<Integer,Integer> map = new TreeMap<>();

        List<Integer> ans = new ArrayList<>();

        if(root == null)

        return ans;

        Queue<Pair> q = new LinkedList<>();

        q.add(new Pair(0,root));

        while(!q.isEmpty()){

            Pair p = q.poll();

            TreeNode node = p.node;

            int hd = p.hd;

          map.putIfAbsent(hd, node.data);

          if(node.left != null)

          q.add(new Pair(hd-1,node.left));

          if(node.right!=null)

          q.add(new Pair(hd+1,node.right));

        }

        for(Map.Entry<Integer,Integer> entry: map.entrySet()){

            ans.add(entry.getValue());

        }

        return ans;

    }

}

stl is not working in my code like map and queues.

import java.util.*;

class TreeNodeWithHorizontalDistance {

    TreeNode node;

    int horizontalDistance;

    TreeNodeWithHorizontalDistance(TreeNode node, int horizontalDistance) {

        this.node = node;

        this.horizontalDistance = horizontalDistance;

    }

}

public class Solution {

    public static List<Integer> getTopView(TreeNode root) {

        if (root == null) return new ArrayList<>();

        List<Integer> topViewNodes = new ArrayList<>();

        Map<Integer, Integer> topViewMap = new TreeMap<>(); // Horizontal distance to node data mapping

        Queue<TreeNodeWithHorizontalDistance> nodeQueue = new LinkedList<>();

        nodeQueue.add(new TreeNodeWithHorizontalDistance(root, 0));

        while (!nodeQueue.isEmpty()) {

            TreeNodeWithHorizontalDistance currentNodeWithHD = nodeQueue.poll(); // Retrieve the node and horizontal distance

            int horizontalDistance = currentNodeWithHD.horizontalDistance;

            TreeNode currentNode = currentNodeWithHD.node;

            if (!topViewMap.containsKey(horizontalDistance)) {

                topViewMap.put(horizontalDistance, currentNode.data);

            }

            if (currentNode.left != null) {

                nodeQueue.add(new TreeNodeWithHorizontalDistance(currentNode.left, horizontalDistance - 1));

            }

            if (currentNode.right != null) {

                nodeQueue.add(new TreeNodeWithHorizontalDistance(currentNode.right, horizontalDistance + 1));

            }

        }

        for (Map.Entry<Integer, Integer> entry : topViewMap.entrySet()) {

            topViewNodes.add(entry.getValue());

        }

        return topViewNodes;

    }

}

#include<bits/stdc++.h>

vector<int> getTopView(TreeNode<int> *root)

{

    vector<int> ans;

    queue<pair<TreeNode<int> *,int>> q;

    q.push({root,0});

    map<int,int> mp;

    while(!q.empty()){

        TreeNode<int> * temp=q.front().first;

        int level=q.front().second;

        q.pop();

        if(mp.find(level)==mp.end()){

            mp[level]=temp->data;

        }

        if(temp->left){

            q.push({temp->left,level-1});

        }

        if(temp->right){

            q.push({temp->right,level+1});

        }

    }

    for(auto &it:mp){

        ans.push_back(it.second);

    }

    return ans;

}

#include <map>

#include <vector>

using namespace std;

void code(TreeNode<int> *root,int row,int col , map<int,pair<int,int>> &mp)

{

    if ( root == NULL)

    return ;

    if(mp.find(col)==mp.end())

    {

    mp[col]={row,root->data};

    }

    else{

    if (mp[col].first>row)

      mp[col] = {row, root->data};

    }

    code(root->left,row+1,col-1,mp);

    code(root->right,row+1,col+1,mp);

}

vector<int> getTopView(TreeNode<int> *root)

{

    map<int,pair<int,int>>mp;

    vector<int>ans;

    code(root,0,0,mp);

    for(auto  it : mp)

    {

        ans.push_back(it.second.second);

    }

    return ans ;

}

def getTopView(root):

    # Write your code here.

    bfs = []

    dicts = defaultdict(list)

    if(root is None):

        return root

    queue = deque([(root, 0)])

    while(queue):

        l = len(queue)

        for i in range(0, l):

            curr, nl = queue.popleft()

            dicts[nl].append(curr.val)

            if(curr.left):

                queue.append((curr.left, nl-1))

            if(curr.right):

                queue.append((curr.right, nl+1))

    # print(dicts)

    dicts1 = sorted(dicts.items(), key=lambda x: x[0])

    for key, value in dicts1:

        bfs.append(value[0])

    return bfs

my github : https://github.com/yashswag22

#include<bits/stdc++.h>

vector<int> getTopView(TreeNode<int> *root)

{

    vector<int>ans;

    if(root == NULL) return ans;

    map <int, map<int,vector<int>>> nodes;

    // to fulfill this "If two nodes have the same position, then the value of the node that is added first will be the value that is on the left side."

    // we will use level order traversal

    queue< pair< TreeNode<int>*, pair<int,int>>> q;

    q.push({root,{0,0}});

    while(!q.empty()){

        pair< TreeNode<int>*, pair<int,int>> temp = q.front();

        q.pop();

        TreeNode<int>* frontNode = temp.first;

        int hd = temp.second.first; // hd = horizontal distance

        int lvl = temp.second.second; // lvl = level of node 

        if(frontNode!= NULL){

            nodes[hd][lvl].push_back(frontNode->data);

        }

        if(frontNode->left)

        q.push({frontNode ->left,{hd-1,lvl+1}});

        if(frontNode->right)

        q.push({frontNode ->right,{hd+1,lvl+1}});

    }

    for(auto i : nodes){ // it give <int, map<>>

        for(auto j : i.second){ // it give <int, vector<>>

           for(auto k : j.second) { // it will iterate the vector

                ans.push_back(k);

                break;

           }

            break;

        }

    }

    return ans;

}

#include <bits/stdc++.h>
vector<int> getTopView(TreeNode<int> *root) {
    vector<int> ans;
    if (root == NULL) {
        return ans;
    }
    
    // Mapping of horizontal distance with node data
    map<int, int> topNode;
    // Queue for level order traversal, stores nodes with their horizontal distance
    queue<pair<TreeNode<int>*, int>> q;
    q.push(make_pair(root, 0)); // The root has a horizontal distance of 0
    
    while (!q.empty()) {
        pair<TreeNode<int>*, int> temp = q.front();
        q.pop();
        TreeNode<int>* frontNode = temp.first;
        int hd = temp.second;
        
        // If a value is not yet present for a horizontal distance, add it
        if (topNode.find(hd) == topNode.end()) {
            topNode[hd] = frontNode->data;
        }
        
        if (frontNode->left) {
            q.push(make_pair(frontNode->left, hd - 1));
        }
        
        if (frontNode->right) {
            q.push(make_pair(frontNode->right, hd + 1));
        }
    }
    
    for (auto i: topNode) {
        ans.push_back(i.second);
    }
    
    return ans;
}

/*********************************************

 Following is the TreeNode class structure

 class TreeNode {
     int data;
     TreeNode left;
     TreeNode right;

     TreeNode(int data) {
         this.data = data;
         this.left = null;
         this.right = null;
     }
 }

 *********************************************/

import java.util.*;


public class Solution {
    static class Pair{
        TreeNode node;
        int coord;

        public Pair(TreeNode node, int coord){
            this.node = node;
            this.coord = coord;
        }
    }
    public static List<Integer> getTopView(TreeNode root) {
        // Write your code here.
        int min = 1, max = 0;
        List<Integer> a = new ArrayList<>(), b = new ArrayList<>();
        Queue<Pair> queue = new LinkedList<>();
        queue.add(new Pair(root, 0));

        while(!queue.isEmpty()){
            Pair pair = queue.poll();
            int coord = pair.coord;
            TreeNode left = pair.node.left, right = pair.node.right;
            if (coord < min){
                a.add(pair.node.data);
                min = coord;
            }
            if (coord > max){
                b.add(pair.node.data);
                max = coord;
            }
            if (left != null)
                queue.add(new Pair(left, coord-1));
            if (right != null)
                queue.add(new Pair(right, coord+1));
        }
        Collections.reverse(a);
        a.addAll(b);
        return a;
    }
}