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

news2024/11/25 7:02:30

三、用go语言，设计一个执行中序遍历的非递归算法。（提示:一种容易的方法是使用栈作为辅助数据结构;另一种较复杂但比较简洁的做法是不使用栈，但要假设能测试两个指针是否相等。）

文心一言，代码正常运行：

我们可以使用栈作为辅助数据结构来执行中序遍历的非递归算法。以下是用Go语言实现的代码：

package main  
  
import (  
 "fmt"  
)  
  
type TreeNode struct {  
 Val   int  
 Left  *TreeNode  
 Right *TreeNode  
}  
  
func inorderTraversal(root *TreeNode) {  
 stack := []*TreeNode{}  
 node := root  
  
 for node != nil || len(stack) > 0 {  
 for node != nil {  
 stack = append(stack, node)  
 node = node.Left  
 }  
  
 node = stack[len(stack)-1]  
 stack = stack[:len(stack)-1]  
 fmt.Println(node.Val)  
  
 node = node.Right  
 }  
}  
  
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}  
 inorderTraversal(root)  
}

这个程序定义了一个TreeNode结构体，每个节点有一个整数值和两个指向其左右子节点的指针。inorderTraversal函数接收一个树的根节点，并使用栈来进行中序遍历。在遍历过程中，首先将当前节点及其所有左子节点推入栈中，然后处理栈顶节点（即最深层的左子节点），打印其值并将节点从栈中弹出。然后转向处理该节点的右子节点。如果在任何时候栈为空且当前节点为nil，则遍历结束。

在这里插入图片描述

在这里插入图片描述

讯飞星火，代码正常运行：

package main

import "fmt"

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

func inorderTraversal(root *TreeNode) []int {
    stack := []*TreeNode{}
    curr := root
    var res []int

    for curr != nil || len(stack) > 0 {
        for curr != nil {
            stack = append(stack, curr)
            curr = curr.Left
        }
        curr = stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        res = append(res, curr.Val)
        curr = curr.Right
    }

    return res
}

func main() {
    root := &TreeNode{Val: 1}
    root.Right = &TreeNode{Val: 2}
    root.Right.Left = &TreeNode{Val: 3}

    fmt.Println(inorderTraversal(root)) // Output: [1 3 2]
}

在这里插入图片描述

在这里插入图片描述

360智脑，代码不能运行：

使用栈实现中序遍历的非递归算法：

package main

import (
    "fmt"
)

// BinaryTree is a simple implementation of binary tree node.
type BinaryTree struct {
    Data interface{}
    Left *BinaryTree
    Right *BinaryTree
}

// InOrderNoRecursion is an implementation of in-order traversal without recursion.
func (bt *BinaryTree) InOrderNoRecursion() []interface{} {
    res := []interface{}{}
    stack := []interface{}{bt}

    for len(stack) > 0 {
        for bt != nil {
            stack = stack[1:]
            stack = stack[0:1]
            bt = bt.Left
        }
        if len(stack) == 0 {
            break
        }
        var current interface{}
        for _, element := range stack {
            current = element
        }
        res = append(res, current.(interface{})) // visit current node
        stack = stack[1:]
        bt = bt.Right
    }
    return res
}

func init() {
    // Create an empty binary tree.
    root := &BinaryTree{}
    root.Left = &BinaryTree{}
    root.Right = &BinaryTree{}
    
    // Create an empty binary tree for testing.
    testRoot := &BinaryTree{}
    testRoot.Left = &BinaryTree{}
    testRoot.Right = &BinaryTree{}
    
    fmt.Println("In-order traversal without recursion result:", InOrderNoRecursion(root))
    fmt.Println("In-order traversal without recursion result:", InOrderNoRecursion(testRoot))
}

该代码首先创建了一个空二叉树，然后创建两个测试用的二叉树进行测试。在InOrderNoRecursion()方法中，我们使用了栈来模拟中序遍历的过程。每次遍历到一个节点时，将其加入栈中，然后移动到其左子树或右子树。当栈为空时，表示已经遍历完所有节点，此时返回结果数组即可。

在这里插入图片描述

在这里插入图片描述

智谱清言，第1段代码正常运行，第2段代码抛panic：

以下是使用栈作为辅助数据结构的非递归算法实现：

