We use cookies to ensure you have the best browsing experience on our website. Please read our cookie policy for more information about how we use cookies.
Loading...
  1. Practice
  2. Data Structures
  3. Trees
  4. Tree : Top View
  5. Discussions

Tree : Top View

  • amazinghacker + 3 comments

    If the other was true, it would be much tougher to code. Isn't that?

    • codefornand + 2 comments

      no only printing of leaves will be added

      • aravindprasad + 2 comments

        This problem expects solution as @AlexMistery explained.

        But the actual Top view seems to be different though.

        • johnsonjo4531 + 3 comments

          When I visited this question there was no definition for top view given so I had to search for a definition. I came to the geeks for geeks link that others have referenced and made my algorithm according to geeks for geeks' definition which is the same as @Faland's and it was still accepted no problem. There was also only two test cases when I submitted. I honestly think you can submit either way and be fine unless my submission is not implementing geek for geek's definition of top view correctly.

          • ekjot28 + 1 comment

            If we follow algo given by geeksforgeeks then it doesnt give right answer. Geeks for geeks alfo print according @Faland

            • yogeshkaushik008 + 0 comments

              It Does, I have submitted the logic of vertical order traversal.

          • parmarabhishek_1 + 4 comments

            This is the actual code for top view of a tree :

            typedef pair<int,int> v_h; 
map <int,v_h> m; // map
map <int, v_h> :: iterator itr; //itterator

void store_view(node * root,int i,int h)
    {
    if(root==NULL)
        return;
    itr=m.find(i);
    if(itr==m.end())
        m[i]=make_pair(h,root->data);
    else
    {
        if(itr->second.first > h)
            m[i]=make_pair(h,root->data);
    }
    if(root->left!=NULL)
        store_view(root->left,i-1,h+1);
    if(root->right!=NULL)
        store_view(root->right,i+1,h+1);
     
}

void print_map()
    {
    for(itr = m.begin(); itr != m.end(); ++itr)
        cout<<itr->second.second<<" ";
}

void topView(node * root)
{
   store_view(root,0,0);
   print_map();
    return;
}

            but the problem demands the top view according to the root node only :

            void for_left(node * root)
{
    if(root->left!=NULL)
        for_left(root->left);
    cout<<root->data<<" ";
}


void for_right(node * root)
{
    cout<<root->data<<" ";
    if(root->right!=NULL)
        for_right(root->right);
}

void topView(node * root)
{
    if(root->left!=NULL)
        for_left(root->left);
    cout<<root->data<<" ";
    if(root->right!=NULL)
        for_right(root->right);
    
}
            • BansheeGhoul + 0 comments

              You are spot onn in identifying two different implementations .. looks like this question demands just the outer values of the tree. Thanks once again.

            • digikar99 + 1 comment

              Isn't it the second solution that is expected - the first solution passes in July '18! Seems like they changed the meaning; and if so, I don't think this is a "easy" problem - a "medium" one.

              • xdavidliu + 0 comments

                it seems the second part of parmarabhishek_1's post was what the problem originally expected, and that was incorrect. They changed it to correctly require the solution in the first part, as you pointed out. They should have also used a better example to illustrate this subtle point.

            • shashikumargund2 + 0 comments

              it's not working for all the test cases

            • lishantsahu + 0 comments

              I think you are printing root->data 3 times in the topView() function.

          • bennattj + 1 comment

            Yep, the definition of "Top-View" was never presented in this problem. Besides the grammatical errors in the sentence "explaining" top-view, it almost literally says: when you view from the top, you'll see the top view.

            The definition I found, that made sense was from the geeks for geeks link. So I solved it that way. I failed everything past the first test. So I looked at the input/output for the second test case.

            For anyone interested, it's clear that the input is given as a binary search tree. So I constructed the graph from the input, ran my program, got the correct result but with extras (to the right for the second test case).

            Then figured I was getting extras because a subtree was "poking" out and they didn't want that. So deleted all of my (more complicated) code for what amounted to a trivial problem.

            • archidsouza18 + 2 comments

              can anyone explain how to represent the tree for this input, 47 2 40 20 38 30 14 28 10 16 19 44 39 27 7 9 31 12 43 21 5 41 34 49 13 33 3 4 25 22 29 15 32 35 6 24 23 26 1 11 42 36 37 17 18 8 45 48 50 46 ? what is root of this tree ?

              • niranjan_wad + 5 comments

                same question.. Expected output: 1 2 47 49 50 My output: 47 2 1 49 50

                • archidsouza18 + 1 comment

                  @niranjan_wad how did you manage to find the output? Since, it does not tell what is your output. do you know what is root of above question ?

                  • BarryB + 0 comments

                    If you hover of the submission results that failed, there will be a popup that appears, where you can download both the input and expected output for that test case.

                • bennattj + 0 comments

                  You appear to have the correct output, but in the wrong order. The solution wants it "left-to-right" (which just so happens to be least-to-greatest since these are apparently binary search trees).

                • 15A31A0566 + 0 comments

                  Try using TreeMap so the keys will be in sorted order

                • Sumitkush677 + 0 comments

                  bro..first print traverse, then print that node. then u get correct order

                • Sumitkush677 + 0 comments

                  first traverse,the print that node. u get correct order

              • bennattj + 0 comments

                The root is 47 (the first node given), the rest are input as a binary search tree, which means 2 is the left child of 47. 40 is the right child of 2 (because it's less than 47 but greater than 2), 20 is the left child of 40 (less than 47, greater than 2, and less than 40)...etc.

        • pkenil96 + 0 comments

          Exactly!! Even i got that the other way.. I coded the solution considering the horizontal distances of the nodes and all my test cases(except the sample case) failed! The actual top view certainly is different than what they expects!

      • prnvkrjha + 0 comments

        No! an entire branch could appear in the top view. not just the leaves.

    • euler + 0 comments

      Not much tough though. I wrote the code with that assumption only. Problem writers need to do a better job here.

    • sagar_yadav + 1 comment

      no , by the way it become more easy that way u just have to traverse left and store all in vector(push tis data from front) then just traverse right and store it in same vector(push this data from back) then simply print the data or u can use recurssion :)

      • tanmax + 1 comment

        how can you push sometrhing from front in a vector

        • boolean_bro + 0 comments

          vec.push_front(data);