Golang每日一练(leetDay0048) 链表专题

news2024/11/14 13:31:12

目录

141. 环形链表 Linked List Cycle  🌟

142. 环形链表 II Linked List Cycle II  🌟🌟

143. 重排链表 Reorder List  🌟🌟

🌟 每日一练刷题专栏 🌟

Golang每日一练 专栏

Python每日一练 专栏

C/C++每日一练 专栏

Java每日一练 专栏

141. 环形链表 Linked List Cycle

给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

如果链表中存在环 ，则返回 true 。 否则，返回 false 。

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

提示：

  • 链表中节点的数目范围是 [0, 10^4]
  • -10^5 <= Node.val <= 10^5
  • pos 为 -1 或者链表中的一个 有效索引 。

进阶：你能用 O(1)（即，常量）内存解决此问题吗？

代码1： 快慢指针

package main

import "fmt"

type ListNode struct {
	Val  int
	Next *ListNode
}

func hasCycle(head *ListNode) bool {
	if head == nil || head.Next == nil {
		return false
	}
	slow, fast := head, head.Next
	for slow != fast {
		if fast == nil || fast.Next == nil {
			return false
		}
		slow, fast = slow.Next, fast.Next.Next
	}
	return true
}

func createRingNodeList(nums []int, pos int) *ListNode {
	if len(nums) == 0 {
		return nil
	}
	head := &ListNode{Val: nums[0]}
	tail := head
	for i := 1; i < len(nums); i++ {
		tail.Next = &ListNode{Val: nums[i]}
		tail = tail.Next
	}
	if pos >= 0 {
		p := head
		for pos > 0 {
			p = p.Next
			pos--
		}
		tail.Next = p
	}
	return head
}

func main() {
	nums, pos := []int{3, 2, 0, -4}, 1
	head := createRingNodeList(nums, pos)
	fmt.Println(hasCycle(head))
	nums, pos = []int{1, 2}, 0
	head = createRingNodeList(nums, pos)
	fmt.Println(hasCycle(head))
	nums, pos = []int{1}, -1
	head = createRingNodeList(nums, pos)
	fmt.Println(hasCycle(head))
}

代码2： 哈希表

package main

import "fmt"

type ListNode struct {
	Val  int
	Next *ListNode
}

func hasCycle(head *ListNode) bool {
	visited := make(map[*ListNode]bool)
	for head != nil {
		if visited[head] {
			return true
		}
		visited[head] = true
		head = head.Next
	}
	return false
}

func createRingNodeList(nums []int, pos int) *ListNode {
	if len(nums) == 0 {
		return nil
	}
	head := &ListNode{Val: nums[0]}
	tail := head
	for i := 1; i < len(nums); i++ {
		tail.Next = &ListNode{Val: nums[i]}
		tail = tail.Next
	}
	if pos >= 0 {
		p := head
		for pos > 0 {
			p = p.Next
			pos--
		}
		tail.Next = p
	}
	return head
}

func main() {
	nums, pos := []int{3, 2, 0, -4}, 1
	head := createRingNodeList(nums, pos)
	fmt.Println(hasCycle(head))
	nums, pos = []int{1, 2}, 0
	head = createRingNodeList(nums, pos)
	fmt.Println(hasCycle(head))
	nums, pos = []int{1}, -1
	head = createRingNodeList(nums, pos)
	fmt.Println(hasCycle(head))
}

代码3： 递归

package main

import "fmt"

type ListNode struct {
	Val  int
	Next *ListNode
}

func hasCycle(head *ListNode) bool {
	visited := make(map[*ListNode]bool)
	return checkCycle(head, visited)
}

func checkCycle(head *ListNode, visited map[*ListNode]bool) bool {
	if head == nil {
		return false
	}
	if visited[head] {
		return true
	}
	visited[head] = true
	return checkCycle(head.Next, visited)
}

func createRingNodeList(nums []int, pos int) *ListNode {
	if len(nums) == 0 {
		return nil
	}
	head := &ListNode{Val: nums[0]}
	tail := head
	for i := 1; i < len(nums); i++ {
		tail.Next = &ListNode{Val: nums[i]}
		tail = tail.Next
	}
	if pos >= 0 {
		p := head
		for pos > 0 {
			p = p.Next
			pos--
		}
		tail.Next = p
	}
	return head
}

