为有牺牲多壮志，敢教日月换新天。

[Swift]LeetCode993. 二叉树的堂兄弟节点 | Cousins in Binary Tree

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

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

In a binary tree, the root node is at depth 0, and children of each depth k node are at depth k+1.

Two nodes of a binary tree are cousins if they have the same depth, but have different parents.

We are given the root of a binary tree with unique values, and the values x and y of two different nodes in the tree.

Return true if and only if the nodes corresponding to the values x and y are cousins. 

Example 1:

Input: root = [1,2,3,4], x = 4, y = 3
Output: false

Example 2:

Input: root = [1,2,3,null,4,null,5], x = 5, y = 4
Output: true

Example 3:

Input: root = [1,2,3,null,4], x = 2, y = 3
Output: false

Note:

  1. The number of nodes in the tree will be between 2 and 100.
  2. Each node has a unique integer value from 1 to 100.

在二叉树中，根节点位于深度 0 处，每个深度为 k 的节点的子节点位于深度 k+1 处。

如果二叉树的两个节点深度相同，但父节点不同，则它们是一对堂兄弟节点。

我们给出了具有唯一值的二叉树的根节点 root，以及树中两个不同节点的值 x 和 y。

只有与值 x 和 y 对应的节点是堂兄弟节点时，才返回 true。否则，返回 false。 

示例 1：

输入：root = [1,2,3,4], x = 4, y = 3
输出：false

示例 2：

输入：root = [1,2,3,null,4,null,5], x = 5, y = 4
输出：true

示例 3：

输入：root = [1,2,3,null,4], x = 2, y = 3
输出：false 

提示：

  1. 二叉树的节点数介于 2 到 100 之间。
  2. 每个节点的值都是唯一的、范围为 1 到 100 的整数。

Runtime: 12 ms

