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

news2025/1/20 20:02:23

五、用go语言，栈插入和删除元素只能在同一端进行，队列的插入操作和删除操作分别在两端进行，与它们不同的，有一种双端队列(deque)，其插入和删除操作都可以在两端进行。写出4个时间均为 O(1)的过程，分别实现在双端队列的两端插入和删除元素的操作，该队列是用一个数组实现的。

文心一言：

在 Go 语言中，我们可以使用切片（slice）来实现双端队列（deque）。这是因为切片可以在 O(1) 时间内进行头部和尾部的插入和删除操作。

以下是实现的代码：

package main  
  
import "fmt"  
  
type Deque struct {  
    elements []int  
}  
  
// 创建一个新的双端队列  
func NewDeque() *Deque {  
    return &Deque{}  
}  
  
// 在队列的头部插入一个元素  
func (d *Deque) InsertFront(value int) {  
    d.elements = append([]int{value}, d.elements...)  
}  
  
// 在队列的尾部插入一个元素  
func (d *Deque) InsertBack(value int) {  
    d.elements = append(d.elements, value)  
}  
  
// 从队列的头部删除一个元素  
func (d *Deque) RemoveFront() {  
    if len(d.elements) > 0 {  
        d.elements = d.elements[1:]  
    }  
}  
  
// 从队列的尾部删除一个元素  
func (d *Deque) RemoveBack() {  
    if len(d.elements) > 0 {  
        d.elements = d.elements[:len(d.elements)-1]  
    }  
}  
  
func main() {  
    deque := NewDeque()  
    deque.InsertBack(1)  
    deque.InsertBack(2)  
    deque.InsertFront(0)  
    fmt.Println(deque.elements) // Output: [0 1 2]  
    deque.RemoveBack()  
    fmt.Println(deque.elements) // Output: [0 1]  
    deque.RemoveFront()  
    fmt.Println(deque.elements) // Output: [1]  
}

在这个实现中，InsertFront 和 InsertBack 方法分别在双端队列的头部和尾部插入一个元素，而 RemoveFront 和 RemoveBack 方法则分别从双端队列的头部和尾部删除一个元素。所有这些操作的时间复杂度都是 O(1)。

在这里插入图片描述

在这里插入图片描述

讯飞星火：

以下是使用Go语言实现的双端队列（deque）的四个时间复杂度为O(1)的操作：

package main

import "fmt"

type Node struct {
    value interface{}
    next  *Node
    prev  *Node
}

type Deque struct {
    head *Node
    tail *Node
}

// 在队列头部插入元素
func (dq *Deque) PushFront(value interface{}) {
    newNode := &Node{value: value}
    if dq.head == nil {
        dq.head = newNode
        dq.tail = newNode
    } else {
        newNode.next = dq.head
        dq.head.prev = newNode
        dq.head = newNode
    }
}

// 在队列尾部插入元素
func (dq *Deque) PushBack(value interface{}) {
    newNode := &Node{value: value}
    if dq.tail == nil {
        dq.head = newNode
        dq.tail = newNode
    } else {
        newNode.prev = dq.tail
        dq.tail.next = newNode
        dq.tail = newNode
    }
}

// 从队列头部删除元素
func (dq *Deque) PopFront() interface{} {
    if dq.head == nil {
        return nil
    }
    value := dq.head.value
    dq.head = dq.head.next
    if dq.head != nil {
        dq.head.prev = nil
    } else {
        dq.tail = nil
    }
    return value
}

// 从队列尾部删除元素
func (dq *Deque) PopBack() interface{} {
    if dq.tail == nil {
        return nil
    }
    value := dq.tail.value
    dq.tail = dq.tail.prev
    if dq.tail != nil {
        dq.tail.next = nil
    } else {
        dq.head = nil
    }
    return value
}

func main() {
    dq := &Deque{}
    dq.PushFront(1)
    dq.PushBack(2)
    fmt.Println(dq.PopFront()) // 输出：2
    fmt.Println(dq.PopBack())  // 输出：1
}

以上代码实现了一个双端队列（deque），其中PushFront方法用于在队列头部插入元素，PushBack方法用于在队列尾部插入元素，PopFront方法用于从队列头部删除元素，PopBack方法用于从队列尾部删除元素。这些操作的时间复杂度均为O(1)。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