func main() {
	nums, pos := []int{3, 2, 0, -4}, 1
	head := createRingNodeList(nums, pos)
	fmt.Println(hasCycle(head))
	nums, pos = []int{1, 2}, 0
	head = createRingNodeList(nums, pos)
	fmt.Println(hasCycle(head))
	nums, pos = []int{1}, -1
	head = createRingNodeList(nums, pos)
	fmt.Println(hasCycle(head))
}

输出：

true
true
false

142. 环形链表 II Linked List Cycle II

给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。

提示：

  • 链表中节点的数目范围在范围 [0, 10^4] 内
  • -10^5 <= Node.val <= 10^5
  • pos 的值为 -1 或者链表中的一个有效索引

进阶：你是否可以使用 O(1) 空间解决此题？

代码1： 快慢指针

package main

import "fmt"

type ListNode struct {
	Val  int
	Next *ListNode
}

func detectCycle(head *ListNode) *ListNode {
	if head == nil || head.Next == nil {
		return nil
	}
	slow, fast := head, head
	for fast != nil && fast.Next != nil {
		slow = slow.Next
		fast = fast.Next.Next
		if slow == fast {
			slow = head
			for slow != fast {
				slow = slow.Next
				fast = fast.Next
			}
			return slow
		}
	}
	return nil
}

func createRingNodeList(nums []int, pos int) *ListNode {
	if len(nums) == 0 {
		return nil
	}
	head := &ListNode{Val: nums[0]}
	tail := head
	for i := 1; i < len(nums); i++ {
		tail.Next = &ListNode{Val: nums[i]}
		tail = tail.Next
	}
	if pos >= 0 {
		p := head
		for pos > 0 {
			p = p.Next
			pos--
		}
		tail.Next = p
	}
	return head
}

func showResult(head *ListNode) {
	if detectCycle(head) == nil {
		fmt.Println("null")
	} else {
		fmt.Println(detectCycle(head).Val)
	}
}

func main() {
	nums, pos := []int{3, 2, 0, -4}, 1
	head := createRingNodeList(nums, pos)
	showResult(detectCycle(head))
	nums, pos = []int{1, 2}, 0
	head = createRingNodeList(nums, pos)
	showResult(detectCycle(head))
	nums, pos = []int{1}, -1
	head = createRingNodeList(nums, pos)
	showResult(detectCycle(head))
}

代码2： 哈希表

package main

import "fmt"

type ListNode struct {
	Val  int
	Next *ListNode
}

func detectCycle(head *ListNode) *ListNode {
	visited := make(map[*ListNode]bool)
	for head != nil {
		if visited[head] {
			return head
		}
		visited[head] = true
		head = head.Next
	}
	return nil
}

func createRingNodeList(nums []int, pos int) *ListNode {
	if len(nums) == 0 {
		return nil
	}
	head := &ListNode{Val: nums[0]}
	tail := head
	for i := 1; i < len(nums); i++ {
		tail.Next = &ListNode{Val: nums[i]}
		tail = tail.Next
	}
	if pos >= 0 {
		p := head
		for pos > 0 {
			p = p.Next
			pos--
		}
		tail.Next = p
	}
	return head
}

func showResult(head *ListNode) {
	if detectCycle(head) == nil {
		fmt.Println("null")
	} else {
		fmt.Println(detectCycle(head).Val)
	}
}

func main() {
	nums, pos := []int{3, 2, 0, -4}, 1
	head := createRingNodeList(nums, pos)
	showResult(detectCycle(head))
	nums, pos = []int{1, 2}, 0
	head = createRingNodeList(nums, pos)
	showResult(detectCycle(head))
	nums, pos = []int{1}, -1
	head = createRingNodeList(nums, pos)
	showResult(detectCycle(head))
}

代码3： 数组

package main

import "fmt"

type ListNode struct {
	Val  int
	Next *ListNode
}

func detectCycle(head *ListNode) *ListNode {
	visited := make([]*ListNode, 0)
	for head != nil {
		for _, node := range visited {
			if node == head {
				return node
			}
		}
		visited = append(visited, head)
		head = head.Next
	}
	return nil
}

func createRingNodeList(nums []int, pos int) *ListNode {
	if len(nums) == 0 {
		return nil
	}
	head := &ListNode{Val: nums[0]}
	tail := head
	for i := 1; i < len(nums); i++ {
		tail.Next = &ListNode{Val: nums[i]}
		tail = tail.Next
	}
	if pos >= 0 {
		p := head
		for pos > 0 {
			p = p.Next
			pos--
		}
		tail.Next = p
	}
	return head
}

