[Swift]LeetCode19. 删除链表的倒数第N个节点 | Remove Nth Node From End of List

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号:山青咏芝(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?

给定一个链表,删除链表的倒数第 个节点,并且返回链表的头结点。

示例:

给定一个链表: 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

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

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

CAS

cas&#xff1a;Compare and Swap&#xff0c;即比较再交换。 对CAS的理解&#xff0c;CAS是一种无锁算法&#xff0c;CAS有3个操作数&#xff0c;内存值V&#xff0c;旧的预期值A&#xff0c;要修改的新值B。当且仅当预期值A和内存值V相同时&#xff0c;将内存值V修改为B&…

大脑使用交叉存储,来区分现在和过去

来源&#xff1a;混沌巡洋舰在每一个清醒的时刻&#xff0c;人类和其他动物必须在我们对过去的记忆和对现在的意识两者中保持平衡。我们必须吸收关于周围世界的新的感官信息&#xff0c;同时保持对早期观察或事件的短期记忆。我们理解周围环境、学习、行动和思考的能力都依赖于…

CONTINUE...? ZOJ - 4033

CONTINUE...? ZOJ - 4033 题解&#xff1a;先计算一下总数sum是否是偶数&#xff0c;如果不是则不能分出来&#xff0c;如果是则从后面开始分&#xff0c;先把人分到1、3组&#xff0c;分完sum / 2这些人&#xff0c;如果恰好能够分成零&#xff0c;那么剩下前面的都分到2、4组…

对象在内存中的存储布局

对象头包含&#xff1a; markword(和锁相关的信息) 8字节 class pointer(说明对象属于哪个类)&#xff0c;jvm指针八字节&#xff0c;但是默认压缩&#xff0c;所有4个字节 对象体包含&#xff1a; instance word实例数据(例如int&#xff0c;这就占四个字节&#xff0c;l…

用研究新范式破解生命科学难题

来源&#xff1a;中国科学报 作者&#xff1a;丛斌&#xff08;中国工程院士&#xff09;采访整理&#xff1a;张思玮&#xff08;本报记者&#xff09;当今&#xff0c;世界科技正处于重大变革前夕。各领域科学家们一直积极地探索物质本质、宇宙本源、生命本质&#xff0c;并迫…

synchronized与volatile

synchronized实现过程&#xff1a; 1.Java代码&#xff1a;synchronized 2.字节码层级&#xff1a;monitorenter&#xff0c;monitorexit 3.执行过程中自动升级&#xff08;偏向->自旋->重量级锁&#xff09; 4.cpu汇编层级:lock comxchg 上图为双核cpu的内部构造&am…

redis 字符串数据(string)

Redis 字符串数据类型的相关命令用于管理 redis 字符串值&#xff0c;基本语法如下&#xff1a; 语法 redis 127.0.0.1:6379> COMMAND KEY_NAME 实例 redis 127.0.0.1:6379> SET runoobkey redis OK redis 127.0.0.1:6379> GET runoobkey "redis" 在以上实例…

AI 技术与人类主体想象 ——基于人工直觉在线讨论的研究

来源&#xff1a; 人工智能哲学探索作者&#xff1a;雅克布约翰森&#xff08;英国圣玛丽大学&#xff09; 王鑫&#xff08;辽宁大学&#xff09;一、引言:AI、神经形态硬件、人工直觉AI 在媒体上的讨论越来越多,很多广为流行的专业网站上的相关探讨涵盖了 AI 发展的最新趋势和…

Java四种引用

强引用&#xff1a;没有使用时调用System.gc()会回收 eg&#xff1a;M m new M(); mnull;System.gc(); 软引用&#xff1a;内存不够时就回收 作用&#xff1a;一般使用在缓存时&#xff0c;比如把一些图片存储&#xff0c;内存不够时就自动回收 弱引用&#xff1a; 垃圾回…

js 控制页面跳转的5种方法

js 控制页面跳转的5种方法 编程式导航&#xff1a; 点击跳转路由&#xff0c;称编程式导航&#xff0c;用js编写代码跳转。 History是bom中的History.back是回退一页Histiory.go(1)前进一页History.go(-1)后退一页HandleClick(){Console.log(this.props.history);}This.props.h…

永动机与热力学定律

来源&#xff1a;力学酒吧 撰文&#xff1a;张伟伟热力学三大定律分别为能量守恒、熵增定律和绝对零度无法到达&#xff0c;人们对热力学定律的认识也是纠正永动机思想的过程&#xff0c;是人类“美好思想”不断“碰壁”的过程&#xff0c;这些“碰壁”对于个人成长有着深刻的启…

浅析ThreadLocal

线程本地变量 每个线程独立拥有&#xff0c;线程存在&#xff0c;ThreadLocal就一直存在。 使用场景&#xff1a;spring 事务 里面有m方法&#xff0c;m调用了m1&#xff0c;m2&#xff0c;比如m1&#xff0c;m2都去访问数据库 如果分别建立两个数据库连接&#xff0c;事务…

T-SQL删除存储过程

使用T-SQL脚本删除存储过程 语法&#xff1a; --声明数据库引用use 数据库名称;go --判断是否存在存储过程&#xff0c;如果存在则删除if exists(select * from sys.procedures where name存储过程名称)drop { proc | procedure } [架构名][.][存储过程名称];go 示例&#xff1…

工业机器人技术全解析,值得收藏!

来源&#xff1a;先进制造业一、工业机器人的发展背景1920年&#xff0c;捷克剧作家卡里洛奇别克在其科幻剧本《罗萨姆万能机器人制造公司》&#xff08;Rossums Universal Robots&#xff09;首次使用了ROBOT这个名词&#xff0c;之后便成为机器人的代名词。1938年3月&#xf…

Leetcode--781.森林中的兔子

森林中&#xff0c;每个兔子都有颜色。其中一些兔子&#xff08;可能是全部&#xff09;告诉你还有多少其他的兔子和自己有相同的颜色。我们将这些回答放在 answers 数组里。 返回森林中兔子的最少数量。 示例: 输入: answers [1, 1, 2] 输出: 5 解释: 两只回答了 "1&q…

JQuery 数组按指定长度分组

JQuery方法// 将data每3个一组进行分组var data [法国,澳大利亚,智利,新西兰,西班牙,加拿大,阿根廷,美国,0,国产,波多黎各,英国,比利时,德国,意大利,意大利,]; var result []; for(var i0,lendata.length;i<len;i3){result.push(data.slice(i,i3)); }lodash方法var data …

中科创星米磊:从五个方向筛选“硬科技”企业

来源&#xff1a;经济日报-中国经济网记者/梁 睿米磊建议创投和保荐机构从五个方面入手筛选“硬科技”企业&#xff1a;“围绕落实国家战略规划确定的科技发展方向或承担具体攻关任务的企业&#xff1b;拥有关键核心技术和先进技术的企业&#xff1b;科技创新和转化应用能力突出…

多线程下实现自增的几种方式

前情回顾&#xff1a;i操作并不是原子操作&#xff0c;因此多线程下会达不到预期的效果&#xff0c;需要通过加锁或AtomicInteger或LongAdder等方法来实现。 i可以分为三步 我们通过实验来观察实现i操作的方式。 下面实验中通过继承Thread实现了多线程 错误方法&#xff1a;…

Fast R-CNN(理解)

0 - 背景 经典的R-CNN存在以下几个问题&#xff1a; 训练分多步骤&#xff08;先在分类数据集上预训练&#xff0c;再进行fine-tune训练&#xff0c;然后再针对每个类别都训练一个线性SVM分类器&#xff0c;最后再用regressors对bounding box进行回归&#xff0c;并且bounding …

全球最顶级的十大创新公司

来源&#xff1a;中企思智库2021年2月英国著名的全球信息服务提供商科睿唯安发布了“2021年度全球百强创新机构”榜单&#xff0c;榜单通过衡量全球各大企业机构专利实力以及创新文化进行综合评选&#xff0c;具体排名如下&#xff1a;3M——是世界第一大创新企业&#xff0c;A…