Memory Usage: 18.4 MB
 1 /**
 2  * Definition for a binary tree node.
 3  * public class TreeNode {
 4  *     public var val: Int
 5  *     public var left: TreeNode?
 6  *     public var right: TreeNode?
 7  *     public init(_ val: Int) {
 8  *         self.val = val
 9  *         self.left = nil
10  *         self.right = nil
11  *     }
12  * }
13  */
14 class Solution {
15     var ddd:Int = 0
16     func isCousins(_ root: TreeNode?, _ x: Int, _ y: Int) -> Bool {
17         var px:TreeNode? = dfs(root, nil, x, 0, 1)
18         var py:TreeNode? = dfs(root, nil, y, 0, -1)
19         return x != y && px != nil && py != nil && px!.val != py!.val && ddd == 0       
20     }
21     
22     func dfs(_ cur:TreeNode?,_ par:TreeNode?,_ x:Int,_ dep:Int,_ mul:Int) -> TreeNode?
23     {
24         if cur == nil {return nil}
25         if cur!.val == x
26         {
27             ddd += dep * mul
28             return par
29         }
30         var res:TreeNode? = dfs(cur!.left, cur, x, dep + 1, mul)
31         if res != nil {return res}
32         res = dfs(cur!.right, cur, x, dep+1, mul)
33         return res        
34     }
35 }
 1 /**
 2  * Definition for a binary tree node.
 3  * public class TreeNode {
 4  *     public var val: Int
 5  *     public var left: TreeNode?
 6  *     public var right: TreeNode?
 7  *     public init(_ val: Int) {
 8  *         self.val = val
 9  *         self.left = nil
10  *         self.right = nil
11  *     }
12  * }
13  */
14 class Solution {
15     func isCousins(_ root: TreeNode?, _ x: Int, _ y: Int) -> Bool {
16         guard let root = root else {
17             return false
18         }
19         
20         var rootVal = -1
21         var cousinLevel = -1
22         var isCousins = false
23         
24         func goNext(_ node: TreeNode?, _ level: Int, _ parent: TreeNode) {
25             guard let node = node else {
26                 return
27             }
28             
29             if node.val == x || node.val == y {
30                 if rootVal == -1 {
31                     rootVal = parent.val
32                     cousinLevel = level
33                 } else if rootVal != parent.val && cousinLevel == level {
34                     isCousins = true
35                 }
36             }
37             
38             goNext(node.left, level + 1, node)
39             goNext(node.right, level + 1, node)
40         }
41         
42         goNext(root.left, 1, root)
43         goNext(root.right, 1, root)
44         
45         return isCousins
46     }
47 }
 1 /**
 2  * Definition for a binary tree node.
 3  * public class TreeNode {
 4  *     public var val: Int
 5  *     public var left: TreeNode?
 6  *     public var right: TreeNode?
 7  *     public init(_ val: Int) {
 8  *         self.val = val
 9  *         self.left = nil
10  *         self.right = nil
11  *     }
12  * }
13  */
14 class Solution {
15     func isCousins(_ root: TreeNode?, _ x: Int, _ y: Int) -> Bool {
16         var queue = [TreeNode]()
17         guard let root = root else {
18             return false
19         }
20         
21         queue.append(root)
22         while queue.count > 0 {
23             let size = queue.count 
24             var level = [Int]()
25             for i in 0..<size {
26                 let temp = queue.removeFirst()
27                 if let left = temp.left, let right = temp.right {
28                     if (left.val == x && right.val == y) || (left.val == y && right.val == x) {
29                         return false
30                     }
31                     queue.append(left)
32                     queue.append(right)
33                     level.append(left.val)
34                     level.append(right.val)
35                 } else if let left = temp.left {
36                     queue.append(left)
37                     level.append(left.val)
38                 } else if let right = temp.right{
39                     queue.append(right)
40                     level.append(right.val)
41                 }
42             }
43             if level.contains(x) && level.contains(y) {
44                 return true
45             }
46         }
47         return false
48     }
49 }
 1 /**
 2  * Definition for a binary tree node.
 3  * public class TreeNode {
 4  *     public var val: Int
 5  *     public var left: TreeNode?
 6  *     public var right: TreeNode?
 7  *     public init(_ val: Int) {
 8  *         self.val = val
 9  *         self.left = nil
10  *         self.right = nil
11  *     }
12  * }
13  */
14 class Solution {
15     func isCousins(_ root: TreeNode?, _ x: Int, _ y: Int) -> Bool {
16         var depths = [Int:Int]()
17         var parents = [Int:TreeNode]()
18         find(root, val: x, depths: &depths, parents: &parents)
19         find(root, val: y, depths: &depths, parents: &parents)
20         if let xDepth = depths[x], let yDepth = depths[y], let xParent = parents[x], let yParent = parents[y] {
21             return xDepth == yDepth && xParent !== yParent
22         }
23         return false
24     }
25     
26     func find(_ node: TreeNode?, val: Int, depth: Int = 0, depths: inout [Int:Int], parents: inout [Int:TreeNode]) {
27         guard let node = node else {
28             return
29         }
30         if let left = node.left, left.val == val {
31             parents[val] = node
32             depths[val] = depth
33             return
34         }
35         else if let right = node.right, right.val == val {
36             parents[val] = node 
37             depths[val] = depth
38             return
39         }
40         find(node.left, val: val, depth: depth + 1, depths: &depths, parents: &parents)
41         find(node.right, val: val, depth: depth + 1, depths: &depths, parents: &parents)
42     }
43 }
 1 class Solution {
 2   private var xVal: Int!
 3   private var yVal: Int!
 4 
 5   private var xPair: (lvl: Int, prnt: Int)?
 6   private var yPair: (lvl: Int, prnt: Int)?
 7 
 8   func isCousins(_ root: TreeNode?, _ x: Int, _ y: Int) -> Bool {
 9     xVal = x
10     yVal = y
11     search(lvl: 0, prevVal: 0, node: root)
12     return xPair?.lvl == yPair?.lvl && xPair?.prnt != yPair?.prnt
13   }
14   
15   private func search(lvl: Int, prevVal: Int, node: TreeNode?) {
16     guard let n = node else { return }
17     if n.val == xVal! {
18       xPair = (lvl, prevVal)
19     } else if n.val == yVal! {
20       yPair = (lvl, prevVal)
21     }
22     search(lvl: lvl + 1, prevVal: n.val, node: n.left)
23     search(lvl: lvl + 1, prevVal: n.val, node: n.right)
24   }
25 }
 1 /**
 2  * Definition for a binary tree node.
 3  * public class TreeNode {
 4  *     public var val: Int
 5  *     public var left: TreeNode?
 6  *     public var right: TreeNode?
 7  *     public init(_ val: Int) {
 8  *         self.val = val
 9  *         self.left = nil
10  *         self.right = nil
11  *     }
12  * }
13  */
14 class Solution {
15     
16     func isCousins(_ root: TreeNode?, _ x: Int, _ y: Int) -> Bool {
17         let (foundX, foundY, depth) = isCousins(root, 0, x, y)
18         return foundX && foundY && depth != nil
19     }
20 
21     func isCousins(_ root: TreeNode?, _ depth: Int, _ x: Int, _ y: Int) -> (foundX: Bool, foundY: Bool, depth: Int?) {
22         guard let root = root else {
23             return (false, false, nil)
24         }
25 
26         if root.val == x {
27             return (true, false, depth)
28         } else if root.val == y {
29             return (false, true, depth)
30         }
31 
32         var xDepth: Int? = nil
33         var yDepth: Int? = nil
34 
35         let (leftFoundX, leftFoundY, leftDepth) = isCousins(root.left, depth + 1, x, y)
36 
37         if leftFoundX && leftFoundY {
38             return (leftFoundX, leftFoundY, leftDepth)
39         }
40 
41         xDepth = (leftFoundX) ? leftDepth : xDepth
42         yDepth = (leftFoundY) ? leftDepth : yDepth
43 
44         let (rightFoundX, rightFoundY, rightDepth) = isCousins(root.right, depth + 1, x, y)
45 
46         if rightFoundX && rightFoundY {
47             return (rightFoundX, rightFoundY, rightDepth)
48         }
49 
50         xDepth = (rightFoundX) ? rightDepth : xDepth
51         yDepth = (rightFoundY) ? rightDepth : yDepth
52 
53         let foundX = leftFoundX || rightFoundX
54         let foundY = leftFoundY || rightFoundY
55         if foundX && foundY {
56             if xDepth == yDepth && (xDepth != (depth+1)) {
57                 return (true, true, xDepth)
58             } else {
59                 return (true, true, nil)
60             }
61         } else {
62             return (foundX, foundY, xDepth ?? yDepth)
63         }
64     }    
65 }
  1 /**
  2  * Definition for a binary tree node.
  3  * public class TreeNode {
  4  *     public var val: Int
  5  *     public var left: TreeNode?
  6  *     public var right: TreeNode?
  7  *     public init(_ val: Int) {
  8  *         self.val = val
  9  *         self.left = nil
 10  *         self.right = nil
 11  *     }
 12  * }
 13  */
 14 protocol Queue {
 15     associatedtype T
 16     var count: Int { get }
 17     var isEmpty: Bool { get }
 18     var top: T? { get }
 19     func enqueue(_ item: T)
 20     func dequeue() -> T?
 21 }
 22 
 23 class LinkedListNode<T> {
 24     var value: T
 25     var next: LinkedListNode<T>?
 26     init(_ value: T) {
 27         self.value = value
 28     }
 29     init(_ value: T, _ next: LinkedListNode<T>) {
 30         self.value = value
 31         self.next = next
 32     }
 33 }
 34 
 35 class LinkedQueue<Type> : Queue {
 36     typealias T = Type
 37     private var head: LinkedListNode<T>?
 38     private var tail: LinkedListNode<T>?
 39     private(set) var count: Int = 0
 40     var isEmpty: Bool {
 41         return head == nil
 42     }
 43     var top: T? {
 44         return head?.value
 45     }
 46     
 47     init () {
 48         self.head = nil
 49         self.tail = nil
 50     }
 51     init(_ initialValue: T) {
 52         self.head = LinkedListNode<T>(initialValue)
 53         self.tail = self.head
 54     }
 55     
 56     func enqueue(_ item: T) {
 57         if isEmpty {
 58             self.tail = LinkedListNode<T>(item)
 59             self.head = self.tail
 60         } else {
 61             self.tail!.next = LinkedListNode<T>(item)
 62             self.tail = self.tail!.next
 63         }
 64         count += 1
 65     }
 66     
 67     func dequeue() -> Type? {
 68         if let validHead = self.head {
 69             let data = validHead.value
 70             self.head = validHead.next
 71             count -= 1
 72             return data
 73         } else {
 74             return nil
 75         }
 76     }
 77 }
 78 
 79 
 80 class Solution {
 81     func isCousins(_ root: TreeNode?, _ x: Int, _ y: Int) -> Bool {
 82         var xParent: Int? = nil
 83         var yParent: Int? = nil
 84         var xDepth: Int? = nil
 85         var yDepth: Int? = nil
 86         
 87         typealias Level = Int
 88         let frontier = LinkedQueue<(TreeNode, Level, TreeNode?)>()
 89         frontier.enqueue((root!, 0, nil))
 90         
 91         while true {
 92             guard let (node, level, parent) = frontier.dequeue() else {
 93                 break
 94             }
 95             if node.val == x {
 96                 xParent = parent?.val
 97                 xDepth = level
 98             }
 99             if node.val == y {
100                 yParent = parent?.val
101                 yDepth = level
102             }
103             if let leftChild = node.left {
104                 frontier.enqueue((leftChild, level + 1, node))
105             }
106             
107             if let rightChild = node.right {
108                 frontier.enqueue((rightChild, level + 1, node))
109             }
110         }
111         
112         return (xDepth != nil) && (yDepth != nil) && (xDepth == yDepth) && (xParent != yParent)
113     }
114 }
 1 /**
 2  * Definition for a binary tree node.
 3  * public class TreeNode {
 4  *     public var val: Int
 5  *     public var left: TreeNode?
 6  *     public var right: TreeNode?
 7  *     public init(_ val: Int) {
 8  *         self.val = val
 9  *         self.left = nil
10  *         self.right = nil
11  *     }
12  * }
13  */
14 class Solution {
15     var xParent = -1
16     var yParent = -1
17     var xDepth = Int.min
18     var yDepth = Int.max
19     
20     func isCousins(_ root: TreeNode?, _ x: Int, _ y: Int) -> Bool {
21         if let r = root {
22             countDepth(r, r.left, x, y, 1)
23             countDepth(r, r.right, x, y, 1)
24             if xParent != yParent && xDepth == yDepth {
25                 return true
26             }
27         } 
28         return false
29     }
30     
31     func countDepth(_ parent: TreeNode, _ node: TreeNode?, _ x: Int, _ y: Int, _ depth: Int) {
32         if let r = node {
33             if r.val == x {
34                 xParent = parent.val
35                 xDepth = depth
36             }   
37             
38             if r.val == y {
39                 yParent = parent.val
40                 yDepth = depth
41             }
42             
43             countDepth(r, r.left, x, y, depth+1)
44             countDepth(r, r.right, x, y, depth+1)
45         }
46     }
47 }
 1 /**
 2  * Definition for a binary tree node.
 3  * public class TreeNode {
 4  *     public var val: Int
 5  *     public var left: TreeNode?
 6  *     public var right: TreeNode?
 7  *     public init(_ val: Int) {
 8  *         self.val = val
 9  *         self.left = nil
10  *         self.right = nil
11  *     }
12  * }
13  */
14 class Solution {
15     var xNode: (Int, TreeNode?)?
16     var yNode: (Int, TreeNode?)?
17     func isCousins(_ root: TreeNode?, _ x: Int, _ y: Int) -> Bool {
18         helper(root, nil, x, y, 0)
19         guard let xNode = xNode, let yNode = yNode else { return false }
20         return xNode.0 == yNode.0 && xNode.1 !== yNode.1
21     }
22     
23     private func helper(_ root: TreeNode?, _ parent: TreeNode?, _ x: Int, _ y: Int, _ depth: Int) {
24         guard let root = root else { return }
25         if root.val == x {
26             xNode = (depth, parent)
27         }
28         if root.val == y {
29             yNode = (depth, parent)
30         }
31         helper(root.left, root, x, y, depth + 1)
32         helper(root.right, root, x, y, depth + 1)
33     }
34 }

 

posted @ 2019-02-17 12:10  为敢技术  阅读(421)  评论(0)  编辑  收藏  举报