360智脑：

以下是在双端队列的两端插入和删除元素的时间均为 O(1) 的过程:

  1. 在队列的一端插入元素:
func insertFront(q *Deque, x interface{}) {
    n := q.Front.Value.(int)
    if n == 0 {
        q.Front = q.Back
        q.Back = &Node{Value: make([]byte, 1)}
    } else if n == 1 {
        q.Front.Value = &Node{Value: make([]byte, 1)}
    } else {
        q.Front.Value.(*Node).Value = x
        q.Front = &Node{Value: make([]byte, 1)}
    }
}
  1. 在队列的另一端插入元素:
func insertRear(q *Deque, x interface{}) {
    n := q.Back.Value.(int)
    if n == 0 {
        q.Front = q.Back
        q.Back = &Node{Value: make([]byte, 1)}
    } else if n == 1 {
        q.Back.Value = &Node{Value: make([]byte, 1)}
    } else {
        q.Back.Value.(*Node).Value = x
        q.Back = &Node{Value: make([]byte, 1)}
    }
}
  1. 从队列的一端删除元素:
func removeFront(q *Deque, x interface{}) {
    n := q.Front.Value.(int)
    if n == 0 {
        q.Front = q.Back
        q.Back = &Node{Value: make([]byte, 1)}
    } else if n == 1 {
        q.Front.Value = &Node{Value: make([]byte, 1)}
    } else {
        q.Front.Value.(*Node).Value = nil
        q.Front = &Node{Value: make([]byte, 1)}
    }
}
  1. 从队列的另一端删除元素:
func removeRear(q *Deque, x interface{}) {
    n := q.Back.Value.(int)
    if n == 0 {
        q.Front = q.Back
        q.Back = &Node{Value: make([]byte, 1)}
    } else if n == 1 {
        q.Front.Value = &Node{Value: make([]byte, 1)}
    } else {
        q.Back.Value.(*Node).Value = nil
        q.Back = &Node{Value: make([]byte, 1)}
    }
}

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

智谱清言：

为了实现双端队列 (deque) 的两端插入和删除操作，我们可以使用一个长度为 2 的数组来实现。其中一个数组用于存储队列的头部，另一个数组用于存储队列的尾部。当头部数组的最后一个位置被占满时，我们需要从头部数组的第一个位置开始存储新的元素。同样，当尾部数组的第一个位置被占满时，我们需要从尾部数组的最后一个位置开始存储新的元素。

以下是用 Go 语言实现双端队列的两端插入和删除操作的代码：

package main
import "fmt"
type Deque struct {  
	head [1]int  
	tail [1]int  
	size  int  
}
func (d *Deque) PushFront(value int) {  
	if d.size == 0 {  
		d.head[0] = value  
	} else {  
		d.head[0] = value  
		d.head[1] = d.head[0]  
		d.head[0] = d.head[1]  
		d.head[1] = value  
	}  
	d.size++  
}
func (d *Deque) PushBack(value int) {  
	if d.size == 0 {  
		d.tail[0] = value  
	} else {  
		d.tail[0] = value  
		d.tail[1] = d.tail[0]  
		d.tail[0] = d.tail[1]  
		d.tail[1] = value  
	}  
	d.size++  
}
func (d *Deque) PopFront() int {  
	if d.size == 0 {  
		return 0  
	}  
	value := d.head[0]  
	d.head[0] = d.head[1]  
	d.head[1] = value  
	d.size--  
	return value  
}
func (d *Deque) PopBack() int {  
	if d.size == 0 {  
		return 0  
	}  
	value := d.tail[0]  
	d.tail[0] = d.tail[1]  
	d.tail[1] = value  
	d.size--  
	return value  
}
func main() {  
	deque := Deque{}  
	deque.PushFront(1)  
	deque.PushFront(2)  
	deque.PushBack(3)  
	deque.PushBack(4)  
	fmt.Println(deque.PopFront()) // 输出 2  
	fmt.Println(deque.PopFront()) // 输出 1  
	fmt.Println(deque.PopBack()) // 输出 4  
	fmt.Println(deque.PopBack()) // 输出 3  
}

