是否同一棵二叉搜索树——Swift

是否同一棵二叉搜索树(Swift)

给定一个插入序列就可以唯一确定一棵二叉搜索树。然而，一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树，都得到一样的结果。于是对于输入的各种插入序列，你需要判断它们是否能生成一样的二叉搜索树。

输入格式:

输入包含若干组测试数据。每组数据的第1行给出两个正整数N (≤10)和L，分别是每个序列插入元素的个数和需要检查的序列个数。第2行给出N个以空格分隔的正整数，作为初始插入序列。最后L行，每行给出N个插入的元素，属于L个需要检查的序列。

简单起见，我们保证每个插入序列都是1到N的一个排列。当读到N为0时，标志输入结束，这组数据不要处理。

输出格式:

对每一组需要检查的序列，如果其生成的二叉搜索树跟对应的初始序列生成的一样，输出“Yes”，否则输出“No”。

输入样例:

4 2
3 1 4 2
3 4 1 2
3 2 4 1
2 1
2 1
1 2
0

输出样例:

Yes
No
No

代码：

//
//  main.swift
//  BinarySerchTree
//
//  Created by 陈汉超 on 2021/8/2.
//

import Foundation
let null = -1
class TreeNode{
    var data: Int
    var Left: TreeNode?
    var Right: TreeNode?
    init(_ Data:Int) {
        self.data = Data
    }
}


func CreatTree(_ Tree: inout TreeNode,_ Data: Int){
    if Tree.data == null {
        Tree.data = Data
        Tree.Left = nil
        Tree.Right = nil
    }else if Data < Tree.data {
        if Tree.Left == nil {
            let newnode = TreeNode.init(null)
            Tree.Left = newnode
            CreatTree(&Tree.Left!, Data)
        }else{
            CreatTree(&Tree.Left!, Data)
        }
    }else if Data > Tree.data{
        if Tree.Right == nil {
            let newnode = TreeNode.init(null)
            Tree.Right = newnode
            CreatTree(&Tree.Right!, Data)
        }else{
            CreatTree(&Tree.Right!, Data)
        }
    }
}

func TreePrint(_ Tree: TreeNode,_ arr: inout [Int]){
    if Tree.data != null {
        arr.append(Tree.data)
    }
    if Tree.Left != nil {
        TreePrint(Tree.Left!,&arr)
    }
    if Tree.Right != nil {
        TreePrint(Tree.Right!,&arr)
    }
}

while true{
    let n = readLine()
    guard n != "0" else{
       break
    }
    var TreeArr = [TreeNode]()
    var Arr = [[Int]]()
    var judge = [[Int]]()
    let n1 = n!.components(separatedBy: CharacterSet.whitespaces).map{Int($0)}
    for _ in 0...n1[1]!{
        TreeArr.append(TreeNode(null))
    }
    for _ in 0...n1[1]!{
        let t = readLine()!.components(separatedBy: CharacterSet.whitespaces).map{Int($0)!}
        Arr.append(t)
    }
    for _ in 0...n1[1]!{
        judge.append([Int]())
    }
    for i in TreeArr.indices{
        for j in 0..<n1[0]!{
            CreatTree(&TreeArr[i], Arr[i][j])
        }
    }
    for i in TreeArr.indices{
        TreePrint(TreeArr[i], &judge[i])
    }
    for i in judge.indices{
        if i == 0 {
            continue
        }
        if judge[i] == judge[0]{
            print("Yes")
        }else{
            print("No")
        }
    }
}

 以上是swift编写的是否为同一颗二叉搜索树的算法。