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

ChatGpt

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

發布時間：2023/11/25 ChatGpt 131 coder

生活随笔收集整理的這篇文章主要介紹了文心一言 VS 讯飞星火 VS chatgpt （141）-- 算法导论12.1 1题小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

一、用go語言，對于關鍵字集合(1，4，5，10，16，17，21)，分別畫出高度為 2、3、4、5和6的二又搜索樹。

文心一言：

以下是用Go語言為給定的關鍵字集合(1, 4, 5, 10, 16, 17, 21)生成的高度為2、3、4、5和6的二叉搜索樹。

由于二叉搜索樹的形狀對于不同的生成方式可能會有所不同，所以我這里給出的是一種可能的形狀。為了方便展示，我將節點按照從上到下、從左到右的順序進行排列。

首先，定義一個二叉樹節點的結構：

type Node struct {  
    Key   int  
    Left  *Node  
    Right *Node  
}
然后，我們可以使用遞歸的方式生成二叉搜索樹：

go
func insertNode(root *Node, key int) *Node {  
    if root == nil {  
        return &Node{Key: key}  
    }  
  
    if key < root.Key {  
        root.Left = insertNode(root.Left, key)  
    } else if key > root.Key {  
        root.Right = insertNode(root.Right, key)  
    }  
  
    return root  
}

接下來，我們可以使用給定的關鍵字集合，生成不同高度的二叉搜索樹：

func generateBinarySearchTree(keys []int, height int) *Node {  
    if height == 1 {  
        return insertNode(nil, keys[0])  
    }  
  
    leftKeys := make([]int, 0)  
    rightKeys := make([]int, 0)  
  
    for _, key := range keys {  
        if key < keys[height-1] {  
            leftKeys = append(leftKeys, key)  
        } else {  
            rightKeys = append(rightKeys, key)  
        }  
    }  
  
    root := &Node{Key: keys[height-1]}  
    root.Left = generateBinarySearchTree(leftKeys, height-1)  
    root.Right = generateBinarySearchTree(rightKeys, height-1)  
  
    return root  
}

最后，我們可以調用 generateBinarySearchTree 函數生成不同高度的二叉搜索樹：

func main() {  
    keys := []int{1, 4, 5, 10, 16, 17, 21}  
    trees := make([]*Node, 6)  
  
    for i := 2; i <= 6; i++ {  
        trees[i-2] = generateBinarySearchTree(keys, i)  
    }  
}

訊飛星火，代碼正常運行：

首先，我們需要定義一個二叉搜索樹的結構體，然后實現插入和遍歷的方法。接下來，我們將使用給定的關鍵字集合創建不同的二又搜索樹，并繪制它們的高度為2、3、4、5和6的情況。

解析：

1.定義二叉搜索樹結構體

2.實現插入方法

3.實現遍歷方法

4.根據給定的關鍵字集合創建二又搜索樹

5.繪制二又搜索樹的高度為2、3、4、5和6的情況

代碼如下：

package main

import (
	"fmt"
)

type TreeNode struct {
	Key   int
	Left  *TreeNode
	Right *TreeNode
}

func NewTreeNode(key int) *TreeNode {
	return &TreeNode{Key: key}
}

func (t *TreeNode) Insert(key int) {
	if key < t.Key {
		if t.Left == nil {
			t.Left = NewTreeNode(key)
		} else {
			t.Left.Insert(key)
		}
	} else if key > t.Key {
		if t.Right == nil {
			t.Right = NewTreeNode(key)
		} else {
			t.Right.Insert(key)
		}
	}
}

func (t *TreeNode) InOrderTraversal() []int {
	var result []int
	if t.Left != nil {
		result = append(result, t.Left.InOrderTraversal()...)
	}
	result = append(result, t.Key)
	if t.Right != nil {
		result = append(result, t.Right.InOrderTraversal()...)
	}
	return result
}