在这个实现中，我们使用了四个时间复杂度为 O(1) 的过程来实现双端队列的两端插入和删除操作。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

通义千问：

双端队列是一种特殊的队列，可以在队列的两端进行插入和删除操作，以下是在双端队列的两端插入和删除元素的操作的四个时间均为 O(1)的过程，该队列是用一个数组实现的：

1.在队列的前端插入元素：首先检查队列是否已满，如果已满则返回错误。然后检查队列是否为空，如果为空则将队列的大小增加一，将新元素添加到队列的开始位置。最后，将队列的前端指针前移一位。

2.在队列的后端插入元素：首先检查队列是否已满，如果已满则返回错误。然后检查队列是否为空，如果为空则将队列的大小增加一，将新元素添加到队列的末尾位置。最后，将队列的后端指针后移一位。

3.在队列的前端删除元素：首先检查队列是否为空，如果为空则返回错误。然后，将队列的前端指针前移一位，并返回队列的开始位置的元素。

4.在队列的后端删除元素：首先检查队列是否为空，如果为空则返回错误。然后，将队列的后端指针后移一位，并返回队列的末尾位置的元素。

以上四个过程的时间复杂度均为 O(1)，因为它们只涉及到指针的移动和数组的大小调整，这些操作的时间复杂度均为常数时间。

在这里插入图片描述

天工：

下面是使用 Go 语言实现的双端队列，支持在队首和队尾进行插入和删除操作：

package main

import "fmt"

type Deque struct {
    items []int
}

func NewDeque() *Deque {
    return &Deque{}
}

func (d *Deque) Front() int {
    if len(d.items) == 0 {
        return -1
    }
    return d.items[0]
}

func (d *Deque) Rear() int {
    if len(d.items) == 0 {
        return -1
    }
    return d.items[len(d.items)-1]
}

func (d *Deque)

在这里插入图片描述

chatgpt：

以下是使用数组实现的双端队列的四个时间复杂度为O(1)的操作：

1.在队列前端插入元素（push_front）：

  • 创建一个新的临时数组tmp，长度比原数组多1。

  • 将要插入的元素赋值给tmp的第一个位置。

  • 将原数组中的所有元素依次赋值给tmp中对应的位置（原数组下标+1）。

  • 将tmp赋值给原数组。

  • 更新队列长度。

2.在队列前端删除元素（pop_front）：

  • 创建一个新的临时数组tmp，长度比原数组少1。

  • 将原数组中除了第一个元素以外的所有元素依次赋值给tmp中对应的位置（原数组下标-1）。

  • 将tmp赋值给原数组。

  • 更新队列长度。

3.在队列后端插入元素（push_back）：

  • 将要插入的元素赋值给原数组的队列长度位置（最后一个元素的下一个位置）。

  • 更新队列长度。

4.在队列后端删除元素（pop_back）：

  • 将原数组的最后一个元素置为空。

  • 更新队列长度。

请注意，这里的时间复杂度为O(1)是指在插入或删除操作内部的操作数量与数组的大小无关，即不随着队列元素数量的增加而增加。通过对数组的封装和移动元素的操作，可以实现这种操作复杂度。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

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

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

相关文章

Python之字符串分割替换移除

Python之字符串分割替换移除

Python之字符串分割替换移除 分割 split(sepNone, maxsplit-1) -> list of strings 从左至右sep 指定分割字符串，缺省的情况下空白字符串作为分隔符maxsplit 指定分割的次数，-1 表示遍历整个字符串立即返回列表 rsplit(sepNone, maxsplit-1) -> …
阅读更多...
【熬夜爆肝版】JAVA基础入门专栏——1.JAVA开发入门

【熬夜爆肝版】JAVA基础入门专栏——1.JAVA开发入门

JAVA开发入门 1、Java概述1）起源2）特点3）应用领域 2、JDK1）定义2）作用3）组成4）JDK版本与兼容性5）JDK的安装与配置6）JDK的发行版 3、系统环境变量1）定义2&…
阅读更多...
【Java项目推荐之黑马头条】你的登录鉴权业务是怎么实现的？