func showResult(head *ListNode) {
	if detectCycle(head) == nil {
		fmt.Println("null")
	} else {
		fmt.Println(detectCycle(head).Val)
	}
}

func main() {
	nums, pos := []int{3, 2, 0, -4}, 1
	head := createRingNodeList(nums, pos)
	showResult(detectCycle(head))
	nums, pos = []int{1, 2}, 0
	head = createRingNodeList(nums, pos)
	showResult(detectCycle(head))
	nums, pos = []int{1}, -1
	head = createRingNodeList(nums, pos)
	showResult(detectCycle(head))
}

输出：

2
1
null

143. 重排链表 Reorder List

给定一个单链表 L 的头节点 head ，单链表 L 表示为：

L0 → L1 → … → Ln - 1 → Ln

请将其重新排列后变为：

L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …

不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例 1：

输入：head = [1,2,3,4]
输出：[1,4,2,3]

示例 2：

输入：head = [1,2,3,4,5]
输出：[1,5,2,4,3]

提示：

  • 链表的长度范围为 [1, 5 * 10^4]
  • 1 <= node.val <= 1000

代码： 快慢指针 + 反转链表

package main

import "fmt"

type ListNode struct {
	Val  int
	Next *ListNode
}

func reorderList(head *ListNode) {
	if head == nil || head.Next == nil {
		return
	}
	// 快慢指针找到中间节点
	slow, fast := head, head
	for fast.Next != nil && fast.Next.Next != nil {
		slow = slow.Next
		fast = fast.Next.Next
	}
	// 反转后半部分链表
	mid := slow.Next
	slow.Next = nil
	var prev *ListNode
	for mid != nil {
		next := mid.Next
		mid.Next = prev
		prev = mid
		mid = next
	}
	// 合并两个链表
	p1, p2 := head, prev
	for p2 != nil {
		next1 := p1.Next
		next2 := p2.Next
		p1.Next = p2
		p2.Next = next1
		p1 = next1
		p2 = next2
	}
}

func createNodeList(nums []int) *ListNode {
	if len(nums) == 0 {
		return nil
	}
	head := &ListNode{Val: nums[0]}
	tail := head
	for i := 1; i < len(nums); i++ {
		tail.Next = &ListNode{Val: nums[i]}
		tail = tail.Next
	}
	return head
}

func (head *ListNode) travel() {
	for p := head; p != nil; p = p.Next {
		fmt.Print(p.Val)
		if p.Next != nil {
			fmt.Print("->")
		}
	}
	fmt.Println("<nil>")
}

func main() {
	nums := []int{1, 2, 3, 4}
	head := createNodeList(nums)
	head.travel()
	reorderList(head)
	head.travel()
	nums = []int{1, 2, 3, 4, 5}
	head = createNodeList(nums)
	head.travel()
	reorderList(head)
	head.travel()
}

输出：

1->2->3->4<nil>
1->4->2->3<nil>
1->2->3->4->5<nil>
1->5->2->4->3<nil>

🌟 每日一练刷题专栏 🌟

✨ 持续，努力奋斗做强刷题搬运工！

👍 点赞，你的认可是我坚持的动力！ 

🌟 收藏，你的青睐是我努力的方向！ 

✎ 评论，你的意见是我进步的财富！  

☸ 主页：https://hannyang.blog.csdn.net/ 

Golang每日一练 专栏

Python每日一练 专栏

C/C++每日一练 专栏

Java每日一练 专栏

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

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

相关文章

全光谱防蓝光护眼灯有用吗？怎么分辨是全光谱灯

全光谱防蓝光护眼灯有用吗？怎么分辨是全光谱灯

每个人的家里都有一两个台灯&#xff0c;孩子用来学习&#xff0c;老人用来阅读。但台灯不仅仅是用来照明而已&#xff0c;还需要呵护我们的双眼。现在的孩子患近视的人越来越多&#xff0c;很多小学生都戴上了眼镜&#xff0c;而老年人老花眼白内障的患者也在攀升&#xff0c;…
阅读更多...
华三（H3C）GRE OVER IPsec实验

华三（H3C）GRE OVER IPsec实验

