Print a Binary Tree in Vertical Order

Given a binary tree, print it vertically. The following example illustrates vertical order traversal.

           1
        /    
       2      3
      /     / 
     4   5  6   7
                
              8   9 
               
			  
The output of print this tree vertically will be:
4
2
1 5 6
3 8
7
9 

We strongly recommend to minimize the browser and try this yourself first.

The idea is to traverse the tree once and get the minimum and maximum horizontal distance with respect to root. For the tree shown above, minimum distance is -2 (for node with value 4) and maximum distance is 3 (For node with value 9).
Once we have maximum and minimum distances from root, we iterate for each vertical line at distance minimum to maximum from root, and for each vertical line traverse the tree and print the nodes which lie on that vertical line.

Algorithm:

// min --> Minimum horizontal distance from root
// max --> Maximum horizontal distance from root
// hd  --> Horizontal distance of current node from root 
findMinMax(tree, min, max, hd)
     if tree is NULL then return;
 
     if hd is less than min then
           min = hd;
     else if hd is greater than max then
          *max = hd;
 
     findMinMax(tree->left, min, max, hd-1);
     findMinMax(tree->right, min, max, hd+1);

 
printVerticalLine(tree, line_no, hd)
     if tree is NULL then return;
 
     if hd is equal to line_no, then
           print(tree->data);
     printVerticalLine(tree->left, line_no, hd-1);
     printVerticalLine(tree->right, line_no, hd+1); 

//Print a Binary Tree in Vertical Order 
static int min;
static int max;
static HashMap<Integer,ArrayList> map;

public static void generate(TreeNode root, Integer dis){
    if(root == null) return;
    else{
        if(map.containsKey(dis)) map.get(dis).add(root.val);
        else{
            ArrayList<Integer> tmp = new ArrayList<Integer> ();
            tmp.add(root.val);
            map.put(dis, tmp);
        }
    }
    generate(root.left, dis - 1);
    generate(root.right, dis + 1);
}

public static ArrayList<Integer>[] verticalOrderTraveralBT(TreeNode root){
    min = 0; max = 0;
    int len = max - min + 1;
    map = new HashMap<Integer,ArrayList>();
    generate(root, 0);
    return map.values();
}


public static void main(String[] args) {    
    TreeNode root = new TreeNode(1);
    root.left = new TreeNode(2);
    root.right = new TreeNode(3);
    root.left.left = new TreeNode(4);
    root.left.right = new TreeNode(5);
    root.right.left = new TreeNode(6);
    root.right.right = new TreeNode(7);
    root.right.left.right = new TreeNode(8);
    root.right.right.right = new TreeNode(9);
    ArrayList[] result = verticalOrderTraveralBT(root);
    for(int i = 0; i < max - min + 1; i ++){
        System.out.println(result[i].toString());
    }
}

也可以使用HashMap 来做， 这样就不需要min / max 了。

//Print a Binary Tree in Vertical Order 
static int min;
static int max;
static ArrayList<Integer>[] output;
public static void findMinMax(TreeNode root, Integer dis){
    if(root == null) return;
    else{
        min = Math.min(dis, min);
        max = Math.max(dis, max);
    }
    findMinMax(root.left, dis - 1);
    findMinMax(root.right, dis + 1);
}

public static void generate(TreeNode root, Integer dis){
    if(root == null) return;
    else{
        output[dis - min].add(root.val);
    }
    generate(root.left, dis - 1);
    generate(root.right, dis + 1);
}

public static ArrayList<Integer>[] verticalOrderTraveralBT(TreeNode root){
    min = 0; max = 0;
    findMinMax(root, 0);
    int len = max - min + 1;
    output = new ArrayList[len];
    for(int i = 0; i < len; i ++){
        output[i] = new ArrayList<Integer>();
    }
    generate(root, 0);
    return output;
}


public static void main(String[] args) {    
    TreeNode root = new TreeNode(1);
    root.left = new TreeNode(2);
    root.right = new TreeNode(3);
    root.left.left = new TreeNode(4);
    root.left.right = new TreeNode(5);
    root.right.left = new TreeNode(6);
    root.right.right = new TreeNode(7);
    root.right.left.right = new TreeNode(8);
    root.right.right.right = new TreeNode(9);
    ArrayList[] result = verticalOrderTraveralBT(root);
    for(int i = 0; i < max - min + 1; i ++){
        System.out.println(result[i].toString());
    }
}