當前位置：首頁 > 人工智能 > ChatGpt >内容正文

ChatGpt

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

發布時間：2023/12/24 ChatGpt 49 coder

生活随笔收集整理的這篇文章主要介紹了文心一言 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.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.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 (
<t>"fmt"
)

//定義樹
type BinaryTree struct {
<t>value int
<t>left, right *BinaryTree
}

//新樹
func NewBinaryTree(rootVal int) *BinaryTree {
<t>return &BinaryTree{value: rootVal, left: nil, right: nil}
}

//插入樹
func (bst *BinaryTree) Insert(val int) {
<t>if bst == nil || val < bst.value {
<t><t>bst.left = NewBinaryTree(val)
<t>} else if val > bst.value {
<t><t>bst.right = NewBinaryTree(val)
<t>} else {
<t><t>fmt.Println("錯誤：值必須在樹中")
<t><t>return
<t>}
<t>bst.value = val
}

func main() {
<t>//定義切片存放樹的元素
<t>array := []int{6, 3, 8, 2, 5, 1, 7}
<t>var bst *BinaryTree
<t>for _, v := range array {
<t><t>bst = bst.Insert(v)
<t>}

<t>fmt.Println("插入后的樹:")
<t>bst.PreOrder()
<t>fmt.Println()
<t>bst.InOrder()
<t>fmt.Println()
<t>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.Value {
		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.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.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.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.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 函數按順序遍歷二叉搜索樹并輸出其元素。這個函數也是一個遞歸函數，它按照左子樹 -> 當前節點 -> 右子樹的順序遍歷樹的節點。

總結

以上是生活随笔為你收集整理的文心一言 VS 讯飞星火 VS chatgpt （154）-- 算法导论12.3 1题的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇：东芝电视 Z870MF 上架：Mini
下一篇：文心一言 VS 讯飞星火 VS chat