[Swift]LeetCode872. 叶子相似的树 | Leaf-Similar Trees

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

Consider all the leaves of a binary tree.  From left to right order, the values of those leaves form a leaf value sequence.

For example, in the given tree above, the leaf value sequence is (6, 7, 4, 9, 8).

Two binary trees are considered leaf-similar if their leaf value sequence is the same.

Return true if and only if the two given trees with head nodes root1 and root2 are leaf-similar. 

Note:

• Both of the given trees will have between 1 and 100nodes.

---

请考虑一颗二叉树上所有的叶子，这些叶子的值按从左到右的顺序排列形成一个 叶值序列 。

举个例子，如上图所示，给定一颗叶值序列为 (6, 7, 4, 9, 8) 的树。

如果有两颗二叉树的叶值序列是相同，那么我们就认为它们是 叶相似 的。

如果给定的两个头结点分别为 root1 和 root2 的树是叶相似的，则返回 true；否则返回 false 。 

提示：

• 给定的两颗树可能会有 1 到 100 个结点。

---

Runtime: 12 ms

Memory Usage: 19 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 {
    func leafSimilar(_ root1: TreeNode?, _ root2: TreeNode?) -> Bool {
        return traverse(root1) == traverse(root2)
    }

    func traverse(_ root: TreeNode?) ->String
    {
        if root == nil {return String()}
        if root?.left == nil && root?.right == nil
        {
            return String(root!.val) + "-"
        }
        return traverse(root?.left) + traverse(root?.right)
    }
}

---

12ms

/**
 * 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 {
    func leafSimilar(_ root1: TreeNode?, _ root2: TreeNode?) -> Bool {
        var leaves1 : [Int] = []
        var leaves2 : [Int] = []
        getLeaves(root1, &leaves1)
        getLeaves(root2, &leaves2)
        
        return isSame(leaves1, leaves2)
    }
    
    func getLeaves(_ root: TreeNode?, _ leaves: inout [Int]) {
        guard let node = root else {
            return
        }
        if node.left == nil && node.right == nil {
            leaves.append(node.val)
            return
        }
        getLeaves(node.left, &leaves)
        getLeaves(node.right, &leaves)
    }
    
    func isSame(_ leaves1: [Int], _ leaves2: [Int]) -> Bool {
        if leaves1.count != leaves2.count {
            return false
        }
        
        for i in 0..<leaves1.count {
            if leaves1[i] != leaves2[i] {
                return false
            }
        }
        return true
    }
}

---

Runtime: 16 ms

Memory Usage: 19.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 {
    func leafSimilar(_ root1: TreeNode?, _ root2: TreeNode?) -> Bool {
        if root1 == nil {
            if root2 == nil {
                return true
            }
            return false
        }
        
        var roots1: [Int] = [], roots2: [Int] = []
        
        traversingBTree(root1!, roots: &roots1)
        traversingBTree(root2!, roots: &roots2)
        
        //    遍历并且存储叶节点的值至数组
        
        guard roots1.count == roots2.count else {
            return false
        }
        
        for index in 0..<roots1.count {
            if roots1[index] != roots2[index] {
                return false
            }
        }
        
        return true
    }
    
    func traversingBTree(_ root: TreeNode, roots: inout [Int]) {
        
        if root.left == nil && root.right == nil {
            roots.append(root.val)
            return ;
        }
        if let left = root.left {
            traversingBTree(left, roots: &roots)
        }
        
        if let right = root.right {
            traversingBTree(right, roots: &roots)
        }
    }
}

---

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 {
    func leafSimilar(_ root1: TreeNode?, _ root2: TreeNode?) -> Bool {

        return getLeaves(root1) == getLeaves(root2)
        
    }
    func getLeaves(_ root:TreeNode?) -> [Int]
    {
        guard let root = root else
        {
            return []
        }
        var result: [Int] = []
        if root.left == nil && root.right == nil
        {
            result += [root.val]
        }
        result += getLeaves(root.left)
        result += getLeaves(root.right)
        return result
    }
}

---

24ms

class Solution {
    func leafSimilar(_ root1: TreeNode?, _ root2: TreeNode?) -> Bool {
        var arr1 = [Int]()
        var arr2 = [Int]()
        helper(root1, &arr1)
        helper(root2, &arr2)
        for i in 0..<min(arr1.count, arr2.count) {
            if arr1[i] != arr2[i] {
                return false
            }
        }
        return true
    }
    
    func helper(_ root: TreeNode?, _ arr: inout [Int]) {
        guard root?.left != nil || root?.right != nil else {
            if root != nil {
                arr.append(root!.val)
            }
            return
        }
        helper(root?.left, &arr)
        helper(root?.right, &arr)
    }
}

---

28ms

class Solution {
    func leafSimilar(_ root1: TreeNode?, _ root2: TreeNode?) -> Bool {
    var arr1 = [Int]()
    var arr2 = [Int]()
    
    getArray(root1, &arr1)
    getArray(root2, &arr2)
    
    return arr1 == arr2
}
    func getArray(_ root: TreeNode?, _ arr: inout [Int]) {
        guard let r = root else { return }          
        if r.left == nil && r.right == nil {             
            arr.append(r.val)
        } else {
            getArray(r.left, &arr)
            getArray(r.right, &arr)
        }
    }
}

---

32ms

class Solution {
    func leafSimilar(_ root1: TreeNode?, _ root2: TreeNode?) -> Bool {
        var array1: [Int] = []
        var array2: [Int] = []
        dfs(root: root1, result: &array1)
        dfs(root: root2, result: &array2)
        return array1 == array2
    }
    
    func dfs(root: TreeNode?, result: inout [Int]) -> Void {
        if let r = root {
            if r.left == nil && r.right == nil {
                result.append(r.val)
            }
            dfs(root: r.left, result: &result)
            dfs(root: r.right, result: &result)
        }
    }
}