二叉树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***定义一颗二叉树