Swift 如何“；绘制”；控制台中的二叉树？

如何在Swift中打印二叉树，以便输入

79561

按如下方式打印输出：

    7
   / \
  5   9
 / \
1   6

我尝试使用

For循环

和

If语句

来安排一些代码，但没有成功。 我的代码是：

import UIKit

//Variable "node" used only to arrange it in output.
var node = "0"
var space = " "
var linkLeft = "/"
var linkRight = "\\"
var str = "Hello, playground"

var height = 6
var width = height * 2 + 1

print()

//Height
for h in 1...height {
    //Width
    for w in 1...width {
        switch h {
        case 1:
            if(w == width/2 + h) {
                print(node, terminator: "")
            } else {
                print(space, terminator: "")
            }

            if (w == width) {
                print()
            }
        case 2:
            //print(linkLeft, terminator: "")
            if(w == width/3 + h) {
                print(linkLeft, terminator: "")
            } else if(w == width/3 + h + 4) {
                print(linkRight, terminator: "")
            } else {
                print(space, terminator: "")
            }

            if (w == width) {
                print()
            }
        case 3:
            if(w == width/5 + h) {
                print(node, terminator: "")
            } else if(w == width/h + h){
                print(node, terminator: "")
            } else {
                print(space, terminator: "")
            }

            if (w == width) {
                print()
            }
            break
        default:
            break
        }
    }
}

我试着用两个

表示循环，一个表示高度，另一个表示宽度。但是，如果节点数量发生变化，它将不起作用。目前，我只是试图安排
链接
（
/
和
\
）、
节点
和空格的位置，所以它不起作用。
有没有一种可能的方法可以做到这一点？
首先，您必须定义一个允许递归遍历树节点的层次树结构（类）。如何实现它并不重要，只要它能够提供描述性字符串并访问其左、右子节点

extension TreeNode
{       
   var asString:String { return treeString(self){("\($0.value)",$0.left,$0.right)}  }       
}

var root = TreeNode(7)

root.addValue(9)
root.addValue(5)
root.addValue(6)
root.addValue(1)

print(root.asString)

//     7
//    / \
//   5   9
//  / \
// 1   6
//

root = TreeNode(80)

root.addValue(50)
root.addValue(90)
root.addValue(10)
root.addValue(60)
root.addValue(30)
root.addValue(70)
root.addValue(55)
root.addValue(5)
root.addValue(35)
root.addValue(85)

print(root.asString)

//              80
//          ___/  \___
//        50          90
//     __/  \__      /
//   10        60  85
//  /  \      /  \
// 5    30  55    70
//        \
//         35
//

例如（我将其用于测试目的）：

[编辑]改进了逻辑，在右侧比左侧更深的树上使用更少的空间。清理代码并添加注释以解释其工作原理

//
//       12
//      /  \
//    10    50
//   /   __/  \__
//  5  30        90
//       \      /
//        35  70
//           /  \
//         60    85
//        /
//      55
//

//                12
//               /  \
//             10    30
//            /        \
//           5          90
//                     /
//                   85
//                  /
//                70
//               /
//             55
//            /
//          48
//         /
//       45
//      /
//    40
//   /
// 35
//

[EDIT2]对功能进行了一般性和适应性解释

使用泛型函数，数据甚至不需要处于实际的树结构中

例如，可以打印包含堆树的数组：

 extension Array
 {    
    func printHeapTree(reversed:Bool = false)
    {
       let tree = treeString( 0, reversed:reversed )
       {
          let left  = { $0 < self.count ? $0 : nil}($0 * 2 + 1)
          let right = { $0 < self.count ? $0 : nil}($0 * 2 + 2)
          return ( "\(self[$0])", left, right )
       }
       print(tree) 
    }
 }

let values = [7,5,9,1,6]
values.printHeapTree()

//     7
//    / \
//   5   9
//  / \
// 1   6

let family = [ "Me","Paul","Rosa","Vincent","Jody","John","Kate"]
family.printHeapTree()

//                Me
//            ___/  \___
//        Paul          Rosa
//        /  \          /  \
// Vincent    Jody  John    Kate

[EDIT3]添加了根据Emm的请求从示例类（TreeNode）中的树中排除重复项的条件

[EDIT4]更改了合并发布的公式，以便在实际项目中进行编译（当时正在操场上进行测试）

[EDIT5]对Swift4进行了一些小的调整，增加了打印反转树的功能，将数组示例更改为堆树。
您可以修改以下@Jean BaptisteYunès是的，但这是Java语言，我对Java和Swift都是初学者。因此，我很难从Java用Swift编写它。好吧，你需要（1）递归解析数据树（2）使用节点之间的距离，它是树中高度的函数，通常你可以使用的函数是2的幂（叶距离1，叶2的父，父4的父，等等）。严格来说，这是不可能的，在这段代码中，随着树的宽度线性增加，但必须绘制的节点数呈指数增长，如果我们添加两个或更多相同的值，这些值将在树上重复。所以这是错误的，并且这不会发生在
二叉搜索树中。示例类本身可以根据需要进行调整（例如，如果提供了现有值，则添加验证以不添加任何内容，并返回现有节点）。是，我编辑了答案，但您没有批准它。但它与数组有点混淆。在示例类中添加了“无重复”条件。数组示例旨在说明泛型函数的灵活性。我写这篇文章是为了其他人的利益，他们可能会发现这个问题（和答案），并且可能在他们的数据结构中有不同的需求。
//
//       12
//      /  \
//    10    50
//   /   __/  \__
//  5  30        90
//       \      /
//        35  70
//           /  \
//         60    85
//        /
//      55
//

//                12
//               /  \
//             10    30
//            /        \
//           5          90
//                     /
//                   85
//                  /
//                70
//               /
//             55
//            /
//          48
//         /
//       45
//      /
//    40
//   /
// 35
//

 extension Array
 {    
    func printHeapTree(reversed:Bool = false)
    {
       let tree = treeString( 0, reversed:reversed )
       {
          let left  = { $0 < self.count ? $0 : nil}($0 * 2 + 1)
          let right = { $0 < self.count ? $0 : nil}($0 * 2 + 2)
          return ( "\(self[$0])", left, right )
       }
       print(tree) 
    }
 }

let values = [7,5,9,1,6]
values.printHeapTree()

//     7
//    / \
//   5   9
//  / \
// 1   6

let family = [ "Me","Paul","Rosa","Vincent","Jody","John","Kate"]
family.printHeapTree()

//                Me
//            ___/  \___
//        Paul          Rosa
//        /  \          /  \
// Vincent    Jody  John    Kate

family.printHeapTree(reversed:true)

// Vincent    Jody  John    Kate
//        \  /          \  /
//        Paul          Rosa
//            ¯¯¯\  /¯¯¯
//                Me