文心一言 VS 讯飞星火 VS chatgpt （154）-- 算法导论12.3 1题

一、用go语言，给出 TREE-INSERT 过程的一个递归版本。

文心一言，代码不能运行：

下面是用 Go 语言实现一个递归版本的 TREE-INSERT 过程的代码：

packagemain
import"fmt"
typeTreeNodestruct{
Valint
Left*TreeNode
Right*TreeNode
}
funcinsert(root*TreeNode,valint)*TreeNode{
ifroot==nil{
return&TreeNode{Val:val,Left:nil,Right:nil}
}
ifvalroot.Left=insert(root.Left,val)
}elseifval>root.Val{
root.Right=insert(root.Right,val)
}
returnroot
}
funcinorderTraversal(root*TreeNode){
ifroot!=nil{
inorderTraversal(root.Left)
fmt.Println(root.Val)
inorderTraversal(root.Right)
}
}
funcmain(){
root:=nil
root=insert(root,5)
insert(root,3)
insert(root,7)
insert(root,1)
insert(root,9)
inorderTraversal(root)
}

在这个代码中，我们定义了一个 TreeNode 结构体来表示二叉树节点。insert 函数用于将一个值插入到二叉搜索树中，它采用递归的方式实现。如果当前节点为空，则创建一个新的节点作为根节点；否则，根据值的大小，递归地插入到左子树或右子树中。最后返回根节点。我们还定义了一个 inorderTraversal 函数来验证树的正确性，它会按照中序遍历的顺序打印出节点的值。在 main 函数中，我们创建了一个二叉搜索树，并插入了一些值。然后调用 inorderTraversal 函数来验证结果。

讯飞星火，代码正常运行：

packagemain
import(
"fmt"
)
typeTreeNodestruct{
Valueint
Left,Right*TreeNode
}
funcTreeInsert(root*TreeNode,valueint)*TreeNode{
ifroot==nil{
return&TreeNode{Value:value}
}
ifvalueroot.Left=TreeInsert(root.Left,value)
}elseifvalue>root.Value{
root.Right=TreeInsert(root.Right,value)
}
returnroot
}
funcmain(){
root:=&TreeNode{Value:50}
root=TreeInsert(root,30)
root=TreeInsert(root,70)
root=TreeInsert(root,20)
root=TreeInsert(root,40)
root=TreeInsert(root,60)
root=TreeInsert(root,80)
fmt.Println("树的结构：")
printInOrder(root)
}
funcprintInOrder(node*TreeNode){
ifnode!=nil{
printInOrder(node.Left)
fmt.Printf("%d",node.Value)
printInOrder(node.Right)
}
}

360智脑：

以下是一个递归版本的 TREE-INSERT 过程：

packagemain
import(
"fmt"
)
//定义树
typeBinaryTreestruct{
valueint
left,right*BinaryTree
}
//新树
funcNewBinaryTree(rootValint)*BinaryTree{
return&BinaryTree{value:rootVal,left:nil,right:nil}
}
//插入树
func(bst*BinaryTree)Insert(valint){
ifbst==nil||valbst.left=NewBinaryTree(val)
}elseifval>bst.value{
bst.right=NewBinaryTree(val)
}else{
fmt.Println("错误：值必须在树中")
return
}
bst.value=val
}
funcmain(){
//定义切片存放树的元素
array:=[]int{6,3,8,2,5,1,7}
varbst*BinaryTree
for_,v:=rangearray{
bst=bst.Insert(v)
}
fmt.Println("插入后的树:")
bst.PreOrder()
fmt.Println()
bst.InOrder()
fmt.Println()
bst.PostOrder()
}

智谱清言，代码不能运行：

在计算机科学中，二叉搜索树（BST）是一种特殊的二叉树，它具有以下性质：

• •每个节点都有一个作为关键字的值，该值唯一存在于树中。
• •左子树上所有节点的值均小于它的根节点的值。
• •右子树上所有节点的值均大于它的根节点的值。

过程是在 BST 中插入一个新值的过程。这里给出一个用 Go 语言编写的递归版本的过程：

TREE-INSERT

TREE-INSERT

