[Swift]LeetCode653. 两数之和 IV

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

Given a Binary Search Tree and a target number, return true if there exist two elements in the BST such that their sum is equal to the given target.

Example 1:

Input: 
    5
   / 
  3   6
 /    
2   4   7

Target = 9

Output: True 

Example 2:

Input: 
    5
   / 
  3   6
 /    
2   4   7

Target = 28

Output: False

---

给定一个二叉搜索树和一个目标结果，如果 BST 中存在两个元素且它们的和等于给定的目标结果，则返回 true。

案例 1:

输入: 
    5
   / 
  3   6
 /    
2   4   7

Target = 9

输出: True 

案例 2:

输入: 
    5
   / 
  3   6
 /    
2   4   7

Target = 28

输出: False

---

124ms

/**
 * 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 findTarget(_ root: TreeNode?, _ k: Int) -> Bool {
        var list = [Int]()
        inorder(root, &list)
        
        var i = 0
        var j = list.count - 1
        while i < j {
            if list[i] + list[j] == k { return true }
            if list[i] + list[j] < k { i += 1}
            else { j -= 1}
        }
        
        return false
    }
    
    func inorder(_ root: TreeNode?, _ list: inout [Int]) {
        guard let r = root else { return }
        
        inorder(r.left, &list)
        list.append(r.val)
        inorder(r.right, &list)
    }
}

---

Runtime: 128 ms

Memory Usage: 20.2 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 findTarget(_ root: TreeNode?, _ k: Int) -> Bool {
        var set: Set<Int> = []
        var result = false
        func check(_ tree: TreeNode?) -> Bool {
            if tree == nil {return false}
            let val = tree!.val
            if set.contains(k - val) {
                return true
            }else {
                set.insert(val)
                return check(tree?.left) || check(tree?.right)
            }
        }
        return check(root)
    }
}

---

132ms

/**
 * 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 findTarget(_ root: TreeNode?, _ k: Int) -> Bool {
        var dict = [Int: Int]()
        return traverse(root, k , &dict)
    }
    
    func traverse(_ root: TreeNode?, _ k: Int, _  dict: inout [Int: Int]) -> Bool {
        guard let root = root else { return false }
        let rem = k - root.val
        if dict[rem] != nil {
            return true
        }
        dict[root.val] = 1
        return traverse(root.left, k, &dict) || traverse(root.right, k, &dict)
    }
}

---

Runtime: 140 ms

Memory Usage: 20.2 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 findTarget(_ root: TreeNode?, _ k: Int) -> Bool {
        if root == nil {return false}
        var st:Set<Int> = Set<Int>()
        var q:[TreeNode?] = [root]
        while (!q.isEmpty)
        {
            var t:TreeNode? = q.removeFirst()           
            if st.contains(k - t!.val) {return true}
            st.insert(t!.val)
            if t?.left != nil {q.append(t!.left)}
            if t?.right != nil {q.append(t!.right)}
        }
        return false
    }
}

---

152ms

class Solution {
  var arr : [Int] = []
    func findTarget(_ root: TreeNode?, _ k: Int) -> Bool {
        preOrder(root)
        var i = 0
        var j = arr.count - 1
        while i < j {
            let sum = arr[i] + arr[j]
            if sum == k {
                return true
            } else if sum < k {
                i += 1
            } else {
                j -= 1
            }
        }
        return false
    }
    
    func preOrder(_ root: TreeNode?) {
        if root == nil {return}
        preOrder(root?.left)
        arr.append(root!.val)
        preOrder(root?.right)
    }
}

---

156ms

class Solution {
    func findTarget(_ root: TreeNode?, _ k: Int) -> Bool {
        var dic = [Int:Int]()
        return find(root,k, &dic)
    }
    func find(_ root: TreeNode?, _ k: Int, _  dic: inout [Int:Int]) -> Bool {
        if let root = root {
            let value = k - root.val
            if dic[value] != nil {
                return true
            }
            dic[root.val] = root.val
            return find(root.left,k,&dic) || find(root.right,k,&dic)
        } else {
            return false
        }
    }
}

---

164ms

class Solution {
    
    var memo : Set<Int> = []
    var isSum = false
    
    func findTarget(_ root: TreeNode?, _ k: Int) -> Bool {
        guard let node = root else { return false }
        
        depthFS(node, k)
        return isSum
    }
    
    func depthFS(_ root: TreeNode?,_ k: Int){
         
        guard let node = root else { return }
        
        let complement = k - node.val
        
        if memo.contains(complement){
            isSum = true
        } else {
            memo.insert(node.val)
        }
        
        if let left = node.left{
            findTarget(left, k)
        }
        
        if let right = node.right{
            findTarget(right, k)
        }
    }
}

---

172ms

class Solution {
    func findTarget(_ root: TreeNode?, _ k: Int) -> Bool {
        if root == nil {
            return false
        }
        
        var nodeValueDict = [Int: Int]()
        var nodeArray = [TreeNode]()
        nodeArray.append(root!)
        while nodeArray.count > 0 {
            let frontNode = nodeArray[0]
            let diff = k - frontNode.val
            
            if nodeValueDict[diff] != nil {
                return true
            }
            
            nodeArray.removeFirst()
            nodeValueDict[frontNode.val] = 1
            
            if frontNode.left != nil {
                nodeArray.append(frontNode.left!)
            }
            
            if frontNode.right != nil {
                nodeArray.append(frontNode.right!)
            }
        }
        
        return false
    }
}

---

196ms

class Solution {
    func preorder(_ root: TreeNode?) -> [Int] {
        if let root: TreeNode = root {
            return preorder(root.left) + [root.val] + preorder(root.right)
        } else {
            return []
        }
    }
    
    func findTarget(_ root: TreeNode?, _ k: Int) -> Bool {
        var seenVals = Set<Int>()
        
        for val in preorder(root) {
            if seenVals.contains(k - val) {
                return true
            } else {
                seenVals.insert(val)
            }
        }
        
        return false
    }
}

---

200ms

class Solution {
    func findTarget(_ root: TreeNode?, _ k: Int) -> Bool {
        guard let root = root else{
            return false
        }
        var nSet = Set<Int>()
        var queue = [TreeNode]()
        queue.append(root)
            
        while queue.count > 0{
            let cur = queue.removeFirst()
            nSet.insert(cur.val)
            if let left = cur.left{
                queue.append(left)
            }
            if let right = cur.right{
                queue.append(right)
            }
        }
        for n in Array(nSet){
            if nSet.contains(k - n) && n != (k - n){
                return true
            }
        }
        return false
    }
}

---

220ms

class Solution {
    
    var memo : Set<Int> = []
    // var isSum = false
    
    func findTarget(_ root: TreeNode?, _ k: Int) -> Bool {
        guard let node = root else { return false }
        
        return depthFS(node, k)
    }
    
    func depthFS(_ root: TreeNode?,_ k: Int) -> Bool{
         
        guard let node = root else { return false}
        
        let complement = k - node.val
        print(node.val)
        if memo.contains(complement){
            return true
        } else {
            memo.insert(node.val)
        }
        
        return depthFS(node.left, k) || depthFS(node.right, k)
    }
}