文心一言 VS 讯飞星火 VS chatgpt （124）-- 算法导论10.5 5题

news2024/10/7 18:31:49

五、用go语言，给定一个n结点的二叉树，写出一个 O(n)时间的非递归过程，将该树每个结点的关键字输出。要求除该树本身的存储空间外只能使用固定量的额外存储空间，且在过程中不得修改该树，即使是暂时的修改也不允许。

文心一言：

您可以使用一个栈来存储节点，以便在遍历二叉树时进行回溯。由于您要求不能修改树的结构，我们需要在原树上进行操作。以下是一个可能的解决方案：

package main  
  
import (  
    "fmt"  
)  
  
type TreeNode struct {  
    Val   int  
    Left  *TreeNode  
    Right *TreeNode  
}  
  
func PrintTree(root *TreeNode) {  
    if root == nil {  
        return  
    }  
    stack := []*TreeNode{root}  
    for len(stack) > 0 {  
        node := stack[len(stack)-1]  
        stack = stack[:len(stack)-1]  
        fmt.Println(node.Val)  
        if node.Left != nil {  
            stack = append(stack, node.Left)  
        }  
        if node.Right != nil {  
            stack = append(stack, node.Right)  
        }  
    }  
}

在这个函数中，我们首先检查根节点是否为空。如果为空，那么就直接返回。否则，我们将根节点放入栈中。然后，我们开始一个循环，只要栈不为空，就持续运行。在每个循环中，我们取出栈顶的节点，打印其值，然后依次将其左子节点和右子节点（如果存在）放入栈中。这样，我们就可以按照中序遍历的顺序打印出每个节点的值，而中序遍历是二叉树所有遍历方法中最接近线性时间的。同时，因为我们只使用了固定数量的额外存储空间（即栈的空间），所以满足了题目中的要求。

在这里插入图片描述

在这里插入图片描述

讯飞星火：

解析：

1.首先，我们需要创建一个二叉树节点的结构体，包含关键字和左右子节点的指针。

2.然后，我们需要创建一个非递归的过程来遍历二叉树。我们可以使用一个栈来实现这个过程。初始时，我们将根节点压入栈中。

3.在每一步中，我们从栈顶取出一个节点，输出它的关键字，然后将它的右子节点和左子节点（如果存在的话）压入栈中。这样，我们就可以按照先序遍历的顺序访问所有的节点。

4.重复这个过程，直到栈为空，也就是我们已经访问了所有的节点。

代码如下：

package main

import "fmt"

// 定义二叉树节点的结构体
type TreeNode struct {
    Val   int
    Left  *TreeNode
    Right *TreeNode
}

// 非递归过程遍历二叉树并输出每个节点的关键字
func printTree(root *TreeNode) {
    if root == nil {
        return
    }

    stack := []*TreeNode{root}
    for len(stack) > 0 {
        node := stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        fmt.Println(node.Val)
        if node.Right != nil {
            stack = append(stack, node.Right)
        }
        if node.Left != nil {
            stack = append(stack, node.Left)
        }
    }
}

func main() {
    // 创建一个简单的二叉树进行测试
    root := &TreeNode{Val: 1}
    root.Left = &TreeNode{Val: 2}
    root.Right = &TreeNode{Val: 3}
    root.Left.Left = &TreeNode{Val: 4}
    root.Left.Right = &TreeNode{Val: 5}

    printTree(root)
}

这段代码首先定义了一个二叉树节点的结构体，然后定义了一个非递归的过程来遍历二叉树并输出每个节点的关键字。在主函数中，我们创建了一个简单的二叉树进行测试。

在这里插入图片描述

在这里插入图片描述

360智脑：

以下是一个用Go语言实现的非递归遍历二叉树并输出每个结点的关键字的示例代码。这个代码使用了栈来辅助实现，因此时间复杂度为O(n)。

package main

import (
    "fmt"
)

// 定义二叉树节点
type Node struct {
    key  int
    left； *Node
    right *Node
}

// 打印二叉树结点
func printTree(root *Node) {
    if root == nil {
        return
    }

    stack := []*Node{}
    stack = append(stack, root)

    for len(stack) > 0 {
        node := stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        fmt.Printf("Node: %d\n", node.key)
        
        // 弹出左子节点和右子节点
        if node.left != nil {
            stack = append(stack, node.left)
        }

        if node.right != nil {
            stack = append(stack, node.right)
        }
    }
}