【Java项目推荐之黑马头条】你的登录鉴权业务是怎么实现的？

前言 在学习Java的路上还是遇到了很多不错的好项目的，今天分享给大家，希望能对大家面试有所帮助！ 后续会继续推荐其他好的项目，这次推荐的是B站开源的视频黑马头条项目，来吧学会它一起去虐面试官！&#x…
阅读更多...
【C语言初阶】初识C语言

【C语言初阶】初识C语言

目录 一、什么是C语言 二、第一个C语言程序 三、数据类型 类型的使用： 四、变量、常量 4.1 定义变量的方法 4.2 变量的命名 4.3 变量的分类 4.4 变量的使用 4.5 变量的作用域和生命周期 4.5.1 作用域 4.5.2 生命周期 4.6 常量 五、字符串转义字符注释 …
阅读更多...
【计算机组成 课程笔记】7.2 DRAM和SRAM

【计算机组成 课程笔记】7.2 DRAM和SRAM

课程链接： 计算机组成_北京大学_中国大学MOOC(慕课) 7 - 2 - 702-DRAM和SRAM（13-22--）_哔哩哔哩_bilibili 从【计算机组成 课程笔记】7.1 存储层次结构概况_Elaine_Bao的博客-CSDN博客中，我们了解到：SRAM比较快&#x…
阅读更多...
x64内核实验5-API进0环

x64内核实验5-API进0环

x64内核实验5-API进0环 今天开始我们来分析系统api进0环的过程 系统调用3环部分的过程分析 先写一个应用程序然后我们调用一个readprocessmemory的系统api #include <Windows.h> #include <stdio.h>DWORD32 testVal 111;int main() {HANDLE h GetCurrentProc…
阅读更多...
DatenLord前沿技术分享 No.36

DatenLord前沿技术分享 No.36

达坦科技专注于打造新一代开源跨云存储平台DatenLord&#xff0c;通过软硬件深度融合的方式打通云云壁垒&#xff0c;致力于解决多云架构、多数据中心场景下异构存储、数据统一管理需求等问题&#xff0c;以满足不同行业客户对海量数据跨云、跨数据中心高性能访问的需求。在本周…
阅读更多...
ChatGPT已进化到会看图和说话了，上教程

ChatGPT已进化到会看图和说话了，上教程

HI&#xff0c;同学们&#xff0c;我是赤辰&#xff0c;本期是第14篇AI工具类教程&#xff0c;文章底部准备了粉丝福利&#xff0c;看完后可领取&#xff01; ChatGPT又又又升级&#xff01;这次是支持语音聊天和图像问答。 这意味着用户现在除了键盘文本输入外&#xff0c;还可…
阅读更多...
【JavaEE】多线程进阶（一）饿汉模式和懒汉模式

【JavaEE】多线程进阶（一）饿汉模式和懒汉模式

多线程进阶&#xff08;一&#xff09; 文章目录 多线程进阶&#xff08;一&#xff09;单例模式饿汉模式懒汉模式 本篇主要引入多线程进阶的单例模式&#xff0c;为后面的大冰山做铺垫 代码案例介绍 单例模式 非常经典的设计模式 啥是设计模式 设计模式好比象棋中的 “棋谱”…
阅读更多...
三一充填泵：煤矿矸石无害化充填，煤炭绿色高效开采的破局利器

三一充填泵：煤矿矸石无害化充填，煤炭绿色高效开采的破局利器

富煤贫油少气是我国的能源禀赋特征&#xff0c;决定了我国以煤炭为主的能源结构&#xff0c;煤炭为国民经济发展提供了重要的基础。煤炭开采过程会对土地、地下水、空气等环境造成较大的污染&#xff0c;但大宗固废煤矸石无害化充填的技术手段可以有效改善这样的情况&#xff0…
阅读更多...
LabVIEW使用机器学习分类模型探索基于技能课程的学习

LabVIEW使用机器学习分类模型探索基于技能课程的学习

LabVIEW使用机器学习分类模型探索基于技能课程的学习 教育中的学习评估对教育工作者来说是一项繁琐的工作&#xff0c;但评估的好处是显着的。由于其开放性和复杂性&#xff0c;使用传统的评估方法为学生提供及时的支持一直具有挑战性。在Covid-19大流行期间突然转向在线学习&…
阅读更多...
总结二：linux面经