package main
import "fmt"
type TreeNode struct {
    Val   int
    Left  *TreeNode
    Right *TreeNode
}
func inorderTraversal(root *TreeNode) []int {
    if root == nil {
        return []int{}
    }
    result := make([]int, 0)
    stack := make([]*TreeNode, 0)
    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() {
    root := &TreeNode{Val: 1, Left: &TreeNode{Val: 2, Left: &TreeNode{Val: 3, Left: nil, Right: nil}, Right: nil}, Right: &TreeNode{Val: 4, Left: nil, Right: nil}}
    fmt.Println(inorderTraversal(root)) // 输出：[3 2 4 1]
}

以下是使用非递归但假设能测试两个指针是否相等的做法：

package main
import "fmt"
type TreeNode struct {
    Val   int
    Left  *TreeNode
    Right *TreeNode
}
func isEqual(a, b *TreeNode) bool {
    if a == nil && b == nil {
        return true
    }
    if a == nil || b == nil {
        return false
    }
    return a.Val == b.Val && isEqual(a.Left, b.Left) && isEqual(a.Right, b.Right)
}
func inorderTraversal(root *TreeNode) []int {
    if root == nil {
        return []int{}
    }
    result := make([]int, 0)
    current := root
    for current != nil {
        for isEqual(current.Left, current) {
            current = current.Left
        }
        result = append(result, current.Val)
        for !isEqual(current.Right, current) {
            current = current.Right
        }
        current = current.Right
    }
    return result
}
func main() {
    root := &TreeNode{Val: 1, Left: &TreeNode{Val: 2, Left: &TreeNode{Val: 3, Left: nil, Right: nil}, Right: nil}, Right: &TreeNode{Val: 4, Left: nil, Right: nil}}
    fmt.Println(inorderTraversal(root)) // 输出：[3 2 4 1]
}

这两种方法都可以实现中序遍历，但第二种方法不使用栈，而是假设能测试两个指针是否相等，这种假设在实际编程中可能不总是成立，因此第一种方法更为推荐。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

通义千问，两段代码都能正常运行：

以下是两种方法实现的Go语言代码：

方法一：使用栈作为辅助数据结构

package main

import (
	"fmt"
)

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

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

func main() {
	root := &TreeNode{Val: 1}
	root.Left = &TreeNode{Val: 2}
	root.Right = &TreeNode{Val: 3}
	fmt.Println(inorderTraversal(root)) // 输出: [2 1 3]
}

方法二：不使用栈，测试两个指针是否相等

package main

import (
	"fmt"
)

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

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

func main() {
	root := &TreeNode{Val: 1}
	root.Left = &TreeNode{Val: 2}
	root.Right = &TreeNode{Val: 3}
	fmt.Println(inorderTraversal(root)) // 输出: [2 1 3]
}

这两种方法都可以有效地对二叉树进行中序遍历，并且都不会修改原始的二叉树结构。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

天工，代码正常运行：

以下是使用栈实现中序遍历的非递归算法的Go代码示例：

package main

import "fmt"

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

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

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

该代码定义了一个TreeNode结构体，表示二叉树的节点，包含节点的值Val，左子树Left和右子树Right。inorderTraversal函数使用一个栈来模拟中序遍历的过程，将根节点入栈，然后循环处理直到栈为空。在每次循环中，将栈顶节点弹出，如果该节点有左子树，则将左子树入栈，如果该节点有右子树，则将右子树入栈，最后将该节点的值加入到结果数组中。最后返回结果数组。

在main函数中，创建了一个二叉树的根节点，并调用inorderTraversal函数对其进行中序遍历，并将结果打印到控制台上。输出结果为[2 1 3]，与预期结果一致。

在这里插入图片描述

在这里插入图片描述

灵小智：

以下是使用栈作为辅助数据结构的非递归算法，用于执行中序遍历：

// 树节点定义
type TreeNode struct {
    Val   int
    Left  *TreeNode
    Right *TreeNode
}

// 中序遍历函数
func inorderTraversal(root *TreeNode) []int {
    if root == nil {
        return nil
    }

    stack := []*TreeNode{}
    result := []int{}
    currentNode := root

    for currentNode != nil || len(stack) >  {
        // 将当前节点及其所有左子节点入栈
        for currentNode != nil {
            stack = append(stack, currentNode)
            currentNode = currentNode.Left
        }

        // 弹出栈顶节点并记录其值
        currentNode = stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        result = append(result, currentNode.Val)

        // 处理右子节点
        currentNode = currentNode.Right
    }

    return result
}

这个算法使用了一个栈来存储待处理的节点。首先将根节点及其所有左子节点依次入栈，然后弹出栈顶节点并记录其值，最后处理右子节点。重复这个过程直到栈为空且当前节点为空。

使用这个算法可以实现中序遍历的非递归方式。希望这个代码对你有帮助！

在这里插入图片描述

在这里插入图片描述

chatgpt：

下面是使用栈作为辅助数据结构的非递归中序遍历算法的示例代码：

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

func inorderTraversal(root *TreeNode) []int {
    if root == nil {
        return nil
    }

    stack := []*TreeNode{}
    res := []int{}
    curr := root

    for curr != nil || len(stack) > 0 {
        // 将当前节点及其左子树入栈，直到没有左子节点为止
        for curr != nil {
            stack = append(stack, curr)
            curr = curr.Left
        }
        
        // 弹出栈顶元素，并将其值添加到结果数组中
        top := stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        res = append(res, top.Val)

        // 处理右子树
        curr = top.Right
    }

    return res
}

这个算法使用了一个辅助栈，通过模拟递归过程来实现非递归的中序遍历。具体步骤如下：

1.如果当前节点不为空或者栈不为空，则继续循环。

2.将当前节点以及它的所有左子节点依次入栈，直到当前节点为空。

3.弹出栈顶元素，将其值添加到结果数组中。

4.处理弹出节点的右子节点。

以上是一种常见且简单易懂的方法。另外一种复杂但更简洁的方法是使用 Morris Traversal 算法，它不需要额外的栈空间，但需要对指针进行特殊处理。在此不再赘述。

在这里插入图片描述

在这里插入图片描述

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

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

相关文章

Linux 面试题（一）

Linux 面试题（一）

目录 1、绝对路径用什么符号表示？当前目录、上层目录用什么表示？主目录用什么表示? 切换目录用什么命令？ 2、怎么查看当前进程？怎么执行退出？怎么查看当前路径？ 3、怎么清屏？怎么退出当前命…
阅读更多...
4G模块（EC600N）通过MQTT连接华为云

4G模块（EC600N）通过MQTT连接华为云

目录 一、前言 二、EC600N模块使用 1．透传模式 2．非透传模式 3、华为云的MQTT使用教程： 三、具体连接步骤 1、初始化检测 2、打开MQTT客户端网络 3、创建产品 4、创建模型 5、注册设备 6、连接客户端到MQTT服务器 7、发布主题消…
阅读更多...
【数据分享】我国12.5米分辨率的坡向数据（免费获取）

【数据分享】我国12.5米分辨率的坡向数据（免费获取）

地形数据，也叫DEM数据，是我们在各项研究中最常使用的数据之一。之前我们分享过源于NASA地球科学数据网站发布的12.5米分辨率DEM地形数据！基于该数据我们处理得到12.5米分辨率的坡度数据、12.5米分辨率的山体阴影数据（均可查看之前…
阅读更多...
Python 安装mysqlclient 错误 无法打开包括文件: “mysql.h”: 解决方法

Python 安装mysqlclient 错误 无法打开包括文件: “mysql.h”: 解决方法

解决方案：python最新3.12.0不支持mysqlclient 请下载 python3.9.9 版本 高速下载地址CNPM Binaries Mirror 官方下载地址Welcome to Python.org 下载完成后将python添加到环境变量 pycharm 虚拟环境下的python版本切换到你刚才下载的3.9.9的python版本 Avai…
阅读更多...
nginx相关配置信息

nginx相关配置信息

阅读更多...
C语言标准

C语言标准

1、概述 C语言标准是由ANSI（美国国家标准协会）和ISO（国际标准化组织）共同制定的一种语言规范。标准经历过如下更新： C89/C90标准C99标准C11标准C17标准 2、C89/C90标准 (1)这是1989年正式发布的C语言标准&#xff0…
阅读更多...
使用项目管理工具进行新媒体运营管理的策略与方法

使用项目管理工具进行新媒体运营管理的策略与方法

使用Zoho Projects项目管理工具，新媒体运营可轻松驾驭从策划选题、撰写到排期发布的全流程。运用项目管理工具对新媒体运营进行精细化管理，助力团队更高效地规划、执行和追踪各项任务与活动。 以下是运用项目管理工具管理新媒体运营的妙招： 1…
阅读更多...
Java进阶（第二期）：package 包 抽象类和抽象方法 接口的实现 多态的实现 综合继承、接口、多态的使用。

Java进阶（第二期）：package 包 抽象类和抽象方法 接口的实现 多态的实现 综合继承、接口、多态的使用。

2023年11月26日20:11:11 文章目录 Java进阶（第二期）一、package包的概念二、抽象类和抽象方法(abstract)2.1 使用2.1 抽象类注意事项 三、接口3.1 接口的定义格式3.2 接口成员特点3.3 类和接口的关系3.4 接口和抽象类的对比 四、多态4.1 多态的前提条件4…
阅读更多...
2009年iMac装64位windows7及win10

2009年iMac装64位windows7及win10

2009年iMac装64位windows7及win10 Boot Camp没有“创建 Windows7 或更高版本的安装磁盘”选项 安装完Mac OS系统后，要制作Windows7安装U盘时才发现，Boot Camp没有“创建 Windows7 或更高版本的安装磁盘”选项，搜索到文章：修改Boo…
阅读更多...
Mac 最佳使用指南

Mac 最佳使用指南

如何在macOS系统安装根证书mac Terminal config proxy 【mac 终端配置代理】iPhone 安装 iOS 17公测版（Public Beta)macOS 最佳命令行客户端：iTermMac 配置与 Linux 互信Mac mini 外接移动硬盘无法写入或者无法显示的解决方法如何在 macOS 美化 iterm2 &…
阅读更多...
更改MacBook壁纸，有时可以带来不一样的感觉，特别是动态壁纸