// 定义主函数
func main() {
    // 创建二叉树
    root := &Node{key: 100}
    root.left = &Node{key: 50}
    root.right = &Node{key: 300}
    root.left.left = &Node{key: 20}
    root.left.right = &Node{key: 40}

    // 打印结点
    printTree(root)
}

在这个代码中，我们使用了一个栈来存储待处理的二叉树的节点。每次取出一个节点，然后弹出它的左右子节点，并将这些节点存储在一个新的栈中。这样，我们就可以在不修改原始树的情况下，将所有节点的关键字输出。

在这里插入图片描述

在这里插入图片描述

智谱清言：

在 Go 语言中，我们可以使用迭代的方式遍历二叉树，并输出每个节点的关键字。为此，我们可以使用一个长度为 n 的数组作为辅助空间，同时在遍历过程中，按照层序遍历的方式访问每个节点。以下是一个满足要求的 Go 代码实现：

package main
import "fmt"
type TreeNode struct {  
    Key   int  
    Left  *TreeNode  
    Right *TreeNode  
}
func levelOrderTraversal(root *TreeNode, extraSpace int) {  
    if root == nil {  
        return  
    }
    nodes := make([]*TreeNode, extraSpace)  
    nodes[0] = root  
    level := 1
    for len(nodes) > 0 {  
        for i := 0; i < len(nodes); i++ {  
            node := nodes[i]  
            fmt.Print(node.Key, " ")
            if node.Left != nil {  
                nodes = append(nodes, node.Left)  
            }  
            if node.Right != nil {  
                nodes = append(nodes, node.Right)  
            }  
        }  
        fmt.Println()  
        level++
        for len(nodes) > 0 && level <= extraSpace {  
            nodes = nodes[1:]  
            level++  
        }  
    }  
}
func main() {  
    root := &TreeNode{Key: 1}  
    root.Left = &TreeNode{Key: 2}  
    root.Right = &TreeNode{Key: 3}  
    root.Left.Left = &TreeNode{Key: 4}  
    root.Left.Right = &TreeNode{Key: 5}  
    root.Right.Right = &TreeNode{Key: 6}
    levelOrderTraversal(root, 2)  
}

在这个代码中，我们定义了一个TreeNode结构体，用于表示二叉树的节点。levelOrderTraversal函数接受一个二叉树的根节点和一个额外的存储空间大小作为参数。我们使用一个循环遍历二叉树，按照层序访问每个节点，并输出关键字。在每次循环中，我们使用辅助数组存储当前层的节点，并在访问完一层后移除该层节点。

注意，这个解决方案使用了额外的存储空间，但满足了题目要求的不修改二叉树的条件。

在这里插入图片描述

在这里插入图片描述

通义千问：

在 Go 语言中，可以使用广度优先搜索（BFS）来实现这个需求。广度优先搜索是一种图形遍历算法，它从根节点开始，首先访问与根节点相邻的所有节点，然后再依次访问这些节点的邻居。

以下是具体的代码实现：

package main

import (
	"fmt"
)

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

func PrintTree(root *TreeNode) {
	if root == nil {
		return
	}

	queue := make([]*TreeNode, 0)
	queue = append(queue, root)

	for len(queue) > 0 {
		node := queue[0]
		fmt.Println(node.Value)
		queue = queue[1:]

		if node.Left != nil {
			queue = append(queue, node.Left)
		}
		if node.Right != nil {
			queue = append(queue, node.Right)
		}
	}
}

func main() {
	root := &TreeNode{Value: 1}
	root.Left = &TreeNode{Value: 2}
	root.Right = &TreeNode{Value: 3}
	root.Left.Left = &TreeNode{Value: 4}
	root.Left.Right = &TreeNode{Value: 5}
	root.Right.Left = &TreeNode{Value: 6}
	root.Right.Right = &TreeNode{Value: 7}

	PrintTree(root)
}

在这个代码中，我们使用了一个队列来存储待访问的节点。每次从队列的头部取出一个节点进行访问，并将其左右子节点加入到队列的尾部。这样就可以保证所有节点都会被访问到，并且只需要常数级别的额外空间。

在这里插入图片描述

在这里插入图片描述

天工：

以下是用Go语言实现的O(n)时间复杂度的非递归二叉树遍历过程，满足题目要求：

package main

import "fmt"

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

func printInOrder(root *TreeNode) []int {
    res := []int{}
    cur := root
    for cur != nil {
        if cur.Left == nil {
            res = append(res, cur.Val)
            cur = cur.Right
        } else {
            printInOrder(cur.Left)
            res = append(res, cur.Val)
            cur = cur.Right
        }
    }
    return res
}

