[Swift]LeetCode222. 完全二叉树的节点个数 | Count Complete Tree Nodes

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

Given a complete binary tree, count the number of nodes.

Note:

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:

Input: 
    1
   / 
  2   3
 /   /
4  5 6

Output: 6

---

给出一个完全二叉树，求出该树的节点个数。

说明：

完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。

示例:

输入: 
    1
   / 
  2   3
 /   /
4  5 6

输出: 6

---

96ms

/**
 * 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 countNodes(_ root: TreeNode?) -> Int {
        guard  root != nil else{
            return 0
        }
        
        var leftCount = 0
        var rightCount = 0
        
        var leftNode = root
        var rightNode = root
        while leftNode != nil{
            leftCount += 1
            leftNode = leftNode?.left
        }
        
        while rightNode != nil{
            rightCount += 1
            rightNode = rightNode?.right
        }
        if leftCount == rightCount{
            return Int( pow(Double(2), Double(leftCount)) - 1.0)
        }

        return countNodes(root?.left) + countNodes(root?.right) + 1
        
    }
}

---

100ms

/**
 * 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 countNodes(_ root: TreeNode?) -> Int {
        guard let root = root else { return 0 }
        
        return 1 + countNodes(root.left) + countNodes(root.right)
    }
}

---

104ms

/**
 * 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 nodes = 0
    
    func countNodes(_ root: TreeNode?) -> Int {
        guard let root = root else { return 0 }
        nodes += 1
        if let left = root.left {
            countNodes(left)
        }
        if let right = root.right {
            countNodes(right)
        }
        return nodes
    }
}

---

112ms

/**
 * 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 countNodes(_ root: TreeNode?) -> Int {
        if root == nil {
            return 0
        }
        var count = 0
        var stack = [TreeNode?]()
        stack.append(root)
        while !stack.isEmpty {
            guard let node = stack.removeLast() else {
                return count
            } 
            count += 1
            if let lNode = node.left {
                stack.append(lNode)
            }
            if let rNode = node.right {
                stack.append(rNode)
            }
        }
        return count
    }
}

---

120ms

/**
 * 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 countNodes(_ root: TreeNode?) -> Int {
    guard let root = root else {
        return 0
    }
    
    let left = countLeftNodes(root)
    let right = countRightNodes(root)
    
    if left == right {
        return NSDecimalNumber(decimal: Decimal(pow(2.0, Double(left)) - 1.0)).intValue
    }
    
    return countNodes(root.left) + countNodes(root.right) + 1
}

private func countLeftNodes(_ node: TreeNode?) -> Int {
    var height = 0, node = node
    
    while node != nil {
        node = node?.left
        height += 1
    }
    
    return height
}

private func countRightNodes(_ node: TreeNode?) -> Int {
    var height = 0, node = node
    while node != nil {
        node = node?.right
        height += 1
    }
    
    return height
}
}

---

176ms

/**
 * 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 countNodes(_ root: TreeNode?) -> Int {
        var hLeft:Int = leftHeight(root)
        var hRight:Int = rightHeight(root)
        if hLeft == hRight
        {
            return Int(pow(Double(2), Double(hLeft)) - 1)
        }
        return countNodes(root!.left) + countNodes(root!.right) + 1
    }
    
    func leftHeight(_ root: TreeNode?) -> Int
    {
        if root == nil {return 0}
        return 1 + leftHeight(root!.left)
    }
    
    func rightHeight(_ root: TreeNode?) -> Int
    {
        if root == nil {return 0}
        return 1 + rightHeight(root!.right)
    }
}