https://leetcode.com/problems/binary-tree-vertical-order-traversal

binary-tree-vertical-order-traversal.go

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */

type OrderNode struct {
    node *TreeNode
    order int
}

func verticalOrder(root *TreeNode) [][]int {
    if root == nil {
        return [][]int{}
    } 
    
    order := make(map[int][]int)
    from, to := (1 << 31) - 1, -1 << 31
    
    queue := []*OrderNode{{
        node: root,
        order: 0,
    }}
    
    for len(queue) > 0 {
        item := queue[0]
        queue = queue[1:]
        order[item.order] = append(order[item.order], item.node.Val)
        
        if item.node.Left != nil {
            queue = append(queue, &OrderNode{
                node: item.node.Left,
                order: item.order - 1,
            })
        }
        
        if item.node.Right != nil {
            queue = append(queue, &OrderNode{
                node: item.node.Right,
                order: item.order + 1,
            })
        }
        
        from, to = min(from, item.order), max(to, item.order)
    }
    
    result := [][]int{}
    
    for ; from <= to; from++ {
        row := order[from]
        result = append(result, row)
    }
    
    return result
}

func min(a, b int) int {
    if a < b {
        return a
    }
    
    return b
}

func max(a, b int) int {
    if a < b {
        return b
    }
    
    return a
}