二叉樹BinaryTree的深度

二叉樹定義

typealias Node = BinaryTree
class BinaryTree<T: Comparable>{
    var value:T
    var left: Node<T>?
    var right: Node<T>?
    init(_ value:T, leftNode: Node<T>?, rightNode: Node<T>? ) {
        self.value = value
        self.left = leftNode
        self.right = rightNode
    }
}

extension BinaryTree: CustomDebugStringConvertible, CustomStringConvertible{
    var description: String{
        return "\(value) \(String(describing: left)) \(String(describing: right))\t"
    }
    var debugDescription: String{
        return "\(description)"
    }
}

extension BinaryTree{
    func add(leftNode left: Node<T>) -> Void {
        self.left = left
    }
    func add(rightNode right: Node<T>) -> Void {
        self.right = right
    }
}

複製代碼

遍歷

extension BinaryTree{
func leftDeep<T: Comparable>(_ root: BinaryTree<T>?) -> Int {
    let deep = 0
    if root == nil {
            return deep
    }
    
    var left = 0
    var right = 0
    if root?.left != nil {
        
      left =   leftDeep(root?.left) + 1
    }
    if root?.right != nil{
        right =  leftDeep(root?.right) + 1
    }
    return max(max(left, right),1) // 根節點算是一個層級
}
func rightDeep<T: Comparable>(_ root: BinaryTree<T>?)->Int{
    return leftDeep(root)
}
func binaryDeep<T: Comparable>(_ root: BinaryTree<T>?)-> Int{
    if root == nil{
        return 0
    }
    let left = leftDeep(root?.left)
    let right = rightDeep(root?.right)
     return   max(left, right) + 1
    }
    
}
複製代碼

思路

二叉樹能夠很好的使用遞歸類進行，個人思路是先遞歸的遍歷作子樹的深度，而後遍歷右子樹，取兩者最大值

使用屬性

extension BinaryTree{
    var leftDeep: Int{
        return self.leftDeep(self.left)
    }
    var rightDeep: Int{
        return self.rightDeep(self.right)
    }
    var deep: Int{
        return binaryDeep(self)
    }
}
複製代碼

測試

var node1 = BinaryTree<Int>(1, leftNode: nil, rightNode: nil)
var node2 = BinaryTree<Int>(2, leftNode: nil, rightNode: nil)
var node3 = BinaryTree<Int>(3, leftNode: nil, rightNode: nil)
node1.add(leftNode: node2)
node1.add(rightNode: node3)
var tmp = BinaryTree<Int>(4,leftNode:nil, rightNode:nil)
node2.add(leftNode: tmp)
print(node1)
print(node1.deep)
print(node1.leftDeep)
print(node1.rightDeep)
複製代碼

結果

疑問：

怎麼使用***struct***定義一顆二叉樹