总结二：linux面经

文章目录 1、 Linux中查看进程运行状态的指令、查看内存使用情况的指令、tar解压文件的参数。2、文件权限怎么修改&#xff1f;3、说说常用的Linux命令&#xff1f;4、说说如何以root权限运行某个程序&#xff1f;5、 说说软链接和硬链接的区别&#xff1f;6、说说静态库和动态…
阅读更多...
QT聊天室阶段性记录（完善中：注册功能，数据库存储）

QT聊天室阶段性记录（完善中：注册功能，数据库存储）

server.h #ifndef SERVERDEMO_H #define SERVERDEMO_H#include <QObject> #include <QTcpServer> #include <QMap> #include <QSqlDatabase> //数据库管理类 #include <QSqlQuery> //执行sql语句的类 #include <QSqlRecord> //数据库…
阅读更多...
最全MacBook选购指南 | 看完你就知道怎么买

最全MacBook选购指南 | 看完你就知道怎么买

最全MacBook选购指南 | 看完你就知道怎么买 作为MacBook的老用户大大小小的型号也都用了不少 那这么多台MacBook到底怎么选呢&#x1f4a1; . ☑️M1和Intel的MacBook有什么差别呢&#xff1f; 下半年苹果发布的两款MacBook都是苹果自研的芯片M1。在此之前苹果一直用的都是Inte…
阅读更多...
解决报错：模块“react-redux“没有导出的成员“TypedUseSelectorHook”

解决报错：模块“react-redux“没有导出的成员“TypedUseSelectorHook”

在react整合typescript,redux时&#xff0c;写hook.ts时报这个错&#xff1a;模块"react-redux"没有导出的成员“TypedUseSelectorHook” 现象如下&#xff1a; 原因&#xff1a;react-redux版本太低&#xff0c;至少要升级到7.2.3以后才能包含TypedUseSelectorHook…
阅读更多...
汇编指令集合

汇编指令集合

阅读更多...
Clion中使用C/C++开发stm32程序

Clion中使用C/C++开发stm32程序

前言 从刚开始学习阶段&#xff0c;一直是用的keil5开发stm32程序&#xff0c;自从看到稚晖君推荐的CLion开发嵌入式程序后&#xff0c;这次尝试在CLion上开发stm32程序。 1、配置CLion用于STM32开发的环境 这里我就不详细写了&#xff0c;没必要重新写&#xff0c;网上教程很多…
阅读更多...
【Java项目推荐之黑马头条】自媒体文章实现异步上下架（使用Kafka中间件实现）

【Java项目推荐之黑马头条】自媒体文章实现异步上下架（使用Kafka中间件实现）

自媒体文章上下架功能完成 需求分析 流程说明 接口定义 说明接口路径/api/v1/news/down_or_up请求方式POST参数DTO响应结果ResponseResult DTO Data public class WmNewsDto {private Integer id;/*** 是否上架 0 下架 1 上架*/private Short enable;}ResponseResult 自媒…
阅读更多...
哈希/散列--哈希表[思想到结构][==完结版==]

哈希/散列--哈希表[思想到结构][==完结版==]

文章目录 1.何为哈希?1.1百度搜索1.2自身理解1.3哈希方法/散列方法1.4哈希冲突/哈希碰撞1.5如何解决?哈希函数的设计 2.闭散列和开散列2.1闭散列/开放定址法2.2开散列/链地址法/开链法1.概念2.容量问题3.字符串问题4.开散列性能测试5.开散列与闭散列比较 3.代码实现[配备详细…
阅读更多...
【Luckfox pico入门记录（一）】开发环境与工具链

【Luckfox pico入门记录（一）】开发环境与工具链

写在前面 最近刷bilibili发现微雪电子关于luckyfox pico的介绍视频&#xff0c;感叹linux开发板居然可以把价格缩到100RMB以内&#xff0c;也正巧结束了复旦微比赛&#xff0c;受够了FM33LC046N的低性能&#xff0c;来玩点便宜又高性能的板子。   开发板型号&#xff1a;luck…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023