func main() {
	keywords := []int{1, 4, 5, 10, 16, 17, 21}
	trees := make([]*TreeNode, len(keywords))

	for i, key := range keywords {
		trees[i] = NewTreeNode(key)
		for j := 0; j < i; j++ {
			trees[i].Insert(keywords[j])
		}
	}

	for i, tree := range trees {
		fmt.Printf("Height %d: %v
", i+2, tree.InOrderTraversal())
	}
}

運行上述代碼，將輸出不同高度的二又搜索樹的中序遍歷結果。

360智腦，代碼不能運行：

抱歉，我無法直接繪制圖形。但是，我可以向您解釋如何在Go中實現一個二叉搜索樹并插入給定的關鍵字集合。

以下是一個使用Go語言實現的二叉搜索樹的示例代碼：

package main

import (
    "fmt"
)

type Node struct {
    Value int
    left *Node
    right *Node
}

func CreateNode(value int) *Node {
    return &Node{value, nil, nil}
}

func InOrder(node *Node) {
    if node != nil {
        InOrder(node.Left)
        fmt.Println(node.Value)
        InOrder(node.Right)
    }
}

func Insert(node *Node, value int) bool {
    if node == nil {
        node = CreateNode(value)
        return true
    }
    var parent *Node = nil
    var cur *Node = node
    for cur != nil {
        if cur.Value < value {
            parent = cur
            cur = cur.Left
        } else if cur.Value > value {
            parent = cur
            cur = cur.Right
        } else {
            return false
        }
    }
    parent.Value = value
    InOrder(node)
    return true
}

func main() {
    nodes := []Node{}
    for i := 1; i <= 21; i++ {
        nodes = append(nodes, CreateNode(i))
    }
    fmt.Println("Nodes:", nodes)
    for i, node := range nodes {
        fmt.Printf("Node %d: %v\n", i, node)
        Insert(node, 4)
        Insert(node, 5)
        Insert(node, 10)
        Insert(node, 16)
        Insert(node, 17)
        Insert(node, 21)
    }
}

該代碼首先創建了一個空的二叉搜索樹，然后通過插入節點來填充它。對于給定關鍵字集合，可以調用Insert方法將其插入樹中。最后，使用main方法遍歷整個樹并打印每個節點。

要繪制高度為2、3、4、5和6的二叉搜索樹，您需要根據樹的結構手動創建節點，然后使用圖形化工具將它們繪制出來。由于樹的高度不同，因此您需要對每個節點進行適當的調整以使其在視覺上看起來平衡。

智譜清言：

以下是使用Go語言編寫的代碼，用于構建高度為2、3、4、5和6的二叉搜索樹。首先，我們定義了一個結構體來表示節點：

type Node struct {
	Key   int
	Left  *Node
	Right *Node
}

接下來，我們分別創建高度為2、3、4、5和6的二叉搜索樹：

func BuildTree(height int) *Node {
	if height == 1 {
		return &Node{Key: 1}
	}
	root := &Node{Key: 1}
	root.Left = BuildTree(height-1)
	root.Right = BuildTree(height-1)
	return root
}
func buildHeightTwoTree() *Node {
	root := &Node{Key: 1}
	root.Left = &Node{Key: 4}
	root.Right = &Node{Key: 5}
	root.Left.Left = &Node{Key: 1}
	root.Left.Right = &Node{Key: 3}
	root.Right.Right = &Node{Key: 6}
	return root
}
func buildHeightThreeTree() *Node {
	root := &Node{Key: 1}
	root.Left = &Node{Key: 4}
	root.Right = &Node{Key: 5}
	root.Left.Left = &Node{Key: 1}
	root.Left.Right = &Node{Key: 3}
	root.Right.Right = &Node{Key: 6}
	root.Left.Left.Left = &Node{Key: 2}
	root.Left.Left.Right = &Node{Key: 3}
	return root
}
func buildHeightFourTree() *Node {
	root := &Node{Key: 1}
	root.Left = &Node{Key: 4}
	root.Right = &Node{Key: 5}
	root.Left.Left = &Node{Key: 1}
	root.Left.Right = &Node{Key: 3}
	root.Right.Right = &Node{Key: 6}
	root.Left.Left.Left = &Node{Key: 2}
	root.Left.Left.Right = &Node{Key: 3}
	root.Right.Left = &Node{Key: 7}
	root.Right.Left.Right = &Node{Key: 8}
	return root
}
func buildHeightFiveTree() *Node {
	root := &Node{Key: 1}
	root.Left = &Node{Key: 4}
	root.Right = &Node{Key: 5}
	root.Left.Left = &Node{Key: 1}
	root.Left.Right = &Node{Key: 3}
	root.Right.Right = &Node{Key: 6}
	root.Left.Left.Left = &Node{Key: 2}
	root.Left.Left.Right = &Node{Key: 3}
	root.Right.Left = &Node{Key: 7}
	root.Right.Left.Right = &Node{Key: 8}
	root.Right.Left.Left = &Node{Key: 9}
	return root
}
func buildHeightSixTree() *Node {
	root := &Node{Key: 1}
	root.Left = &Node{Key: 4}
	root.Right = &Node{Key: 5}
	root.Left.Left = &Node{Key: 1}
	root.Left.Right = &Node{Key: 3}
	root.Right.Right = &Node{Key: 6}
	root.Left.Left.Left = &Node{Key: 2}
	root.Left.Left.Right = &Node{Key: 3}
	root.Right.Left = &Node{Key: 7}
	root.Right.Left.Right = &Node{Key: 8}
	root.Right.Left.Left = &Node{Key: 9}
	root.Right.Left.Left.Left = &Node{Key: 10}
	root.Right.Left.Left.Right = &Node{Key: 11}

通義千問：

很抱歉，我無法直接在這里為你畫出二叉搜索樹，但我可以告訴你如何使用Go語言來創建這樣的樹。

首先，在Go中沒有內建的數據結構可以直接用來創建一個二叉搜索樹（BST）。但你可以自己定義一個數據結構來實現它。一個簡單的BST節點可能如下所示：

type Node struct {
    Val int
    Left *Node
    Right *Node
}

然后你需要定義一些方法來插入元素到這個樹中，并保持其二叉搜索樹的特性。例如，一個基本的插入函數可能如下所示：

func insert(root **Node, val int) {
    if *root == nil {
        *root = &Node{Val: val}
    } else if (*root).Val > val {
        insert(&(*root).Left, val)
    } else {
        insert(&(*root).Right, val)
    }
}

有了這些基礎，你現在可以創建一個根為空的新樹，然后使用上述插入函數將給定的關鍵字添加到樹中。為了確保得到不同高度的樹，你可以根據需要調整插入順序。

注意，不同的插入順序可能導致生成不同的樹，即使它們具有相同的高度。這是因為二叉搜索樹是動態查找樹，它們的形狀取決于輸入的數據分布。

天工，代碼不能運行：

以下是用Go語言繪制高度為2、3、4、5和6的二叉搜索樹的示例代碼：

package main

import (
	"fmt"
	"strconv"
)

type Node struct {
	key       int
	leftChild *Node
	rightChild *Node
}

func NewNode(key int) *Node {
	return &Node{
		key: key,
	}
}

func (n *Node) IsLeaf() bool {
	return n.leftChild == nil && n.rightChild == nil
}

func (n *Node) IsInternalNode() bool {
	return n.leftChild != nil || n.rightChild != nil
}

func (n *Node) IsExternalNode() bool {
	return n.leftChild == nil && n.rightChild == nil
}

func (n *Node) Height() int {
	if n == nil {
		return 0
	}
	if n.leftChild == nil && n.rightChild == nil {
		return 1
	}
	if n.leftChild == nil {
		return n.rightChild.Height() + 1
	}
	if n.rightChild == nil {
		return n.leftChild.Height() + 1
	}
	return max(n.leftChild.Height(), n.rightChild.Height()) + 1
}

func (n *Node) String() string {
	if n == nil {
		return ""
	}
	if n.IsLeaf() {
		return fmt.Sprintf("%d", n.key)
	}
	return fmt.Sprintf("(%s %s %s)", n.leftChild.String(), strconv.Itoa(n.key), n.rightChild.String())
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func main() {
	keys := []int{1, 4, 5, 10, 16, 17, 21}
	root := NewNode(0)
	for _, key := range keys {
		root.Insert(key)
	}
	root.PrintTree()
}

func (root *Node) Insert(key int) {
	if root == NULL {
		root = NewNode(key)
		return
	}
	if key < root.key {
		root.leftChild = root.leftChild.Insert(key)
	} else if key > root.key {
		root.rightChild = root.rightChild.Insert(key)
	} else {
		fmt.Printf("Duplicate key: %d\n", key)
	}
}

func (node *Node) PrintTree() {
	if node == nil {
		return
	}
	fmt.Printf("%s\n", node.String())
	if node.leftChild != nil {
		node.leftChild.PrintTree()
	}
	if node.rightChild != nil {
		node.rightChild.PrintTree()
	}
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

該代碼使用二叉搜索樹來存儲關鍵字集合，并使用遞歸方式打印出樹形結構。在 main 函數中，我們先定義關鍵字集合，然后創建一個根節點，并使用 Insert 方法將所有關鍵字插入到樹中。最后，我們調用 PrintTree 方法打印樹形結構。

在 Node 結構體中，我們定義了 key、leftChild 和 rightChild 三個字段，分別表示節點的鍵、左子節點和右子節點。我們還定義了 IsLeaf、IsInternalNode 和 IsExternalNode 三個方法來判斷節點的類型。

在 Node 結構體中，我們還定義了 Height 方法來計算節點的高度。在 PrintTree 方法中，我們首先打印節點的字符串表示，然后遞歸地打印左子樹和右子樹。

在 main 函數中，我們首先創建一個根節點，并使用 Insert 方法將所有關鍵字插入到樹中。最后，我們調用 PrintTree 方法打印樹形結構。

靈小智，代碼正常運行：

好的，我可以幫你用Go語言畫出指定高度的二叉搜索樹。下面是使用遞歸方式實現的代碼示例：

package main

import (
	"fmt"
)

type Node struct {
	Value int
	Left  *Node
	Right *Node
}

func main() {
	keywords := []int{1, 4, 5, 10, 16, 17, 21}
	heights := []int{2, 3, 4, 5, 6}

	for _, height := range heights {
		root := constructBST(keywords, 0, len(keywords)-1, height)
		fmt.Printf("Height: %d\n", height)
		printTree(root, 0)
		fmt.Println()
	}
}

func constructBST(keywords []int, start, end, height int) *Node {
	if start > end || height == 0 {
		return nil
	}

	mid := (start + end) / 2
	root := &Node{Value: keywords[mid]}

	leftHeight := height - 1
	rightHeight := height - 1

	if mid-start >= end-mid {
		leftHeight++
	} else {
		rightHeight++
	}

	root.Left = constructBST(keywords, start, mid-1, leftHeight)
	root.Right = constructBST(keywords, mid+1, end, rightHeight)

	return root
}

func printTree(node *Node, level int) {
	if node == nil {
		return
	}

	printTree(node.Right, level+1)
	for i := 0; i < level; i++ {
		fmt.Printf("\t")
	}
	fmt.Println(node.Value)
	printTree(node.Left, level+1)
}

這段代碼可以根據給定的關鍵字集合和高度構造相應的二叉搜索樹，并打印出來。你可以根據需要修改關鍵字集合和高度來生成不同的樹形結構。

chatgpt，代碼正常運行：

下面是使用Go語言實現的繪制不同高度二叉搜索樹的示例代碼：

package main

import (
	"fmt"
	"strings"
)

type Node struct {
	Value int
	Left  *Node
	Right *Node
}

func NewNode(value int) *Node {
	return &Node{
		Value: value,
	}
}

func Insert(root *Node, value int) *Node {
	if root == nil {
		return NewNode(value)
	}
	if value < root.Value {
		root.Left = Insert(root.Left, value)
	} else if value > root.Value {
		root.Right = Insert(root.Right, value)
	}
	return root
}

func PrintTree(root *Node, space int) {
	const spaceCount = 4

	if root == nil {
		return
	}

	space += spaceCount

	PrintTree(root.Right, space)

	fmt.Println(strings.Repeat(" ", space-spaceCount), root.Value)

	PrintTree(root.Left, space)
}

func main() {
	keywords := []int{1, 4, 5, 10, 16, 17, 21}
	heights := []int{2, 3, 4, 5, 6}

	for _, height := range heights {
		var root *Node
		for _, keyword := range keywords {
			root = Insert(root, keyword)
			if height > 0 && height != calculateHeight(root) { // 如果指定了非零高度，并且當前高度不匹配，繼續插入節點直到達到目標高度
				continue
			}
			fmt.Printf("Height: %d\n", calculateHeight(root))
			PrintTree(root, 0)
			fmt.Println()
		}
		
    fmt.Println("----------------------------------")
	}
}

func calculateHeight(node *Node) int {
	if node == nil {
		return 0
	}
	leftHeight := calculateHeight(node.Left)
	rightHeight := calculateHeight(node.Right)

	if leftHeight > rightHeight {
		return leftHeight + 1
	} else {
		return rightHeight + 1
	}
}

運行該代碼，可以輸出不同高度的二叉搜索樹：

總結

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

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

上一篇：仿真纹眉术价格多少？
下一篇：函数计算的新征程：使用 Laf 构建 A