LeetCode题解之删除链表倒数第n个结点

开发 前端
再想想,可不可以不计算链表长度呢?也就是题目上所说的进阶解法,用一次扫描。再链表中,有一种常用的方法,叫做快慢指针,意思就是用到两个速度不同的指针解决一些问题。

[[380272]]

前言

今天继续说链表常见问题中的——删除链表倒数第n个结点:

  • 单链表反转
  • 两个有序的链表合并
  • 删除链表倒数第n个结点
  • 求链表的中间结点
  • 链表中环的检测

题目:删除链表倒数第n个结点

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

进阶:你能尝试使用一趟扫描实现吗?

示例 1:输入:head = [1,2,3,4,5], n = 2 输出:[1,2,3,5]

示例 2:输入:head = [1], n = 1 输出:[]

示例 3:输入:head = [1,2], n = 1 输出:[1]

解法一

首先容易想到的办法就是想数组一样,遍历链表找到那个要被删除的结点,所以先解决两个问题:

1、获取链表的总长度

  1. public int getLength(ListNode head){ 
  2.         int n=0; 
  3.         while(head!=null){ 
  4.             n++; 
  5.             head=head.next
  6.         } 
  7.         return n; 
  8.     } 

2、找到结点之后,怎么删除。

其实就是把next指向跨过去要删除的结点就行了。

  1. tempNode.next=tempNode.next.next

但是,上述这个方法是删除的tempNode.next结点,如果我们要删除tempNode本身这个结点,那么就要把一开始的结点提前到第一个结点之前。

比如我们要删除链表的第一个结点,如果你本身的指针就指向第一个结点,那么通过上面这个删除方法就永远删除不了第一个结点了。

所以要把指针提前到第一个结点之前。

所以,综上所述,我们得出以下解法:

  1. /** 
  2.  * Definition for singly-linked list. 
  3.  * public class ListNode { 
  4.  *     int val; 
  5.  *     ListNode next
  6.  *     ListNode() {} 
  7.  *     ListNode(int val) { this.val = val; } 
  8.  *     ListNode(int val, ListNode next) { this.val = val; this.next = next; } 
  9.  * } 
  10.  */ 
  11. class Solution { 
  12.     public ListNode removeNthFromEnd(ListNode head, int n) { 
  13.         int length=getLength(head); 
  14.         //新建一个新的链表结点指向head头结点,也就是上面要注意的特殊情况 
  15.         ListNode lastNode=new ListNode(0,head); 
  16.         ListNode tempNode=lastNode; 
  17.         for(int i=0;i<length-n;i++){ 
  18.             tempNode=tempNode.next
  19.         } 
  20.         tempNode.next=tempNode.next.next
  21.         return lastNode.next
  22.     } 
  23.  
  24.     public int getLength(ListNode head){ 
  25.         int n=0; 
  26.         while(head!=null){ 
  27.             n++; 
  28.             head=head.next
  29.         } 
  30.         return n; 
  31.     } 

时间复杂度

用到了遍历、时间复杂度为O(n)

空间复杂度

只用到几个单独的链表结点,所以空间复杂度为O(1)

解法二

再想想,可不可以不计算链表长度呢?也就是题目上所说的进阶解法,用一次扫描。

再链表中,有一种常用的方法,叫做快慢指针,意思就是用到两个速度不同的指针解决一些问题。

比如这个题中,我们使用一个快指针一个慢指针,并且让快指针快n个结点,然后两个指针一直往后移动。当快指针移动到结尾,那么慢指针的位置就是我们要删除的结点了。

当然,这里也要考虑到当前结点被删除的情况,所以要把开始结点提前到链表之前。

  1. public ListNode removeNthFromEnd(ListNode head, int n) { 
  2.  //提前链表 
  3.         ListNode LastNode=new ListNode(0,head); 
  4.         ListNode FirstNode=LastNode; 
  5.         ListNode SecondNode=head; 
  6.         for(int i=0;i<n;i++){ 
  7.             SecondNode=SecondNode.next
  8.         } 
  9.  
  10.         while(SecondNode!=null){ 
  11.             FirstNode=FirstNode.next
  12.             SecondNode=SecondNode.next
  13.         } 
  14.  
  15.         FirstNode.next=FirstNode.next.next
  16.          
  17.         return LastNode.next
  18.     } 

时间复杂度

时间复杂的为O(n)

空间复杂度

空间复杂度为O(1)

其他解法

还有其他的解法,比如用到栈先进后出的原则,先把所有链表数据入栈,然后出栈n个数。剩下的栈顶就是要删除结点的前驱结点了,然后调用上述的删除结点方法,就可以删除要删除的下个结点了。

参考

https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/

本文转载自微信公众号「码上积木」,可以通过以下二维码关注。转载本文请联系码上积木公众号。

 

责任编辑:武晓燕 来源: 码上积木
相关推荐

2022-01-17 09:23:02

LeetCode删除链表算法

2021-08-10 07:57:03

算法链表倒数

2021-04-14 10:19:18

链表倒数结点

2020-10-19 13:27:19

链表倒数结点

2021-02-04 08:18:53

LeetCode链表

2022-06-01 06:58:41

节点链表倒数

2023-04-17 07:33:11

反转链表移除链表

2021-01-21 08:23:29

链表单链表循环链表

2021-01-28 08:20:41

链表空间复杂度

2012-06-19 14:23:04

云计算中国

2022-02-16 09:12:22

LeetCode升序链表链表数组

2021-03-12 08:19:20

数组跳跃游戏

2018-03-01 13:32:28

宏碁游戏本PC行业

2012-02-17 09:45:04

网速手机

2012-02-17 09:43:13

手机网速移动互联

2021-01-22 08:30:50

LeetCode数字数组

2021-03-22 08:23:29

LeetCode二叉树节点

2012-08-10 10:53:03

云计算BSA商业软件联盟

2012-06-18 10:07:17

云计算实力榜

2019-11-01 11:19:25

转链表LeetCode代码
点赞
收藏

51CTO技术栈公众号