更改MacBook壁纸，有时可以带来不一样的感觉，特别是动态壁纸

在我看来，买一台新的MacBook最棒的部分就是挑选一张完美的桌面壁纸，为我的新工作伙伴定下基调。有时，在真正更换壁纸之前，我会花一整天的时间，仔细决定我的新笔记本电脑到底是什么样子，而且由于Macbook如此…
阅读更多...
《数据结构、算法与应用C++语言描述》-二叉树与其他树-二叉树的C++实现-设置信号放大器与并查集问题

《数据结构、算法与应用C++语言描述》-二叉树与其他树-二叉树的C++实现-设置信号放大器与并查集问题

二叉树和其他树 可编译运行程序见：Github::Jasmine-up/Data-Structures-Algorithms-and-Applications/_23BinaryTree 定义 树 定义 11-1 一棵树 t是一个非空的有限元素的集合，其中一个元素为根（root），其余的元素&a…
阅读更多...
Redis面试题：Redis的数据过期策略有哪些？

Redis面试题：Redis的数据过期策略有哪些？

目录 面试官：Redis的数据过期策略有哪些 ? 惰性删除 定期删除 面试官：Redis的数据过期策略有哪些 ? 候选人： 嗯~，在redis中提供了两种数据过期删除策略 第一种是惰性删除，在设置该key过期时间后，我们…
阅读更多...
6.4 Windows驱动开发：内核枚举DpcTimer定时器

