文心一言 VS 讯飞星火 VS chatgpt （144）-- 算法导论12.1 4题
四、用go语言，对于一棵有 n 个结点的树，请设计在 O(n)时间内完成的先序遍历算法和后序遍历算法。
我个人喜欢 灵小智 。
文心一言：
在 Go 语言中，我们可以使用递归来实现树的前序遍历和后序遍历。以下是实现这两种方法的代码。
首先，我们定义一个树节点的结构：
type TreeNode struct {
Val int
Left *TreeNode
Right *TreeNode
}
接下来，我们实现前序遍历（根-左-右）：
func preOrderTraversal(root *TreeNode) {
if root == nil { // 空节点则返回
return
}
fmt.Println(root.Val) // 先打印根节点
preOrderTraversal(root.Left) // 然后遍历左子树
preOrderTraversal(root.Right) // 最后遍历右子树
}
然后，我们实现后序遍历（左-右-根）：
func postOrderTraversal(root *TreeNode) {
if root == nil { // 空节点则返回
return
}
postOrderTraversal(root.Left) // 先遍历左子树
postOrderTraversal(root.Right) // 然后遍历右子树
fmt.Println(root.Val) // 最后打印根节点
}
以上的前序遍历和后序遍历的时间复杂度都是 O(n)，其中 n 是树的节点数量。这是因为每个节点都会被访问一次，每个节点只会被访问一次。
讯飞星火，代码正常运行：
package main
import "fmt"
type TreeNode struct {
Val int
Left *TreeNode
Right *TreeNode
}
func preorderTraversal(root *TreeNode) []int {
if root == nil {
return []int{}
}
stack := []*TreeNode{root}
res := []int{root.Val}
for len(stack) > 0 {
node := stack[len(stack)-1]
stack = stack[:len(stack)-1]
if node.Right != nil {
stack = append(stack, node.Right)
res = append(res, node.Right.Val)
}
if node.Left != nil {
stack = append(stack, node.Left)
res = append(res, node.Left.Val)
}
}
return res
}
func postorderTraversal(root *TreeNode) []int {
if root == nil {
return []int{}
}
stack := []*TreeNode{root}
res := []int{}
for len(stack) > 0 {
node := stack[len(stack)-1]
stack = stack[:len(stack)-1]
res = append(res, node.Val)
if node.Left != nil {
stack = append(stack, node.Left)
}
if node.Right != nil {
stack = append(stack, node.Right)
}
}
for i, n := 0, len(res); i < n/2; i++ {
res[i], res[n-1-i] = res[n-1-i], res[i]
}
return res
}
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}
root.Right.Left = &TreeNode{Val: 6}
root.Right.Right = &TreeNode{Val: 7}
fmt.Println("先序遍历结果：", preorderTraversal(root))
fmt.Println("后序遍历结果：", postorderTraversal(root))
}
360智脑，代码不能运行：
以下是用go语言实现一棵有 n 个结点的树的先序遍历和后序遍历算法：
先序遍历算法：
package main
import "fmt"
func preOrder(node *Node) []int {
res := []int{}
if node != nil {
res = append(res, node.val)
preOrder(node.left)
preOrder(node.right)
}
return res
}
func main() {
// 创建一棵有3个结点的二叉树
root := &Node{val: 10, left: nil, right: nil}
root.left = &Node{val: 5, left: nil, right: &Node{}}
root.left.left = &Node{val: 3, left: nil, right: nil}
root.left.right = &Node{val: 7, left: nil, right: nil}
root.right = &Node{val: 15, left: nil, right: &Node{}}
root.right.left = &Node{val: 2, left: nil, right: nil}
root.right.right = &Node{val: 12, left: nil, right: nil}
// 输出先序遍历结果
res := preOrder(root)
fmt.Println(res) // 输出 [10 5 7 2 12 15]
}
后序遍历算法：
package main
import "fmt"
func postOrder(node *Node) []int {
res := []int{}
if node != nil {
res = append(res, node.val)
postOrder(node.left)
postOrder(node.right)
}
return res
}
func main() {
// 创建一棵有3个结点的二叉树
root := &Node{val: 10, left: nil, right: nil}
root.left = &Node{val: 5, left: nil, right: nil}
root.left.left = &Node{val: 3, left: nil, right: nil}
root.left.right = &Node{val: 7, left: nil, right: nil}
root.right = &Node{val: 15, left: nil, right: nil}
root.right.left = &Node{val: 2, left: nil, right: nil}
root.right.right = &Node{val: 12, left: nil, right: nil}
// 输出后序遍历结果
res := postOrder(root)
fmt.Println(res) // 输出 [15 2 12 7 10 5 3 15]
}
智谱清言：
在 Go 语言中，可以使用递归或迭代方法实现树的遍历。以下是先序遍历和后序遍历的递归和迭代算法：
1.先序遍历算法：
递归算法：
func preOrderTraversalRecursive(root *TreeNode) []int {
if root == nil {
return []int{}
}
result := []int{root.Val}
result = append(result, preOrderTraversalRecursive(root.Left)...)
result = append(result, preOrderTraversalRecursive(root.Right)...)
return result
}
迭代算法：
func preOrderTraversalIterative(root *TreeNode) []int {
if root == nil {
return []int{}
}
result := []int{}
stack := []*TreeNode{root}
for len(stack) > 0 {
node := stack[len(stack)-1]
stack = stack[:len(stack)-1]
result = append(result, node.Val)
if node.Right != nil {
stack = append(stack, node.Right)
}
if node.Left != nil {
stack = append(stack, node.Left)
}
}
return result
}
2.后序遍历算法：
递归算法：
func postOrderTraversalRecursive(root *TreeNode) []int {
if root == nil {
return []int{}
}
result := postOrderTraversalRecursive(root.Left)
result = append(result, root.Val)
result = append(result, postOrderTraversalRecursive(root.Right)...)
return result
}
迭代算法：
func postOrderTraversalIterative(root *TreeNode) []int {
if root == nil {
return []int{}
}
result := []int{}
stack := []*TreeNode{root}
for len(stack) > 0 {
node := stack[len(stack)-1]
stack = stack[:len(stack)-1]
result = append(result, node.Val)
if node.Left != nil {
stack = append(stack, node.Left)
}
if node.Right != nil {
stack = append(stack, node.Right)
}
}
// Reverse the result array to get post-order traversal
for i, j := 0, len(result)-1; i < j; i, j = i+1, j-1 {
result[i], result[j] = result[j], result[i]
}
return result
}
以上算法均能在 O(n) 时间内完成树的遍历。
通义千问：
这是一个经典的二叉树问题，我们可以使用深度优先搜索（DFS）来解决这个问题。
首先，我们需要定义一个树节点的数据结构：
type TreeNode struct {
Val int
Left *TreeNode
Right *TreeNode
}
然后，我们分别实现先序遍历和后序遍历的函数：
先序遍历：根 -> 左 -> 右
func preorderTraversal(root *TreeNode) []int {
if root == nil {
return []int{}
}
result := make([]int, 0)
stack := []*TreeNode{root}
for len(stack) > 0 {
node := stack[len(stack)-1]
result = append(result, node.Val)
if node.Right != nil {
stack = append(stack, node.Right)
}
if node.Left != nil {
stack = append(stack, node.Left)
} else {
stack = stack[:len(stack)-1]
}
}
return result
}
后序遍历：左 -> 右 -> 根
func postorderTraversal(root *TreeNode) []int {
if root == nil {
return []int{}
}
result := make([]int, 0)
stack := []*TreeNode{root}
prev := root
for len(stack) > 0 {
node := stack[len(stack)-1]
if node.Left == nil && node.Right == nil || node == prev {
result = append([]int{node.Val}, result...)
prev = node
stack = stack[:len(stack)-1]
} else if node.Right != nil {
stack = append(stack, node.Right)
} else {
stack = stack[:len(stack)-1]
if node.Left != nil {
stack = append(stack, node.Left)
}
}
}
return result
}
这两种方法的时间复杂度都是O(n)，其中n是树中节点的数量，因为我们只需要遍历一次所有的节点。空间复杂度也是O(n)，因为在最坏的情况下，我们可能需要将所有的节点都压入栈中。
天工：
先序遍历算法：
先序遍历是指先访问根节点，然后依次访问左子树和右子树。在 Go 语言中，可以使用递归实现先序遍历算法。具体实现如下：
// 定义一个树节点结构体
type TreeNode struct {
Val int
Left *TreeNode
Right *TreeNode
}
// 先序遍历算法
func PreorderTraversal(root *TreeNode) {
if root == nil {
return
}
// 访问当前节点
fmt.Printf("%d ", root.Val)
// 递归访问左右子树
PreorderTraversal(root.Left)
PreorderTraversal(root.Right)
}
后序遍历算法：
后序遍历是指先访问左子树，然后访问右子树，最后访问根节点。在 Go 语言中，可以使用递归实现后序遍历算法。具体实现如下：
// 定义一个树节点结构体
type TreeNode struct {
Val int
Left *TreeNode
Right *TreeNode
}
// 后序遍历算法
func PostorderTraversal(root *TreeNode) {
if root == nil {
return
}
// 递归访问左右子树
PostorderTraversal(root.Left)
PostorderTraversal(root.Right)
// 访问当前节点
fmt.Printf("%d ", root.Val)
}
以上两个算法都是使用递归实现的，时间复杂度为 O(n)，空间复杂度为 O(h)，其中 h 是树的高度。
灵小智，代码正常运行：
在Go语言中，可以使用递归的方式实现树的先序遍历和后序遍历算法。下面是相应的实现：
package main
import "fmt"
// 树的节点结构定义
type TreeNode struct {
Val int
Children []*TreeNode
}
// 先序遍历函数
func PreorderTraversal(root *TreeNode) {
if root == nil {
return
}
fmt.Printf("%d ", root.Val) // 先输出当前节点的值
for _, child := range root.Children {
PreorderTraversal(child) // 递归遍历子节点
}
}
// 后序遍历函数
func PostorderTraversal(root *TreeNode) {
if root == nil {
return
}
for _, child := range root.Children {
PostorderTraversal(child) // 递归遍历子节点
}
fmt.Printf("%d ", root.Val) // 最后输出当前节点的值
}
func main() {
// 构建一个示例树
root := &TreeNode{Val: 1}
node2 := &TreeNode{Val: 2}
node3 := &TreeNode{Val: 3}
node4 := &TreeNode{Val: 4}
node5 := &TreeNode{Val: 5}
root.Children = []*TreeNode{node2, node3, node4}
node2.Children = []*TreeNode{node5}
// 先序遍历
fmt.Println("Preorder Traversal:")
PreorderTraversal(root)
fmt.Println()
// 后序遍历
fmt.Println("Postorder Traversal:")
PostorderTraversal(root)
fmt.Println()
}
以上代码通过先序遍历和后序遍历的方式遍历了一棵示例树，并输出了遍历结果。请注意，这里的先序遍历和后序遍历算法的时间复杂度为 O(n)，其中 n 是树中节点的个数。
chatgpt，代码正常运行：
在Go语言中，可以使用迭代的方式来实现树的先序遍历和后序遍历，以保证时间复杂度为O(n)。以下是示例代码：
package main
import (
"fmt"
)
// 树节点结构体
type Node struct {
Value int
Left *Node
Right *Node
}
// 先序遍历
func PreorderTraversal(root *Node) {
if root == nil {
return
}
stack := []*Node{root}
for len(stack) > 0 {
node := stack[len(stack)-1]
stack = stack[:len(stack)-1]
fmt.Printf("%d ", node.Value)
if node.Right != nil {
stack = append(stack, node.Right)
}
if node.Left != nil {
stack = append(stack, node.Left)
}
}
}
// 后序遍历
func PostorderTraversal(root *Node) {
if root == nil {
return
}
stack1 := []*Node{root}
stack2 := []*Node{}
for len(stack1) > 0 {
node := stack1[len(stack1)-1]
stack1 = stack1[:len(stack1)-1]
stack2 = append(stack2, node)
// 左子树先入栈
if node.Left != nil {
stack1 = append(stack1, node.Left)
}
// 右子树后入栈
if node.Right != nil {
stack1 = append(stack1, node.Right)
}
}
for i := len(stack2)-1; i >= 0; i-- {
fmt.Printf("%d ", stack2[i].Value)
}
}
func main() {
// 构建一棵树作为示例
root := &Node{
Value: 1,
Left: &Node{
Value: 2,
Left: &Node{
Value: 4,
Left: nil,
Right: nil,
},
Right: &Node{
Value: 5,
Left: nil,
Right: nil,
},
},
Right: &Node{
Value: 3,
Left: &Node{
Value: 6,
Left: nil,
Right: nil,
},
Right:nil,
},
}
fmt.Println("先序遍历结果：")
PreorderTraversal(root)
fmt.Println("\n后序遍历结果：")
PostorderTraversal(root)
}
以上代码中，我们使用了两个栈来实现后序遍历。第一个栈用于模拟先序遍历，将右子节点先入栈，然后左子节点入栈。第二个栈用于保存逆向的结果，在第一个栈为空时，将第一个栈中的元素依次弹出并加入到第二个栈中，然后输出即为后序遍历结果。
文心一言 VS 讯飞星火 VS chatgpt （144）-- 算法导论12.1 4题的更多相关文章
- 【对比】文心一言对飚ChatGPT实操对比体验
前言 缘由 百度[文心一言]体验申请通过 本狗中午干饭时,天降短信,告知可以体验文心一言,苦等一个月的实操终于到来.心中这好奇的对比心理油然而生,到底是老美的[ChatGPT]厉害,还是咱度娘的[文心 ...
- 【个人首测】百度文心一言 VS ChatGPT GPT-4
昨天我写了一篇文章GPT-4牛是牛,但这几天先别急,文中我测试了用GPT-4回答ChatGPT 3.5 和 Notion AI的问题,大家期待的图片输入也没有出现. 昨天下午百度发布了文心一言,对标C ...
- 文心一言,通营销之学,成一家之言,百度人工智能AI大数据模型文心一言Python3.10接入
"文心"取自<文心雕龙>一书的开篇,作者刘勰在书中引述了一个古代典故:春秋时期,鲁国有一位名叫孔文子的大夫,他在学问上非常有造诣,但是他的儿子却不学无术,孔文子非常痛心 ...
- 获取了文心一言的内测及与其ChatGPT、GPT-4 对比结果
百度在3月16日召开了关于文心一言(知识增强大语言模型)的发布会,但是会上并没现场展示demo.如果要测试的文心一言 也要获取邀请码,才能进行测试的. 我这边通过预约得到了邀请码,大概是在3月17日晚 ...
- 百度生成式AI产品文心一言邀你体验AI创作新奇迹：百度CEO李彦宏详细透露三大产业将会带来机遇（文末附文心一言个人用户体验测试邀请码获取方法，亲测有效）
目录 中国版ChatGPT上线发布 强大中文理解能力 智能文学创作.商业文案创作 图片.视频智能生成 中国生成式AI三大产业机会 新型云计算公司 行业模型精调公司 应用服务提供商 总结 获取文心一言邀 ...
- 阿里版ChatGPT：通义千问pk文心一言
随着 ChatGPT 热潮卷起来,百度发布了文心一言.Google 发布了 Bard,「阿里云」官方终于也宣布了,旗下的 AI 大模型"通义千问"正式开启测试! 申请地址:http ...
- 基于讯飞语音API应用开发之——离线词典构建
最近实习在做一个跟语音相关的项目,就在度娘上搜索了很多关于语音的API,顺藤摸瓜找到了科大讯飞,虽然度娘自家也有语音识别.语义理解这块,但感觉应该不是很好用,毕竟之前用过百度地图的API,有问题也找不 ...
- android用讯飞实现TTS语音合成 实现中文版
Android系统从1.6版本开始就支持TTS(Text-To-Speech),即语音合成.但是android系统默认的TTS引擎:Pic TTS不支持中文.所以我们得安装自己的TTS引擎和语音包. ...
- android讯飞语音开发常遇到的问题
场景:android项目中共使用了3个语音组件:在线语音听写.离线语音合成.离线语音识别 11208:遇到这个错误,授权应用失败,先检查装机量(3台测试权限),以及appid的申请时间(35天期限), ...
- 初探机器学习之使用讯飞TTS服务实现在线语音合成
最近在调研使用各个云平台提供的AI服务,有个语音合成的需求因此就使用了一下科大讯飞的TTS服务,也用.NET Core写了一个小示例,下面就是这个小示例及其相关背景知识的介绍. 一.什么是语音合成(T ...
随机推荐
- WebKit Inside: CSS 样式表的匹配时机
WebKit Inside: CSS 的解析 介绍了 CSS 样式表的解析过程,这篇文章继续介绍 CSS 的匹配时机. 无外部样式表 内部样式表和行内样式表本身就在 HTML 里面,解析 HTML 标 ...
- RPM软件包：Red HatPackage Manager，RPM
RPM软件包是按照GPL条款发行在各个linux版本上使用. 用途 可以安装.删除.升级.刷新和管理RPM软件包 通过RPM软件包管理能知道软件包包含哪些文件,也能知道系统中的某个文件属于哪个RPM软 ...
- 通过Lambda函数的方式获取属性名称
前言: 最近在使用mybatis-plus框架, 常常会使用lambda的方法引用获取实体属性, 避免出现大量的魔法值. public List<User> listBySex() { L ...
- 一键安装LNMP
#!/bin/bash #2020年3月1日 #auto_install_lnmp. #by fly ################################ NGX_VER="$1 ...
- LCT(link cut tree) 详细图解与应用
樱雪喵用时 3days 做了 ybtoj 的 3 道例题,真是太有效率了!!1 写死自己系列. 为了避免自己没学明白就瞎写东西误人子弟,这篇 Blog 拖到了现在. 图片基本沿用 OIwiki,原文跳 ...
- umich cv-6-2 注意力机制
这节课中介绍了循环神经网络的第二部分,主要引入了注意力机制,介绍了注意力机制的应用以及如何理解,在此基础上建立了注意力层以及transformer架构 注意力机制 注意力机制 应用与理解 注意力层 t ...
- 殷浩详解DD系列
第五讲:https://blog.csdn.net/Taobaojishu/article/details/115911833 内部有1-4讲链接
- 在NestJS应用程序中使用 Unleash 实现功能切换的指南
前言 近年来,软件开发行业迅速发展,功能开关(Feature Toggle)成为了一种常见的开发实践.通过功能开关,可以在运行时动态地启用或禁用应用程序的特定功能,以提供更灵活的软件交付和配置管理.对 ...
- Net 高级调试之八：代码审查及杂项命令
一.简介 今天是<Net 高级调试>的第八篇文章.这篇文章设计的内容挺多的,比如:如何查看方法的汇编代码,如何获取方法的描述符,对象同步块的转储,对象方法表的转储,托管堆和垃圾回收器信息的 ...
- 大白话说Python+Flask入门（一）
写在前面 技术这东西就得用,不用就会忘,之前写博客感觉就是给自己记笔记用,还有大部分,估计睡在语雀里都落灰了,哈哈! 在Python领域,我觉得我还是算个小白吧,会写讲不明白,所以我决定想做一件事,先 ...