实验拓扑 目录 实验需求 1. 某企业北京总部、上海分支、武汉分支分别通过 R1&#xff0c;R3&#xff0c;R4 接入互联网&#xff0c;配置默认路由连通公网 2. 按照图示配置 IP 地址&#xff0c;R1&#xff0c;R3&#xff0c;R4 分别配置 Loopback0 口匹配感兴趣流&#xff0…
阅读更多...
电子行业数字工厂管理系统有哪些优点和不足

电子行业数字工厂管理系统有哪些优点和不足

随着制造业的不断发展&#xff0c;其生产技术也在不断改进&#xff0c;有许多电子企业都在部署数字工厂管理系统&#xff0c;进行数字化转型。如果不了解数字工厂管理系统&#xff0c;盲目部署的话&#xff0c;容易走很多弯路。本文将跟大家探讨一下&#xff0c;电子行业数字工…
阅读更多...
本地Linux服务器安装宝塔面板，并公网远程登录

本地Linux服务器安装宝塔面板，并公网远程登录

文章目录 前言1. 安装宝塔2. 安装cpolar内网穿透3. 远程访问宝塔4. 固定http地址5. 配置二级子域名6. 测试访问二级子域名 前言 宝塔面板作为建站运维工具&#xff0c;它支持一键LAMP/LNMP/集群/监控/网站/FTP/数据库/JAVA等100多项服务器管理功能&#xff0c;可提高运维效率。…
阅读更多...
云原生｜Packer插件开发在项目中应用

云原生｜Packer插件开发在项目中应用

作者&#xff1a;李冠军 神州数码云基地 高级后端开发工程师 云时代我们可以在各云厂商控制台点一点&#xff0c;实例就生成了&#xff0c;但是这个点还是需要自己去点&#xff0c;如果把这些动作写成代码&#xff0c;直接运行&#xff0c;一切就完成了。 这就是Packer的作用…
阅读更多...
使用Markdown编辑器

使用Markdown编辑器

使用Markdown编辑器 欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题&#xff0c;有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants 创建一个自定义列表如何创建一个注…
阅读更多...
总结833

总结833

学习目标&#xff1a; 4月&#xff08;复习完高数18讲内容&#xff0c;背诵21篇短文&#xff0c;熟词僻义300词基础词&#xff09; 学习内容&#xff1a; 暴力英语&#xff1a;背《美丽心灵》&#xff0c;背《大独裁者》五六段&#xff0c;六百四十字的文章&#xff0c;明天加…
阅读更多...
Java中的序列化与反序列化

Java中的序列化与反序列化

序列化和反序列化作为 Java 里一个较为基础的知识点&#xff0c;但我相信很多人能了解的也就是那么几句而已&#xff0c;甚至都不了解&#xff0c;如果再深究问一下 Java 如何实现序列化和反序列化的&#xff0c;就可能不知所措了&#xff01; 不知道怎么说好&#xff0c;什么是…
阅读更多...
GD（兆易创新）系列FLASH进行FPGA和ZYNQ配置固化相关操作

GD（兆易创新）系列FLASH进行FPGA和ZYNQ配置固化相关操作

写在前面 本文主要针对使用GD&#xff08;兆易创新&#xff09;系列的FLASH做启动配置片时&#xff0c;遇到的相关问题进行简单整理复盘&#xff0c;避免后人踩坑。 本人操作固化芯片型号为&#xff1a;ZYNQ7045、690T&#xff08;复旦微替代型号V7 690T&#xff09;。 7系列…
阅读更多...
为类创建事务码，读取EXCEL并显示报表简单版

为类创建事务码，读取EXCEL并显示报表简单版

屏幕以及字段定义 DATA: go_container TYPE REF TO cl_gui_custom_container. DATA: lv_subrc TYPE i,gv_action TYPE int4,lt_filetab TYPE filetable,ls_filetab TYPE file_table.DATA: gv_exit TYPE flag . DATA: lt_input TYPE TABLE OF alsmex_tabline,…
阅读更多...
人脸识别概述

人脸识别概述

博主简介 博主是一名大二学生&#xff0c;主攻人工智能研究。感谢让我们在CSDN相遇&#xff0c;博主致力于在这里分享关于人工智能&#xff0c;c&#xff0c;Python&#xff0c;爬虫等方面知识的分享。 如果有需要的小伙伴可以关注博主&#xff0c;博主会继续更新的&#xff0c…
阅读更多...
封装 (encapsulation)--计算机程序术语