6.4 Windows驱动开发：内核枚举DpcTimer定时器

在操作系统内核中，DPC（Deferred Procedure Call）是一种延迟执行的过程调用机制，用于在中断服务例程（ISR）的上下文之外执行一些工作。DPC定时器是基于DPC机制的一种定时执行任务的方式。 DPC定时器的主要特…
阅读更多...
jsp生成验证码的代码

jsp生成验证码的代码

效果图&#xff1a; loginProcess.jsp <% page language"java" contentType"text/html; charsetUTF-8"pageEncoding"UTF-8"%><% String captcharequest.getParameter("captcha");%><% String captcha_session(String)s…
阅读更多...
记一次Kotlin Visibility Modifiers引发的问题

记一次Kotlin Visibility Modifiers引发的问题

概述 测试环境爆出ERROR告警日志java.lang.IllegalStateException: Didnt find report for specified language&#xff0c;登录测试环境ELK查到如下具体的报错堆栈日志&#xff1a; java.lang.IllegalStateException: Didnt find report for specified language at com.aba.…
阅读更多...
基于51单片机红外遥控定时开关智能家电插座设计

基于51单片机红外遥控定时开关智能家电插座设计

**单片机设计介绍&#xff0c; 基于51单片机超声波测距汽车避障系统 文章目录 一 概要二、功能设计设计思路 三、 软件设计原理图 五、 程序六、 文章目录 一 概要 设计一个基于51单片机红外遥控定时开关智能家电插座是一个涉及多个方面的复杂项目。以下是对该设计的基本介绍&…
阅读更多...
Stm32CubeMx生成代码提示缺少“core_cm3.h“

Stm32CubeMx生成代码提示缺少“core_cm3.h“

Stm32CubeMx生成代码提示缺少"core_cm3.h" 1.原因分析 1.1问题根源 在我们使用本地解压的方法去安装固件包,但是找错了要下载的固件包&#x1f60a;.在你点击进入下载页面之后,能看到一共有两个下载链接,其中上面的是补丁包,而第二个才是我们应该要下载的固件包 当…
阅读更多...
Portraiture2024最新Photoshop磨皮插件更新啦

Portraiture2024最新Photoshop磨皮插件更新啦

Portraiture是一款由Imagenomic公司研发的Photoshop磨皮插件。该插件以其优秀的磨皮效果&#xff0c;成为了众多摄影师和化妆师使用的首选插件。Portraiture主要用于影楼、婚纱、时尚摄影等各个领域。其主要特点是能够轻松地模拟人眼的视觉感受&#xff0c;自然地修饰人像照片。…
阅读更多...
论文笔记--Toolformer: Language Models Can Teach Themselves to Use Tools

论文笔记--Toolformer: Language Models Can Teach Themselves to Use Tools

论文笔记--Toolformer: Language Models Can Teach Themselves to Use Tools 1. 文章简介2. 文章概括3 文章重点技术3.1 Toolformer3.2 APIs 4. 文章亮点5. 原文传送门 1. 文章简介 标题&#xff1a;Toolformer: Language Models Can Teach Themselves to Use Tools作者&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023