[Swift]LeetCode958. 二叉树的完全性检验 | Check Completeness of a Binary Tree

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

Given a binary tree, determine if it is a complete binary tree.

Definition of a complete binary tree from Wikipedia:
In a complete binary tree every level, except possibly the last, is completely filled, and all nodes in the last level are as far left as possible. It can have between 1 and 2h nodes inclusive at the last level h.

Example 1:

Input: [1,2,3,4,5,6]
Output: true
Explanation: Every level before the last is full (ie. levels with node-values {1} and {2, 3}), and all nodes in the last level ({4, 5, 6}) are as far left as possible.

Example 2:

Input: [1,2,3,4,5,null,7]
Output: false
Explanation: The node with value 7 isn't as far left as possible.

Note:

1. The tree will have between 1 and 100 nodes.

---

给定一个二叉树，确定它是否是一个完全二叉树。

百度百科中对完全二叉树的定义如下：

若设二叉树的深度为 h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。（注：第 h 层可能包含 1~ 2h 个节点。）

示例 1：

输入：[1,2,3,4,5,6]
输出：true
解释：最后一层前的每一层都是满的（即，结点值为 {1} 和 {2,3} 的两层），且最后一层中的所有结点（{4,5,6}）都尽可能地向左。

示例 2：

输入：[1,2,3,4,5,null,7]
输出：false
解释：值为 7 的结点没有尽可能靠向左侧。

提示：

1. 树中将会有 1 到 100 个结点。

---

20ms

/**
 * 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 isCompleteTree(_ root: TreeNode?) -> Bool {
        var qs = [root]
        while !qs.isEmpty {
            let v = qs.count
            for i in 0 ..< v {
                guard let u = qs.remove(at: 0) else {
                    continue
                }
                var child = [u.left, u.right]
                for c in child {
                    guard let t = c else {
                        qs.append(c)
                        continue
                    } 
                    if qs.count > 0, let t = qs.last, t == nil {
                        return false
                    }
                    qs.append(c)
                }  

            }
        }
        return true
    }
}

---

36 ms

/**
 * 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 isCompleteTree(_ root: TreeNode?) -> Bool {
        var root = root
        var queue:[TreeNode?] =  [TreeNode?]()
        var leaf:Bool = false
        queue.append(root)
        
        while(!queue.isEmpty)
        {
            root = queue.removeFirst()
            if (leaf && (root?.left != nil || root?.right != nil)) || (root?.left == nil && root?.right != nil)
            {
                return false
            }
            if root?.left != nil
            {
                queue.append(root?.left)
            }
            if root?.right != nil
            {
                queue.append(root?.right)
            }
            else
            {
                leaf = true
            }
        }
         return true
    }
}

---

36ms

/**
 * 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
 *     }
 * }
 */
extension TreeNode {
    public func height() -> Int {
        if self.left == nil && self.right == nil {
            return 1
        }
        var left = 0, right = 0
        if self.left != nil {
            left = self.left!.height()
        }
        if self.right != nil {
            right = self.right!.height()
        }
        return 1 + max(left, right)
    }
}

class Solution {
    func isCompleteTree(_ root: TreeNode?) -> Bool {
        guard let first = root else { return true }
        var level = first.height()
        var arr: [TreeNode?] = [first]
        var newArr: [TreeNode?] = []
        // Construct array
        while level > 2 {
            newArr = []
            for node in arr {
                if node != nil && node?.left != nil && node?.right != nil {
                    newArr.append(node?.left)
                    newArr.append(node?.right)
                } else {
                    return false
                }
            }
            arr = newArr
            level -= 1
        }
        
        
        // Assess last row
        var foundNil = false
        for node in arr {
            // 1) If right node exists and left doesnt, return false
            if node?.right != nil && node?.left == nil {
                return false
            }
            // 2) If a nil was found, no subsequent node children should have values else return false
            if foundNil && (node?.left != nil || node?.right != nil) {
                return false
            }
            // 3) Notify a nil was found
            if node?.left == nil || node?.right == nil {
                foundNil = true
            }
        }
        return true
    }
}

---

40ms

extension TreeNode {
    func elements() -> [Int?] {
        let result: [Int?] = [self.val]
        return elementsRec(queue: [self], result: result)
    }
    
    func elementsRec(queue: [TreeNode], result: [Int?]) -> [Int?] {
        var innerQueue = queue
        
        if innerQueue.isEmpty {
            return result
        }
        
        let tree = innerQueue.removeFirst()
        
        var innerResult = result
        
        if tree.left == nil && tree.right == nil {
            innerResult.append(nil)
            innerResult.append(nil)
            return elementsRec(queue: innerQueue, result: innerResult)
        }
        
        if let left = tree.left {
            innerQueue.append(left)
            innerResult.append(left.val)
        } else {
            innerResult.append(nil)
        }
        
        if let right = tree.right {
            innerQueue.append(right)
            innerResult.append(right.val)
        } else {
            innerResult.append(nil)
        }
        
        return elementsRec(queue: innerQueue, result: innerResult)
    }
}
    
class Solution {
    func isCompleteTree(_ root: TreeNode?) -> Bool {  
        guard let root = root else {
            return true
        }
        
        let elements = root.elements()
        
        var hasNull = false
        
        for i in 0..<elements.count {
            let element = elements[i]
            
            if element == nil {
                
                hasNull = true
                continue
                
            } else {
                
                if hasNull {
                    return false
                }
                
                hasNull = false
            }
        }
        
        if root.left == nil && root.right != nil {
            return false
        }
        
        return isCompleteTree(root.left) && isCompleteTree(root.right)
    }
}