func main() {
    root := &TreeNode{1, &TreeNode{2, &TreeNode{4, nil, nil}, &TreeNode{5, nil, nil}}, &TreeNode{3, nil, nil}}
    fmt.Println(printInOrder(root)) // Output: [1 2 4 5 3]
}

在这个实现中，我们使用了一个辅助函数printInOrder，它使用一个res切片来存储遍历结果，同时维护一个cur指针来指向当前要访问的节点。在每次迭代中，我们首先检查cur的左子节点是否为空，如果为空，说明cur是一个叶节点，我们将cur的值加入到res中，并将cur指向其右子节点。如果cur的左子节点不为空，说明cur有左子节点和右子节点，我们先递归访问其左子节点，直到找到叶节点，然后将cur的值加入到res中，并将cur指向其右子节点。这样，我们就可以按照中序遍历的遍历顺序遍历整个树，并将每个节点的值保存到res切片中，最后返回res切片即可。

在这里插入图片描述

在这里插入图片描述

灵小智：

要实现非递归地遍历二叉树并输出每个节点的关键字，我们可以使用栈来模拟递归的过程。具体地，我们从根节点开始，将其入栈，然后遍历其左子树并将所有经过的节点入栈，直到遇到一个没有左孩子的节点。此时，我们弹出栈顶节点，输出其关键字，并遍历其右子树，将其右孩子以及其右孩子的左子树入栈。我们继续重复该过程，直到栈为空。由于每个节点最多入栈一次，出栈一次，因此时间复杂度为O(n)，且空间复杂度为O(h)，其中h为树的高度。

以下是用Go语言实现该算法的示例代码：

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

func inorderTraversal(root *TreeNode) []int {
    if root == nil {
        return []int{}
    }
    
    var result []int
    var stack []*TreeNode
    
    for root != nil || len(stack) > 0 {
        for root != nil {
            stack = append(stack, root)
            root = root.Left
        }
        root = stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        result = append(result, root.Val)
        root = root.Right
    }
    
    return result
}

该函数实现了二叉树的中序遍历，并返回每个节点的关键字。我们使用一个栈来保存经过的节点，在遍历当前节点的左子树时，将所有经过的节点入栈。当遇到一个没有左孩子的节点时，我们弹出栈顶节点并输出其关键字，并遍历以该节点为根的右子树，将其右孩子以及其右孩子的左子树入栈。重复该过程直到栈为空。

在这里插入图片描述

在这里插入图片描述

chatgpt：

下面是使用Go语言编写的非递归过程，按照中序遍历输出二叉树每个节点的关键字：

package main

import "fmt"

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

func inorderTraversal(root *TreeNode) []int {
    var result []int     // 存储结果的数组
    stack := []*TreeNode{}   // 使用栈辅助进行迭代

    current := root
    for current != nil || len(stack) > 0 {
        // 将左子树的所有节点入栈
        for current != nil {
            stack = append(stack, current)
            current = current.Left
        }
        
        // 弹出栈顶元素并记录值
        current = stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        result = append(result, current.Val)
        
        // 处理右子树
        current = current.Right
    }

    return result
}

func main() {
    // 构建示例二叉树：   1   
	//                   / \  
	//                  2   3 
	//                 / \    
	//                4   5  
	root := &TreeNode{
		Val: 1,
		Left: &TreeNode{
			Val: 2,
			Left: &TreeNode{Val: 4},
			Right: &TreeNode{Val: 5},
		},
		Right: &TreeNode{Val: 3},
    }

	result := inorderTraversal(root)
	fmt.Println(result)     // 输出 [4, 2, 5, 1, 3]
}

这里使用了栈来辅助进行迭代，通过模拟递归过程实现中序遍历。时间复杂度为 O(n)，且只使用了固定量的额外存储空间（栈）。

在这里插入图片描述

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1150253.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

ice和Dtls 传输的创建及1个简单的SFU转发实例

ice和Dtls 传输的创建及1个简单的SFU转发实例

ice和Dtls 传输的创建及1个简单的SFU转发实例 licode中，webrtcconn基于dtlstransport 收发，而dtlstransport通过libnice作为底层。dtlstransport 使用了srtp加解密。文末给出一个简化的sfu实例的实现。对应的，看下M98的代码，更能理解为啥这么做： IceTransportInternal 与D…
阅读更多...
Transformer模型原理

Transformer模型原理