packagemain
import(
"fmt"
)
typeTreeNodestruct{
Valueint
Left*TreeNode
Right*TreeNode
}
//TREE-INSERT过程的递归版本
functreeInsert(t*TreeNode,keyint)*TreeNode{
//如果当前节点是nil（即到达了树的末端），则创建一个新节点
ift==nil{
return&TreeNode{Value:key}
}
//如果新键值小于当前节点的键值，则在左子树中递归插入
ifkeyt.Left=treeInsert(t.Left,key)
}elseifkey>t.Value{//如果新键值大于当前节点的键值，则在右子树中递归插入
t.Right=treeInsert(t.Right,key)
}
//返回当前节点（可能已经更新）
returnt
}
funcmain(){
//创建一个空的二叉搜索树
root:=nil
//向树中插入一些键值
root=treeInsert(root,5)
root=treeInsert(root,3)
root=treeInsert(root,8)
root=treeInsert(root,1)
root=treeInsert(root,4)
root=treeInsert(root,6)
root=treeInsert(root,9)
root=treeInsert(root,2)
root=treeInsert(root,7)
//以inorder遍历的方式打印树，验证是否正确插入
varinorderfunc(t*TreeNode)
inorder=func(t*TreeNode){
ift==nil{
return
}
inorder(t.Left)
fmt.Println(t.Value)
inorder(t.Right)
}
//开始inorder遍历
inorder(root)
}

在这个代码中，函数以递归方式向 BST 中插入一个新值。如果当前节点是，它将返回一个新节点。如果新值小于当前节点的值，它将在左子树中递归插入，如果新值大于当前节点的值，它将在右子树中递归插入。函数中展示了如何使用函数，并通过 inorder 遍历打印出树的键值，以验证插入是否正确。

treeInsert

nil

main

treeInsert

通义千问，代码正常运行：

在 Go 语言中，你可以使用递归来实现过程。这里是一个简单的示例，假设你有一个名为的结构体表示二叉搜索树（BST）的节点，并且该结构体包含一个指向左子节点和右子节点的指针以及一个值。

TREE-INSERT

Tree

packagemain
import"fmt"
typeTreestruct{
valueint
left*Tree
right*Tree
}
//RecursiveTREE_INSERTfunction
functreeInsert(root**Tree,z*Tree){
if*root==nil{
*root=z
return
}
//Comparethenewnode'svaluewiththecurrentroot'svalue
if(*root).value>z.value{
//Ifthenewnode'svalueissmaller,insertintotheleftsubtree
treeInsert(&(*root).left,z)
}else{
//Ifthenewnode'svalueislargerorequal,insertintotherightsubtree
treeInsert(&(*root).right,z)
}
}
funcmain(){
varroot*Tree
z:=&Tree{value:10}
treeInsert(&root,z)
y:=&Tree{value:5}
treeInsert(&root,y)
x:=&Tree{value:15}
treeInsert(&root,x)
fmt.Println("In-ordertraversal:")
inorderTraversal(root)
}
//Helperfunctiontoprintin-ordertraversalofabinarysearchtree
funcinorderTraversal(t*Tree){
ift!=nil{
inorderTraversal(t.left)
fmt.Printf("%d",t.value)
inorderTraversal(t.right)
}
}

在这个例子中，我们首先定义了一个结构体来表示二叉搜索树的节点。接下来，我们实现了函数，它接受一个指向树根的指针和一个新的节点。函数通过比较新节点的值与当前根节点的值来决定将新节点插入到左子树还是右子树。如果当前根为空，那么新节点就成为新的根节点。

Tree

treeInsert

z

在函数中，我们创建了一个空的根节点，并使用函数插入了几个新节点。最后，我们调用了一个辅助函数来打印出二叉搜索树的中序遍历结果。

main

treeInsert

inorderTraversal

请注意，这个示例仅用于演示如何使用递归实现过程。在实际应用中，你需要根据你的具体需求对代码进行调整。

TREE-INSERT

天工：

好的，以下是一个使用 Go 语言实现的 TREE-INSERT 过程的递归版本：

funcTREE_INSERT(root*Node,z*Node)*Node{
//如果根节点为空，则创建一个新节点作为根节点
ifroot==nil{
root=&Node{key:z.key,val:z.val}
returnroot
}
//如果根节点的键小于z的键
ifroot.key//将z插入到根节点的左子树中
root.left=TREE_INSERT(root.left,z)
returnroot
}
//如果根节点的键等于z的键
root.right=TREE_INSERT(root.right,z)
//返回根节点
returnroot
}