封装 (encapsulation)--计算机程序术语

封装&#xff0c;即隐藏对象的属性和实现细节&#xff0c;仅对外公开接口&#xff0c;控制在程序中属性的读和修改的 访问级别&#xff1b;将抽象得到的数据和行为(或功能)相结合&#xff0c;形成一个有机的整体&#xff0c;也就是将数据与操作数据的 源代码进行有机的结合&…
阅读更多...
以轻量级服务器niginx为核心的JavaWeb项目：第一章 项目设计

以轻量级服务器niginx为核心的JavaWeb项目：第一章 项目设计

这里写目录标题 一 需求分析与环境搭建1.需求分析2.环境搭建1.2.1首先配置mysql环境1.2.2 配置maven环境 二 打成War包&#xff0c;发到linux上 一 需求分析与环境搭建 1.需求分析 2.环境搭建 1.2.1首先配置mysql环境 先查找一下mysql环境 [roothadoop122 ~]# mysql --vers…
阅读更多...
SpringCloudAlibaba分布式事务——Seata

SpringCloudAlibaba分布式事务——Seata

Seata 本专栏学习内容来自尚硅谷周阳老师的视频 有兴趣的小伙伴可以点击视频地址观看 分布式事务问题 在使用分布式之前&#xff0c;一般都是单机单库或者是单机多库的情况&#xff0c;一个服务对应一个数据库或者多个数据库&#xff0c;这样事务的问题可以通过Transaction解决…
阅读更多...
Python学习：Anaconda23.3.1+spyder5.4.3+Python3.10.11环境配置

Python学习：Anaconda23.3.1+spyder5.4.3+Python3.10.11环境配置

问题1&#xff1a;Anaconda安装配置教程&#xff08;真的非常详细的安装过程&#xff0c;还带环境配置&#xff09; 【参考文献】本文链接&#xff1a;Windows安装Anaconda使用教程_在奋斗的大道的博客-CSDN博客 问题2&#xff1a;Anaconda半天打不开&#xff0c;就在这转啊转…
阅读更多...
MYSQL(六)函数

MYSQL(六)函数

函数是指一段可以直接被另一端程序调用的代码 字符串函数 update employees set workn lpad(workno,5, 0); 数值函数 根据数据库的函数&#xff0c;生成一个六位数的随机验证码 select rpad(round(rand()*1000000, 0), 6, 0); 日期函数 流程函数
阅读更多...
尚融宝24-标的管理

尚融宝24-标的管理

目录 一、需求介绍 &#xff08;一&#xff09;借款人申请借款 &#xff08;二&#xff09;流程 二、生成新标的 三、标的列表 &#xff08;一&#xff09;后端 &#xff08;二&#xff09;前端 四、标的详情 &#xff08;一&#xff09;后端 &#xff08;二&#xf…
阅读更多...
FPGA动态配置si5338输出差分时钟，提供工程源码和技术支持

FPGA动态配置si5338输出差分时钟，提供工程源码和技术支持

目录 1、前言2、设计框图3、si5338原理图设计4、si5338使用流程5、vivado工程详解6、上板调试验证并演示7、福利&#xff1a;工程代码的获取 1、前言 如今的FPGA板卡随着FPGA本身性能的提高也越来越高端&#xff0c;特别是在高速接口方面表现得越发明显&#xff0c;以Xilinx的…
阅读更多...
Redis（10）哨兵

Redis（10）哨兵

redis哨兵 哨兵配置步骤步骤一 启动redis节点步骤二 配置哨兵节点第三步 设置主从复制第四步 查看状态第五步 验证哨兵配置是否成功第六步 测试 哨兵配置步骤 本文将介绍redis哨兵的配置步骤。Redis哨兵是一种用于监控Redis主从复制和自动故障转移的系统 Redis哨兵是Redis的核…
阅读更多...
“探索C++非质变算法：如何更高效地处理数据“

“探索C++非质变算法：如何更高效地处理数据“

&#x1f4d6;作者介绍&#xff1a;22级树莓人&#xff08;计算机专业&#xff09;&#xff0c;热爱编程&#xff1c;目前在c&#xff0b;&#xff0b;阶段>——目标Windows&#xff0c;MySQL&#xff0c;Qt&#xff0c;数据结构与算法&#xff0c;Linux&#xff0c;多线程&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023