NLP预训练模型的架构大致可以分为三类&#xff1a; 1. Encoder-Decoder架构&#xff08;T5&#xff09;&#xff0c;seq2seq模型&#xff0c;RNN、LSTM网络 2. BERT&#xff1a;自编码语言模型&#xff0c;预测文本随机掩码 3. GPT&#xff1a; 自回归语言模型&#xff0c;预测…
阅读更多...
Elasticsearch（一）---搭建

Elasticsearch（一）---搭建

搭建es 不允许root用于运行 创建esuser用户&#xff1a; useradd esuser 设置密码 passwd esuser 让esuser拥有sudo的权限&#xff0c;需要修改/etc/sudoers文件 需要先给/etc/sudoers添加写的权限 [rootnode1 ~]# vim /etc/sudoers 改完之后将写权限删除 三台服务器上操…
阅读更多...
“阿里巴巴按关键字搜索接口：一键获取海量商品信息，助力商家抢占市场先机！“

“阿里巴巴按关键字搜索接口：一键获取海量商品信息，助力商家抢占市场先机！“

阿里巴巴按关键字搜索商品的接口是通过开放平台提供的API接口来实现的。要使用这个接口&#xff0c;需要进行以下步骤&#xff1a; 确认API接口的请求地址和所需参数&#xff1a;需要先查看API文档&#xff0c;了解所要访问的API接口的请求地址和请求参数&#xff0c;以便正确…
阅读更多...
python随手小练13

python随手小练13

题目1&#xff1a; 定义学员信息类&#xff0c;包含姓名、成绩属性&#xff0c;定义成绩打印方法 (90分及以上显示优秀&#xff0c;80分及以上显示良好&#xff0c;70分及以上显示中等&#xff0c;60分及以上显示合格&#xff0c;60分以下显示不及格) 具体操作&#xff1a; cl…
阅读更多...
基于pyqt5和yolov8的智慧工地施工人工安全检测系统

基于pyqt5和yolov8的智慧工地施工人工安全检测系统

基于pyqt5和yolov8的智慧工地施工人工安全检测系统 主要基于两者进行集成 在前面模型训练基础上&#xff0c;实现安全马甲、安全面具和安全帽的检测。 核心检测代码 def run(self):self.hilo_corriendo Truemodel YOLO("best.pt")cap cv2.VideoCapture(0)while…
阅读更多...
安全生产管理系统助力企业安全细化管理

安全生产管理系统助力企业安全细化管理

安全生产管理系统利用完整的安全生产管理体系&#xff0c;结合信息化、数字化和智能化等技术手段&#xff0c;将安全生产过程中的各个环节进行有效整合&#xff0c;使安全管理更加科学、规范和高效。 安全生产管理系统可以对企业安全生产进行全面、细致的管理。它能够实现对企…
阅读更多...
NFTScan | 10.23~10.29 NFT 市场热点汇总

NFTScan | 10.23~10.29 NFT 市场热点汇总

欢迎来到由 NFT 基础设施 NFTScan 出品的 NFT 生态热点事件每周汇总。 周期&#xff1a;2023.10.23~ 2023.10.29 NFT Hot News 01/ sudoswap 推出 NFT 做空协议 sudoshort 10 月 24 日&#xff0c;NFT 交易协议 sudoswap 推出 NFT 做空协议 sudoshort&#xff0c;是建立在 su…
阅读更多...
C语言C位出道心法(一):基础语法

C语言C位出道心法(一):基础语法

一:基础语法认知 变量与常量,数据类型认知升维 C语言中各种变量的定义及数据类型的认知: 一般而言,在譬如C等高级编程语言中,我们定义不同的类型的变量,需要不同的数据类型来进行声明,不同类型的数据类型声明的变量占用的内存空间不一样; 而数据类型大致分为两种: (1)内置的…
阅读更多...
ORACLE运行的数据库突然连接报“无监听程序”

ORACLE运行的数据库突然连接报“无监听程序”

远程&#xff1a;用远程的数据库连接工具用localhost可以连接&#xff0c;用ip地址除127.0.0.1不可连接。 可能是日志文件满了&#xff0c;解决办法如下&#xff1a; 第一步&#xff1a;关闭数据库监听程序【任务管理器--》服务--》右键停止服务】 第二步&#xff1a;找到日志…
阅读更多...
安防视频监控平台EasyCVR服务器需要开启firewalld防火墙，该如何开放端口？

安防视频监控平台EasyCVR服务器需要开启firewalld防火墙，该如何开放端口？

