[Swift]LeetCode987. 二叉树的垂序遍历 | Vertical Order Traversal of a Binary Tree

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/10351710.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Given a binary tree, return the vertical order traversal of its nodes values.

For each node at position (X, Y), its left and right children respectively will be at positions (X-1, Y-1)and (X+1, Y-1).

Running a vertical line from X = -infinity to X = +infinity, whenever the vertical line touches some nodes, we report the values of the nodes in order from top to bottom (decreasing Y coordinates).

If two nodes have the same position, then the value of the node that is reported first is the value that is smaller.

Return an list of non-empty reports in order of X coordinate.  Every report will have a list of values of nodes.

Example 1:

Input: [3,9,20,null,null,15,7]
Output: [[9],[3,15],[20],[7]]
Explanation: 
Without loss of generality, we can assume the root node is at position (0, 0):
Then, the node with value 9 occurs at position (-1, -1);
The nodes with values 3 and 15 occur at positions (0, 0) and (0, -2);
The node with value 20 occurs at position (1, -1);
The node with value 7 occurs at position (2, -2).

Example 2:

Input: [1,2,3,4,5,6,7]
Output: [[4],[2],[1,5,6],[3],[7]]
Explanation: 
The node with value 5 and the node with value 6 have the same position according to the given scheme.
However, in the report "[1,5,6]", the node value of 5 comes first since 5 is smaller than 6.

Note:

1. The tree will have between 1 and 1000 nodes.
2. Each node's value will be between 0 and 1000.

---

给定二叉树，按垂序遍历返回其结点值。

对位于 (X, Y) 的每个结点而言，其左右子结点分别位于 (X-1, Y-1) 和 (X+1, Y-1)。

把一条垂线从 X = -infinity 移动到 X = +infinity ，每当该垂线与结点接触时，我们按从上到下的顺序报告结点的值（ Y 坐标递减）。

如果两个结点位置相同，则首先报告的结点值较小。

按 X 坐标顺序返回非空报告的列表。每个报告都有一个结点值列表。

示例 1：

输入：[3,9,20,null,null,15,7]
输出：[[9],[3,15],[20],[7]]
解释： 
在不丧失其普遍性的情况下，我们可以假设根结点位于 (0, 0)：
然后，值为 9 的结点出现在 (-1, -1)；
值为 3 和 15 的两个结点分别出现在 (0, 0) 和 (0, -2)；
值为 20 的结点出现在 (1, -1)；
值为 7 的结点出现在 (2, -2)。

示例 2：

输入：[1,2,3,4,5,6,7]
输出：[[4],[2],[1,5,6],[3],[7]]
解释：
根据给定的方案，值为 5 和 6 的两个结点出现在同一位置。
然而，在报告 "[1,5,6]" 中，结点值 5 排在前面，因为 5 小于 6。

提示：

1. 树的结点数介于 1 和 1000 之间。
2. 每个结点值介于 0 和 1000 之间。

---

16ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    var map = [Int: [(Int, Int)]]()
    func verticalTraversal(_ root: TreeNode?) -> [[Int]] {
        if root == nil {
            return []
        }
        map[0] = [(root!.val, 0)]
        traversTree(root!.left, true, 0, -1)
        traversTree(root!.right, false, 0, -1)
        var ans = [[Int]]()
        for k in map.keys.sorted() {            
            let sortedTuple = map[k]!.sorted {($0, $1)
                if $0.1 > $1.1 { return true }
                if $0.1 == $1.1 { return $0.0 < $1.0 }
                return false
            }
            let arr = sortedTuple.map {$0.0}
            ans.append(arr)
        }
        return ans
    }

    func traversTree(_ node: TreeNode?, _ left: Bool, _ v: Int, _ vv: Int) {
        if node != nil {
            let k = left ? v-1 : v+1
            var arr = map[k] ?? [(Int, Int)]()
            arr.append((node!.val, vv))
            map[k] = arr
            traversTree(node!.left, true, k, vv-1)
            traversTree(node!.right, false, k, vv-1)
        }
    }
}

---

Runtime: 20 ms

Memory Usage: 4.1 MB

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    var hi:[[Int]] = [[Int]]()
    func verticalTraversal(_ root: TreeNode?) -> [[Int]] {
        dfs(root, 0, 0)
        hi.sort(by:sortArray)
        var ret:[[Int]] = [[Int]]()
        var i:Int = 0
        while(i < hi.count)
        {
            var j:Int = i
            while(j < hi.count && hi[j][1] == hi[i][1])
            {
                j += 1
            }
            var item:[Int] = [Int]()
            for k in i..<j
            {
                item.append(hi[k][0])
            }
            ret.append(item)
            i = j
        }
        return ret
    }
    
    func sortArray(_ a:[Int],_ b:[Int]) -> Bool
    {
        if a[1] != b[1] {return a[1] < b[1]}
        if a[2] != b[2] {return a[2] > b[2]}
        return a[0] < b[0]
    }
    
    func dfs(_ cur: TreeNode?,_ x:Int,_ y:Int)
    {
        if cur == nil {return}
        hi.append([cur!.val,x,y])
        dfs(cur!.left, x-1, y-1)
        dfs(cur!.right, x+1, y-1)
    }
}

---

24ms 

class Solution {
    func verticalTraversal(_ root: TreeNode?) -> [[Int]] {
        var res: [[Int]] = []

        var dict: [Int: [(Int, [Int])]] = [:]
        
        func tra(_ node: TreeNode?, _ x: Int, y: Int) {
            guard let node = node else {
                return
            }

            if dict[x] == nil {
                dict[x] = [(y, [node.val])]
            } else {
                var sameY = false
                
                for (index, (yVal, nodeVal)) in dict[x]!.enumerated() {
                    if yVal == y {
                        sameY = true
                        
                        var newVal = nodeVal
                        newVal.append(node.val)
                        
                        dict[x]![index].1 = newVal.sorted()
                    }
                }
                
                if sameY == false {
                    dict[x]!.append((y, [node.val]))
                }
            }
            
            tra(node.left, x - 1, y: y - 1)
            tra(node.right, x + 1, y: y - 1)
        }
        
        tra(root, 0, y: 0)
        
        let sortedDict = dict.sorted(by: {$0.key < $1.key})
        
        for dict in sortedDict {
            var vals: [Int] = []
            
            for (_, val) in dict.value.sorted(by: { $0.0 > $1.0 }) {
                vals += val
            }
            
            res.append(vals)
        }
        
        return res
    }
}