using System;

using System.Collections.Generic;

public class Program

{

    public static void Main()

    {

        Dictionary<int,int> dict=new Dictionary<int,int>();

        Node a=new Node(1);

        Node b=new Node(2);

        Node c=new Node(3);

        Node d=new Node(4);

        Node e=new Node(5);

        Node f=new Node(6);

        Node g=new Node(7);     

        b.left=d;

        a.left=b;

        b.right=e;

        c.right=g;

        c.left=f;

        a.right=c;      

        //DFT(a);

        //VerticalSum(a,ref dict,0);

        foreach(var key in dict.Keys){

            //Console.WriteLine(dict[key].ToString());

        }

        Dictionary<int,List<NodeLevel>> dictLevelLists=new Dictionary<int,List<NodeLevel>>();

        LevelsListsStack(a,ref dictLevelLists,0);

        foreach(var key in dictLevelLists.Keys){            

            Console.WriteLine("Level - "+key.ToString());

            foreach(var node in dictLevelLists[key]){

                Console.Write(node.node.data.ToString()+"->");

            }

            Console.WriteLine();

        }

    }

    public static void DFT(Node root){

        if(root==null)

            return;

​

        Stack<Node> s=new Stack<Node>();

        s.Push(root);

​

        while(s.Count>0){

            Node x=s.Pop();

            if(x.right!=null) s.Push(x.right);

            if(x.left!=null) s.Push(x.left);

            Console.WriteLine(x.data.ToString());

        }

    }

    public static void VerticalSum(Node root,ref Dictionary<int,int> dict,int level)

    {

        if(root==null)

            return;

        VerticalSum(root.left,ref dict,level-1);

        if(!dict.ContainsKey(level))

        {

            dict.Add(level,root.data);

        }

        else

        {

            dict[level]+=root.data;

        }

        VerticalSum(root.right,ref dict,level+1);

    }

    public static void LevelLists(Node root,Dictionary<int,List<Node>> levels,int level){

        if(root==null)

            return;

        if(levels.ContainsKey(level))

            levels[level].Add(root);

        else

            levels.Add(level,new List<Node>{root});

        LevelLists(root.left,levels,level+1);

        LevelLists(root.right,levels,level+1);

    }

    public static void LevelsListsStack(Node root, ref Dictionary<int,List<NodeLevel>> levels,int level){

        if(root==null)

            return;

        Stack<NodeLevel> s=new Stack<NodeLevel>();

        s.Push(new NodeLevel(root,0));

        while(s.Count>0){

            var n=s.Pop();

            if(levels.ContainsKey(n.level))

                levels[n.level].Add(n);

            else

                levels.Add(n.level,new List<NodeLevel>{n});

            if(n.node.left!=null){

                s.Push(new NodeLevel(n.node.left,n.level+1));

            }

            if(n.node.right!=null){

                s.Push(new NodeLevel(n.node.right,n.level+1));

            }

        }

            //if()

    }

}

​

public class NodeLevel{

    public Node node;

    public int level;

    public NodeLevel(Node n,int level){

        this.node=n;

        this.level=level;

    }

}

​

public class Node{

    public int data;

    public Node left;

    public Node right;

    public Node(int data){

        this.data=data;

    }

}