智能视频监控/视频云存储/集中存储/视频汇聚平台EasyCVR具备视频融合汇聚能力&#xff0c;作为安防视频监控综合管理平台&#xff0c;它支持多协议接入、多格式视频流分发&#xff0c;视频监控综合管理平台EasyCVR支持海量视频汇聚管理&#xff0c;可应用在多样化的场景上&…
阅读更多...
参与国际大科学计划！DDE 深时数字地球向您发出平台使用邀请

参与国际大科学计划！DDE 深时数字地球向您发出平台使用邀请

深时数字地球&#xff08;Deep-time Digital Earth&#xff0c;DDE&#xff09;是由我国科学家主导发起并受国际学术界认可的首个大科学计划&#xff0c;希望通过建立一个链接地学信息的研究平台&#xff0c;整合地球演化数据、共享全球地学知识&#xff0c;同时为世界范围内的…
阅读更多...
【兔子王赠书第4期】用ChatGPT轻松玩转机器学习与深度学习

【兔子王赠书第4期】用ChatGPT轻松玩转机器学习与深度学习

文章目录 前言机器学习深度学习ChatGPT推荐图书粉丝福利尾声 前言 兔子王免费赠书第4期来啦&#xff0c;突破传统学习束缚&#xff0c;借助ChatGPT的神奇力量&#xff0c;解锁AI无限可能&#xff01; 机器学习 机器学习是人工智能领域的一个重要分支&#xff0c;它的目的是让…
阅读更多...
网络安全（黑客）—零基础自学

网络安全（黑客）—零基础自学

目录 一、自学网络安全学习的误区和陷阱 二、学习网络安全的一些前期准备 三、网络安全学习路线 四、学习资料的推荐 想自学网络安全&#xff08;黑客技术&#xff09;首先你得了解什么是网络安全&#xff01;什么是黑客&#xff01; 网络安全可以基于攻击和防御视角来分类&am…
阅读更多...
GIS开源工具分享，Geojson格式转Topojson格式，使用TopoJSON Server工具进行Geojson转换为Topojson

GIS开源工具分享，Geojson格式转Topojson格式，使用TopoJSON Server工具进行Geojson转换为Topojson

前言 为什么要将 GeoJSON 转换为 TopoJSON? 因为TopoJSON会把GeoJSON中的冗余数据精简，所以相同数据TopoJSON体积比GeoJSON更小，更利于存储和传输。 Geojson介绍 GEOJSON是gis地图中常用的数据格式，制作地图时用于存储各种地理数据，使用时通过OpenLayer、Leaflet、mapL…
阅读更多...
Java char类型介绍

Java char类型介绍

前言&#xff1a;最近&#xff0c;想写一篇关于介绍产生”乱码问题“根本原因的文章&#xff0c;因此&#xff0c;查看了Java中的字符是如何存储的&#xff0c;即char数据类型。在此将学到的知识做一个总结。 一、char数据类型 char类型最初用于表示Unicode字符集中的一个字符…
阅读更多...
LeetCode | 17.04.消失的数字和189.旋转数组

LeetCode | 17.04.消失的数字和189.旋转数组

LeetCode | 17.04.消失的数字和189.旋转数组 文章目录 LeetCode | 17.04.消失的数字和189.旋转数组17.04.消失的数字方法一&#xff1a;方法二&#xff1a;方法三&#xff1a;方法二的代码方法三的代码 189.旋转数组思路一思路二思路三 17.04.消失的数字 OJ链接 这里题目要求…
阅读更多...
②CPU - 运算器、控制器 【软考-软件设计师考点】

②CPU - 运算器、控制器 【软考-软件设计师考点】

个人简介&#xff1a;Java领域新星创作者&#xff1b;阿里云技术博主、星级博主、专家博主&#xff1b;正在Java学习的路上摸爬滚打&#xff0c;记录学习的过程~ 个人主页&#xff1a;.29.的博客 学习社区&#xff1a;进去逛一逛~ ②CPU - 运算器、控制器 【软考-软件设计师考点…
阅读更多...
基于python的app程式开发

基于python的app程式开发

安装的库文件&#xff1a; 运行代码&#xff1a; # -*- coding:utf-8 -*- from kivy.app import App class HelloApp(App):pass if __name__ __main__:HelloApp().run() 结果画面&#xff1a;
阅读更多...
PTA 病毒溯源（树）

PTA 病毒溯源（树）

题目 病毒容易发生变异。某种病毒可以通过突变产生若干变异的毒株&#xff0c;而这些变异的病毒又可能被诱发突变产生第二代变异&#xff0c;如此继续不断变化。 现给定一些病毒之间的变异关系&#xff0c;要求你找出其中最长的一条变异链。 在此假设给出的变异都是由突变引起…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023