[Swift]LeetCode19. 删除链表的倒数第N个节点 | Remove Nth Node From End of List
2024-04-13 06:40:15
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9890204.html
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
Given a linked list, remove the n-th node from the end of list and return its head.
Example:
Given linked list: 1->2->3->4->5, and n = 2.After removing the second node from the end, the linked list becomes 1->2->3->5.
Note:
Given n will always be valid.
Follow up:
Could you do this in one pass?
给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。
示例：
给定一个链表: 1->2->3->4->5, 和 n = 2.当删除了倒数第二个节点后，链表变为 1->2->3->5.
说明：
给定的 n 保证是有效的。
进阶：
你能尝试使用一趟扫描实现吗？
12ms
1 /**
2 * Definition for singly-linked list.
3 * public class ListNode {
4 * public var val: Int
5 * public var next: ListNode?
6 * public init(_ val: Int) {
7 * self.val = val
8 * self.next = nil
9 * }
10 * }
11 */
12 class Solution {
13 func removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
14 var endPointer : ListNode? = head
15 var nFromEndPointer : ListNode? = nil
16 var counter = n
17
18 while endPointer != nil {
19 if counter == 0 {
20 if nFromEndPointer == nil {
21 nFromEndPointer = head
22 } else {
23 nFromEndPointer = nFromEndPointer?.next
24 }
25 }
26
27 endPointer = endPointer?.next
28
29 if counter > 0 {
30 counter -= 1
31 }
32 }
33
34 if nFromEndPointer == nil {
35 if counter == 0 {
36 return head?.next
37 }
38 return nil
39 } else {
40 nFromEndPointer?.next = nFromEndPointer?.next?.next
41 }
42
43 return head
44 }
45 }16ms
1 /**
2 * Definition for singly-linked list.
3 * public class ListNode {
4 * public var val: Int
5 * public var next: ListNode?
6 * public init(_ val: Int) {
7 * self.val = val
8 * self.next = nil
9 * }
10 * }
11 */
12 class Solution {
13 func removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
14 let dummy = ListNode(0)
15 var slow: ListNode? = dummy
16 var fast: ListNode? = dummy
17
18 slow?.next = head
19 for _ in 1...(n + 1) {
20 fast = fast?.next
21 }
22 while fast != nil {
23 slow = slow?.next
24 fast = fast?.next
25 }
26 slow?.next = slow?.next?.next
27
28 return dummy.next
29 }
30 }20ms
1 /**
2 * Definition for singly-linked list.
3 * public class ListNode {
4 * public var val: Int
5 * public var next: ListNode?
6 * public init(_ val: Int) {
7 * self.val = val
8 * self.next = nil
9 * }
10 * }
11 */
12 class Solution {
13 func removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
14 guard let head = head else {
15
16 return nil
17 }
18
19
20 if n == 1 && head.next == nil {
21
22 return nil
23 }
24
25 var cur: ListNode? = head
26 var last: ListNode? = head
27
28 for i in 1..<n {
29
30 last = last?.next
31 }
32
33 var prev: ListNode?
34 while last?.next != nil {
35 prev = cur
36 cur = cur?.next
37 last = last?.next
38 }
39
40 prev?.next = prev?.next?.next
41
42 return prev == nil ? head.next : head
43 }
44 }20ms
1 /**
2 * Definition for singly-linked list.
3 * public class ListNode {
4 * public var val: Int
5 * public var next: ListNode?
6 * public init(_ val: Int) {
7 * self.val = val
8 * self.next = nil
9 * }
10 * }
11 */
12 class Solution {
13 func removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
14 var result:ListNode? = head;
15 var tempNode:ListNode? = result;
16 var tempNode2:ListNode? = result;
17 if head! == nil {
18 return head;
19 }
20
21 var i = 0;
22 while i < n && tempNode!.next != nil {
23 tempNode = tempNode!.next;
24 i += 1;
25 }
26 while (tempNode!.next != nil) {
27 i += 1;
28 tempNode = tempNode!.next;
29 tempNode2 = tempNode2!.next;
30 }
31 if (i + 1 == n) {
32 return result!.next;
33 }else {
34 tempNode2!.next = tempNode2!.next!.next;
35 return result;
36 }
37 }
38 }24ms
1 /**
2 * Definition for singly-linked list.
3 * public class ListNode {
4 * public var val: Int
5 * public var next: ListNode?
6 * public init(_ val: Int) {
7 * self.val = val
8 * self.next = nil
9 * }
10 * }
11 */
12 class Solution {
13 func removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
14 var first: ListNode? = head
15 var n:Int = n
16 while(n-- != 0)
17 {
18 first=first!.next
19 }
20 if first == nil
21 {
22 return head!.next
23 }
24 var sec: ListNode? = head
25 while(first!.next != nil)
26 {
27 sec = sec!.next
28 first = first!.next
29 }
30 sec!.next = sec!.next!.next
31 return head
32 }
33 }
34
35 /*扩展Int类，实现自增++、自减--运算符*/
36 extension Int{
37 //后缀--:先执行表达式后再自减
38 static postfix func --(num:inout Int) -> Int {
39 //输入输出参数num
40 let temp = num
41 //num减1
42 num -= 1
43 //返回减1前的数值
44 return temp
45 }
46 }24ms
1 /**
2 * Definition for singly-linked list.
3 * public class ListNode {
4 * public var val: Int
5 * public var next: ListNode?
6 * public init(_ val: Int) {
7 * self.val = val
8 * self.next = nil
9 * }
10 * }
11 */
12 class Solution {
13 func removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
14 guard let _ = head else {
15 return nil
16 }
17
18 var preNode = head
19 var curNode = head
20 var count: Int = 0
21 while count < n {
22 curNode = curNode?.next
23 count += 1
24 }
25 if curNode == nil {
26 return preNode?.next
27 }
28
29 while let _ = curNode?.next {
30 preNode = preNode?.next
31 curNode = curNode?.next
32 }
33
34 preNode?.next = preNode?.next?.next
35 return head
36 }
37 }28ms
1 /**
2 * Definition for singly-linked list.
3 * public class ListNode {
4 * public var val: Int
5 * public var next: ListNode?
6 * public init(_ val: Int) {
7 * self.val = val
8 * self.next = nil
9 * }
10 * }
11 */
12 class Solution {
13 func removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
14 var resultArray = [ListNode]()
15 var tmpNode = head
16 var resultNode = head
17 repeat {
18 resultArray.append(tmpNode!)
19 tmpNode = tmpNode?.next
20 }while tmpNode != nil
21
22 let arrayCount = resultArray.count
23 if arrayCount == n {
24 resultNode = head?.next
25 return resultNode
26 }
27 resultArray[arrayCount - n - 1].next = resultArray[arrayCount - n].next
28 return resultNode
29 }
30 }转载于:https://www.cnblogs.com/strengthen/p/9890204.html
[Swift]LeetCode19. 删除链表的倒数第N个节点 | Remove Nth Node From End of List相关推荐
- 【链表】leetcode19.删除链表的倒数第N个节点(C/C++/Java/Js)
leetcode19.删除链表的倒数第N个节点 1 题目 2 思路 3 代码 3.1 C++版本 3.2 C版本 3.3 Java版本 3.4 JavaScript版本 4 总结 1 题目 题源链接 ...
- 代码随想录Day04 | LeetCode24. 两两交换链表中的节点、LeetCode19. 删除链表的倒数第N个节点、LeetCode160. 链表相交、LeetCode142. 环形链表Ⅱ
LeetCode24. 两两交换链表中的节点 力扣题目链接 给你一个链表,两两交换其中相邻的节点,并返回交换后链表的头节点.你必须在不修改节点内部的值的情况下完成本题(即,只能进行节点交换). 示例 ...
- LeetCode19删除链表的倒数第N个节点20有效的括号
维护不易,还请点赞支持,微信搜索bigsai 回复进群一起打卡. 19删除链表的倒数第N个节点 给定一个链表,删除链表的倒数第 n 个节点,并且返回链表的头结点. 示例: 给定一个链表: 1-> ...
- LeetCode-19 删除链表的倒数第N个节点
文章目录 题目描述 我的解法 反思 优化 再次反思 再次优化 总结 Github 题目描述 给定一个链表,删除链表的倒数第 n 个节点,并且返回链表的头结点. 示例: 给定一个链表: 1->2- ...
- leetcode19. 删除链表的倒数第N个节点
给定一个链表,删除链表的倒数第 n 个节点,并且返回链表的头结点. 示例: 给定一个链表: 1->2->3->4->5, 和 n = 2. 当删除了倒数第二个节点后,链表变为 ...
- Leetcode--19. 删除链表的倒数第N个节点
给定一个链表,删除链表的倒数第 n 个节点,并且返回链表的头结点. 示例: 给定一个链表: 1->2->3->4->5, 和 n = 2. 当删除了倒数第二个节点后,链表变为 ...
- 2021字节跳动校招秋招算法面试真题解题报告--leetcode19 删除链表的倒数第 n 个结点，内含7种语言答案
2021字节跳动校招秋招算法面试真题解题报告--leetcode19 删除链表的倒数第 n 个结点,内含7种语言答案 1.题目描述 给你一个链表,删除链表的倒数第 n 个结点,并且返回链表的头结点. ...
- 删除链表的倒数第N个节点—leetcode19
给定一个链表,删除链表的倒数第 n 个节点,并且返回链表的头结点. 示例: 给定一个链表: 1->2->3->4->5, 和 n = 2. 当删除了倒数第二个节点后,链表变为 ...
- 刻意练习：LeetCode实战 -- Task11. 删除链表的倒数第N个节点
背景 本篇图文是LSGO软件技术团队组织的 第二期基础算法(Leetcode)刻意练习训练营 的打卡任务.本期训练营采用分类别练习的模式,即选择了五个知识点(数组.链表.字符串.树.贪心算法),每个知 ...
最新文章
- Web漏洞扫描（二：Windows server2008 R2操作系统（部署dvwa））
- 大型网站技术架构（2）：架构要素和高性能架构
- linux搭建--ubuntu使用qemu-kvm，libvirt搭建虚拟机，并搭建libvmi来虚拟机自省（三）
- [转] 新入社員の自己紹介
- oracle中批量更新,oracle 批量更新
- Linux命令整理 —— vi 和 vim 编辑器
- 火车站售票系统_好消息！海门火车站自助售取票机增加自助退票功能
- Ubuntu18.04LTS+Anaconda+Tensorflow-GPU安装记录
- 使用 PHP Curl 做数据中转
- 宽带连接错误 651
- 苹果截屏快捷键_几招Mac快捷键技巧
- Python中的图形绘制——3D绘图
- CS5213芯片|HDMI to VGA转换头芯片资料分享
- SDRAM学习（二）——自动刷新，读写操作
- 如何在安装了VS2010的情况下安装SQL Server 2008
- “量子密话” 我们与量子科技第一次亲密接触
- vi/vim编辑器入门
- 当安全遇上AI 阿里聚安全算法挑战赛完美收官
- mac制作铃声 我要变好看
- 【vue双向绑定原理浅析】
热门文章
- mp4 拍摄时间如何看_时间不多了，如何备考期末最有效？这些复习技巧，看了你就会了...
- 六、pink老师学习笔记——CSS三角形之美 margin负值之美文字围绕浮动元素行内块元素布局的巧妙运用
- 十、关于MySQL 标识列，你该了解这些！
- LeetCode 1181. 前后拼接（哈希map）
- LeetCode 549. 二叉树中最长的连续序列（树上DP）
- LeetCode 361. 轰炸敌人（前缀和DP）
- LeetCode 467. 环绕字符串中唯一的子字符串（思维转换）
- LeetCode 696. 计数二进制子串
- POJ 2259 team queue团队排队问题
- 数据结构--链表--判断一个字符串是否为回文串（单向链表，双向链表）