文心一言 VS 讯飞星火 VS chatgpt （154）-- 算法导论12.3 1题
一、用go语言，给出 TREE-INSERT 过程的一个递归版本。
文心一言，代码不能运行：
下面是用 Go 语言实现一个递归版本的 TREE-INSERT 过程的代码：
package?main
import?"fmt"
type?TreeNode?struct?{
Val???int
Left??*TreeNode
Right?*TreeNode
}
func?insert(root?*TreeNode,?val?int)?*TreeNode?{
if?root?==?nil?{
return?&TreeNode{Val:?val,?Left:?nil,?Right:?nil}
}
if?val?
root.Left?=?insert(root.Left,?val)
}?else?if?val?>?root.Val?{
root.Right?=?insert(root.Right,?val)
}
return?root
}
func?inorderTraversal(root?*TreeNode)?{
if?root?!=?nil?{
inorderTraversal(root.Left)
fmt.Println(root.Val)
inorderTraversal(root.Right)
}
}
func?main()?{
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 函数来验证结果。
在这里插入图片描述
在这里插入图片描述讯飞星火，代码正常运行：
package?main
import?(
"fmt"
)
type?TreeNode?struct?{
Value???????int
Left,?Right?*TreeNode
}
func?TreeInsert(root?*TreeNode,?value?int)?*TreeNode?{
if?root?==?nil?{
return?&TreeNode{Value:?value}
}
if?value?
root.Left?=?TreeInsert(root.Left,?value)
}?else?if?value?>?root.Value?{
root.Right?=?TreeInsert(root.Right,?value)
}
return?root
}
func?main()?{
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)
}
func?printInOrder(node?*TreeNode)?{
if?node?!=?nil?{
printInOrder(node.Left)
fmt.Printf("%d?",?node.Value)
printInOrder(node.Right)
}
}
在这里插入图片描述
在这里插入图片描述360智脑：
以下是一个递归版本的 TREE-INSERT 过程：
package?main
import?(
"fmt"
)
//定义树
type?BinaryTree?struct?{
value?int
left,?right?*BinaryTree
}
//新树
func?NewBinaryTree(rootVal?int)?*BinaryTree?{
return?&BinaryTree{value:?rootVal,?left:?nil,?right:?nil}
}
//插入树
func?(bst?*BinaryTree)?Insert(val?int)?{
if?bst?==?nil?||?val?
bst.left?=?NewBinaryTree(val)
}?else?if?val?>?bst.value?{
bst.right?=?NewBinaryTree(val)
}?else?{
fmt.Println("错误：值必须在树中")
return
}
bst.value?=?val
}
func?main()?{
//定义切片存放树的元素
array?:=?[]int{6,?3,?8,?2,?5,?1,?7}
var?bst?*BinaryTree
for?_,?v?:=?range?array?{
bst?=?bst.Insert(v)
}
fmt.Println("插入后的树:")
bst.PreOrder()
fmt.Println()
bst.InOrder()
fmt.Println()
bst.PostOrder()
}
在这里插入图片描述
在这里插入图片描述智谱清言，代码不能运行：
在计算机科学中，二叉搜索树（BST）是一种特殊的二叉树，它具有以下性质：
??每个节点都有一个作为关键字的值，该值唯一存在于树中。
??左子树上所有节点的值均小于它的根节点的值。
??右子树上所有节点的值均大于它的根节点的值。
TREE-INSERT过程是在 BST 中插入一个新值的过程。这里给出一个用 Go 语言编写的递归版本的TREE-INSERT过程：
package?main
import?(
"fmt"
)
type?TreeNode?struct?{
Value?int
Left??*TreeNode
Right?*TreeNode
}
//?TREE-INSERT?过程的递归版本
func?treeInsert(t?*TreeNode,?key?int)?*TreeNode?{
//?如果当前节点是nil（即到达了树的末端），则创建一个新节点
if?t?==?nil?{
return?&TreeNode{Value:?key}
}
//?如果新键值小于当前节点的键值，则在左子树中递归插入
if?key?
t.Left?=?treeInsert(t.Left,?key)
}?else?if?key?>?t.Value?{?//?如果新键值大于当前节点的键值，则在右子树中递归插入
t.Right?=?treeInsert(t.Right,?key)
}
//?返回当前节点（可能已经更新）
return?t
}
func?main()?{
//?创建一个空的二叉搜索树
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?遍历的方式打印树，验证是否正确插入
var?inorder?func(t?*TreeNode)
inorder?=?func(t?*TreeNode)?{
if?t?==?nil?{
return
}
inorder(t.Left)
fmt.Println(t.Value)
inorder(t.Right)
}
//?开始?inorder?遍历
inorder(root)
}
在这个代码中，treeInsert函数以递归方式向 BST 中插入一个新值。如果当前节点是nil，它将返回一个新节点。如果新值小于当前节点的值，它将在左子树中递归插入，如果新值大于当前节点的值，它将在右子树中递归插入。main函数中展示了如何使用treeInsert函数，并通过 inorder 遍历打印出树的键值，以验证插入是否正确。
在这里插入图片描述
在这里插入图片描述通义千问，代码正常运行：
在 Go 语言中，你可以使用递归来实现TREE-INSERT过程。这里是一个简单的示例，假设你有一个名为Tree的结构体表示二叉搜索树（BST）的节点，并且该结构体包含一个指向左子节点和右子节点的指针以及一个值。
package?main
import?"fmt"
type?Tree?struct?{
value?int
left??*Tree
right?*Tree
}
//?Recursive?TREE_INSERT?function
func?treeInsert(root?**Tree,?z?*Tree)?{
if?*root?==?nil?{
*root?=?z
return
}
//?Compare?the?new?node's?value?with?the?current?root's?value
if?(*root).value?>?z.value?{
//?If?the?new?node's?value?is?smaller,?insert?into?the?left?subtree
treeInsert(&(*root).left,?z)
}?else?{
//?If?the?new?node's?value?is?larger?or?equal,?insert?into?the?right?subtree
treeInsert(&(*root).right,?z)
}
}
func?main()?{
var?root?*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-order?traversal:")
inorderTraversal(root)
}
//?Helper?function?to?print?in-order?traversal?of?a?binary?search?tree
func?inorderTraversal(t?*Tree)?{
if?t?!=?nil?{
inorderTraversal(t.left)
fmt.Printf("%d?",?t.value)
inorderTraversal(t.right)
}
}
在这个例子中，我们首先定义了一个Tree结构体来表示二叉搜索树的节点。接下来，我们实现了treeInsert函数，它接受一个指向树根的指针和一个新的节点z。函数通过比较新节点的值与当前根节点的值来决定将新节点插入到左子树还是右子树。如果当前根为空，那么新节点就成为新的根节点。
在main函数中，我们创建了一个空的根节点，并使用treeInsert函数插入了几个新节点。最后，我们调用了一个辅助函数inorderTraversal来打印出二叉搜索树的中序遍历结果。
请注意，这个示例仅用于演示如何使用递归实现TREE-INSERT过程。在实际应用中，你需要根据你的具体需求对代码进行调整。
在这里插入图片描述
在这里插入图片描述天工：
好的，以下是一个使用 Go 语言实现的 TREE-INSERT 过程的递归版本：
func?TREE_INSERT(root?*Node,?z?*Node)?*Node?{
//?如果根节点为空，则创建一个新节点作为根节点
if?root?==?nil?{
root?=?&Node{key:?z.key,?val:?z.val}
return?root
}
//?如果根节点的键小于?z?的键
if?root.key?
//?将?z?插入到根节点的左子树中
root.left?=?TREE_INSERT(root.left,?z)
return?root
}
//?如果根节点的键等于?z?的键
root.right?=?TREE_INSERT(root.right,?z)
//?返回根节点
return?root
}
其中，Node结构体定义如下：
type?Node?struct?{
key?int
val?int
left?*Node
right?*Node
}
该递归版本的实现思路与参考信息中的伪代码基本一致。当递归到叶子节点时，返回的根节点即为最后一个插入的元素。
在这里插入图片描述在这里插入图片描述灵小智，代码正常运行：
以下是一个用Go语言编写的递归版本的TREE-INSERT过程示例：
package?main
import?"fmt"
type?Node?struct?{
key???int
left??*Node
right?*Node
}
func?insert(root?*Node,?key?int)?*Node?{
if?root?==?nil?{
root?=?&Node{key:?key,?left:?nil,?right:?nil}
return?root
}
if?key?
root.left?=?insert(root.left,?key)
}?else?if?key?>?root.key?{
root.right?=?insert(root.right,?key)
}
return?root
}
func?inorder(root?*Node)?{
if?root?!=?nil?{
inorder(root.left)
fmt.Printf("%d?",?root.key)
inorder(root.right)
}
}
func?main()?{
var?root?*Node
keys?:=?[]int{15,?10,?20,?8,?12,?18,?25}
for?_,?key?:=?range?keys?{
root?=?insert(root,?key)
}
fmt.Println("Inorder?traversal?of?the?binary?search?tree:")
inorder(root)
}
以上代码定义了一个名为Node的结构体，表示二叉搜索树中的节点。insert函数是一个递归函数，用于插入一个新的键值到二叉搜索树中。inorder函数用于按照中序遍历的顺序输出二叉搜索树中的节点。
在main函数中，我们创建一个空的二叉搜索树，并依次插入一些键值。最后，调用inorder函数打印二叉搜索树的中序遍历结果。
请注意，这只是一个示例，并没有涉及错误处理和其他边界情况的处理。实际使用时，您可能需要进行适当的错误处理和鲁棒性改进。
在这里插入图片描述
在这里插入图片描述chatgpt：
以下是一个使用递归实现的TREE-INSERT过程的示例代码（假设节点数据类型为整数）：
type?Node?struct?{
key???int
left??*Node
right?*Node
}
func?insert(root?*Node,?key?int)?*Node?{
if?root?==?nil?{
return?&Node{key:?key}
}
if?key?
root.left?=?insert(root.left,?key)
}?else?if?key?>?root.key?{
root.right?=?insert(root.right,?key)
}
return?root
}
你可以将上述代码中的insert函数作为TREE-INSERT过程的递归版本。它会接收一个二叉搜索树的根节点和要插入的关键字作为参数，然后在树中递归地插入新节点，最终返回更新后的根节点。
在这里插入图片描述kimi，抛panic：
在 Go 语言中，我们可以实现一个递归版本的 TREE-INSERT 过程。以下是一个简单的实现：
package?main
type?Node?struct?{
key???interface{}?//?可以是任何可比较的数据类型，如?int、string?等
left??*Node
right?*Node
}
func?(n?*Node)?TreeInsert(key?interface{})?*Node?{
if?n?==?nil?{
return?&Node{key:?key}
}
if?key.(int)?
n.left?=?n.left.TreeInsert(key)
}?else?{
n.right?=?n.right.TreeInsert(key)
}
return?n
}
func?main()?{
root?:=?&Node{}
keys?:=?[]int{8,?3,?10,?1,?6,?14,?4,?7,?13}
for?_,?key?:=?range?keys?{
root?=?root.TreeInsert(key)
}
//?中序遍历（左子树?->?当前节点?->?右子树），输出二叉搜索树的元素
inOrderTraversal(root)
}
func?inOrderTraversal(n?*Node)?{
if?n?!=?nil?{
inOrderTraversal(n.left)
fmt.Println(n.key)
inOrderTraversal(n.right)
}
}
在这个实现中，我们首先定义了一个Node结构体，表示二叉搜索树的节点。TreeInsert方法是一个递归方法，它接受一个关键字作为参数。当树为空时，我们创建一个新的节点。然后，我们根据给定的关键字与当前节点的关键字的大小关系，将其插入到左子树或右子树中。
在main函数中，我们创建了一个空的根节点，并插入了一些整数。然后，我们使用inOrderTraversal函数按顺序遍历二叉搜索树并输出其元素。这个函数也是一个递归函数，它按照左子树 -> 当前节点 -> 右子树的顺序遍历树的节点。
在这里插入图片描述
在这里插入图片描述
- 发表于:
- 原文链接：https://page.om.qq.com/page/OmxiwvwbulcvlXo4QKKG9F0Q0
- 腾讯「腾讯云开发者社区」是腾讯内容开放平台帐号（企鹅号）传播渠道之一，根据《腾讯内容开放平台服务协议》转载发布内容。
- 如有侵权，请联系 cloudcommunity@tencent.com 删除。
相关快讯
扫码
添加站长 进交流群
领取专属 10元无门槛券
私享最新 技术干货
腾讯云开发者
