文心一言 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函数按顺序遍历二叉搜索树并输出其元素。这个函数也是一个递归函数，它按照左子树 -> 当前节点 -> 右子树的顺序遍历树的节点。

在这里插入图片描述

在这里插入图片描述