其中，结构体定义如下：

Node

typeNodestruct{
keyint
valint
left*Node
right*Node
}

该递归版本的实现思路与参考信息中的伪代码基本一致。当递归到叶子节点时，返回的根节点即为最后一个插入的元素。

灵小智，代码正常运行：

以下是一个用Go语言编写的递归版本的TREE-INSERT过程示例：

packagemain
import"fmt"
typeNodestruct{
keyint
left*Node
right*Node
}
funcinsert(root*Node,keyint)*Node{
ifroot==nil{
root=&Node{key:key,left:nil,right:nil}
returnroot
}
ifkeyroot.left=insert(root.left,key)
}elseifkey>root.key{
root.right=insert(root.right,key)
}
returnroot
}
funcinorder(root*Node){
ifroot!=nil{
inorder(root.left)
fmt.Printf("%d",root.key)
inorder(root.right)
}
}
funcmain(){
varroot*Node
keys:=[]int{15,10,20,8,12,18,25}
for_,key:=rangekeys{
root=insert(root,key)
}
fmt.Println("Inordertraversalofthebinarysearchtree:")
inorder(root)
}

以上代码定义了一个名为的结构体，表示二叉搜索树中的节点。函数是一个递归函数，用于插入一个新的键值到二叉搜索树中。函数用于按照中序遍历的顺序输出二叉搜索树中的节点。

Node

insert

inorder

在函数中，我们创建一个空的二叉搜索树，并依次插入一些键值。最后，调用函数打印二叉搜索树的中序遍历结果。

main

inorder

请注意，这只是一个示例，并没有涉及错误处理和其他边界情况的处理。实际使用时，您可能需要进行适当的错误处理和鲁棒性改进。

chatgpt：

以下是一个使用递归实现的TREE-INSERT过程的示例代码（假设节点数据类型为整数）：

typeNodestruct{
keyint
left*Node
right*Node
}
funcinsert(root*Node,keyint)*Node{
ifroot==nil{
return&Node{key:key}
}
ifkeyroot.left=insert(root.left,key)
}elseifkey>root.key{
root.right=insert(root.right,key)
}
returnroot
}

你可以将上述代码中的函数作为TREE-INSERT过程的递归版本。它会接收一个二叉搜索树的根节点和要插入的关键字作为参数，然后在树中递归地插入新节点，最终返回更新后的根节点。

insert

kimi，抛panic：

在 Go 语言中，我们可以实现一个递归版本的 TREE-INSERT 过程。以下是一个简单的实现：

packagemain
typeNodestruct{
keyinterface{}//可以是任何可比较的数据类型，如int、string等
left*Node
right*Node
}
func(n*Node)TreeInsert(keyinterface{})*Node{
ifn==nil{
return&Node{key:key}
}
ifkey.(int)n.left=n.left.TreeInsert(key)
}else{
n.right=n.right.TreeInsert(key)
}
returnn
}
funcmain(){
root:=&Node{}
keys:=[]int{8,3,10,1,6,14,4,7,13}
for_,key:=rangekeys{
root=root.TreeInsert(key)
}
//中序遍历（左子树->当前节点->右子树），输出二叉搜索树的元素
inOrderTraversal(root)
}
funcinOrderTraversal(n*Node){
ifn!=nil{
inOrderTraversal(n.left)
fmt.Println(n.key)
inOrderTraversal(n.right)
}
}

在这个实现中，我们首先定义了一个结构体，表示二叉搜索树的节点。方法是一个递归方法，它接受一个关键字作为参数。当树为空时，我们创建一个新的节点。然后，我们根据给定的关键字与当前节点的关键字的大小关系，将其插入到左子树或右子树中。

Node

TreeInsert

在函数中，我们创建了一个空的根节点，并插入了一些整数。然后，我们使用函数按顺序遍历二叉搜索树并输出其元素。这个函数也是一个递归函数，它按照左子树 -> 当前节点 -> 右子树的顺序遍历树的节点。

main

inOrderTraversal