Leetcode-链表

最新推荐文章于 2024-04-24 21:16:44 发布

dzysunshine

最新推荐文章于 2024-04-24 21:16:44 发布

阅读量282

点赞数

分类专栏：剑指offerLeetcode 文章标签：链表 leetcode 数据结构

本文链接：https://blog.csdn.net/dzysunshine/article/details/118853067

版权

剑指offerLeetcode 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

文章目录

删除链表的倒数第N个节点（19M）
合并两个有序链表（21E）
环形链表（141E）
环形链表 II（142M）
相交链表（160E）
链表中倒数第K个结点（剑22E）
反转链表（206）
回文链表（234E）

删除链表的倒数第N个节点（19M）

19. 删除链表的倒数第 N 个结点
难度：【中等】
在对链表进行操作时，一个常用的技巧就是添加一个哑结点（dummy node）,它的next指向链表的头结点，这样就不需要对头结点进行特殊判断了。

思路一：计算链表长度
先对链表进行一次遍历，得到链表的长度L，随后再从头节点开始对链表进行一次遍历，当遍历到第L-n+1个节点时，就是需要删除的节点。当我们在头结点前面加上dummy节点后，删除的节点就变为了L-n+1的下一个节点，通过修改指针来完成删除操作。
在这里插入图片描述
代码如下：

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        def getLength(head: ListNode) -> int:
            length = 0
            while head:
                length += 1
                head = head.next
            return length
        
        dummy = ListNode(0, head)
        length = getLength(head)
        cur = dummy
        for i in range(1, length - n + 1):
            cur = cur.next
        cur.next = cur.next.next
        return dummy.next

时间复杂度：O(L)，其中 L 是链表的长度。
空间复杂度：O(1)。

方法二：栈

在对链表进行遍历时将所有的节点依次放入栈，根据栈先进后出的原则，我们弹出的第n个节点就是需要删除的节点，且此时栈顶的节点就是待删除节点的前驱节点。

代码如下：

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        dummy = ListNode(0, head)
        stack = list()
        cur = dummy
        while cur:
            stack.append(cur)
            cur = cur.next
        
        for i in range(n):
            stack.pop()

        prev = stack[-1]
        prev.next = prev.next.next
        return dummy.next

时间复杂度：O(L)，其中 L 是链表的长度。
空间复杂度：O(L)，其中 L 是链表的长度。主要为栈的开销。

方法三：双指针
该方法的优点在于不需要预处理链表的长度
使用两个指针 first 和 second 同时对链表进行遍历，并且 first 比 second 超前 n 个节点。当 first 遍历到链表的末尾时second 就恰好处于倒数第 n 个节点。

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        dummy = ListNode(0, head)
        first = head
        second = dummy
        for i in range(n):
            first = first.next

        while first:
            first = first.next
            second = second.next
        
        second.next = second.next.next
        return dummy.next

时间复杂度：O(L)，其中 LL 是链表的长度。
空间复杂度：O(1)。

合并两个有序链表（21E）

难度：【简单】

方法一：递归
分两种情况：空链表和非空链表
当其中一个为空链表时，可以直接返回另一个链表
当两个链表都为非空链表时，可以使用下面方法进行递归
在这里插入图片描述
代码如下：

class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        if l1 is None:
            return l2
        elif l2 is None:
            return l1
        elif l1.val < l2.val:
            l1.next = self.mergeTwoLists(l1.next,l2)
            return l1
        else:
            l2.next = self.mergeTwoLists(l1,l2.next)
            return l2

时间复杂度：O(m+n)
空间复杂度：O(m+n)

方法二：迭代

首先要设定一个哨兵节点，可以在最后比较容易地返回合并后的链表。
维护一个 prev 指针，根据 l1和 l2 的大小不断更新 prev 的next 指针。

代码如下：

class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        Newhead = ListNode(-1)
        pre = Newhead
        while l1 and l2:
            if l1.val < l2.val:
                pre.next = l1
                l1 = l1.next
            else:
                pre.next = l2
                l2 = l2.next
            pre = pre.next
        if l1 is None:
            pre.next = l2
        else:
            pre.next = l1
        return Newhead.next

时间复杂度：O(m+n)
空间复杂度：O(1)

环形链表（141E）

141. 环形链表

难度：【简单】

提供三种解题方法：
最容易想到的就是暴力解法，遍历链表中的节点，由于题目中给出了节点的范围，最多为10的4次方个节点，因此进行遍历，如果遍历过程中遇到空节点（None），说明该链表为无环链表，直接返回False即可，暴力法的时间复杂度为O(n)，空间复杂度为O(1)；
第二种方法是哈希表法，即需要一个set来存储已经遍历过的节点，在遍历节点时判断节点是否被访问过，时间复杂度为O(n)，空间复杂度为O(n)；
方法如下：

方法一：暴力解法

代码如下：

class Solution:
    def hasCycle(self, head: ListNode) -> bool:
        count = 10000
        while head != None and count > 0:
            head = head.next
            count -= 1
        if head == None:
            return False
        return True

时间复杂度为O(n)
空间复杂度为O(1)

方法二：哈希表

遍历所有节点，每次遍历一个节点时，判断该节点此前是否被访问过。
如果被访问过，说明该链表是环形链表，并返回True，如果没有，则将该节点加入到哈希表中，遍历完成即可。

代码如下：

class Solution:
    def hasCycle(self, head: ListNode) -> bool:
        seen = set()
        while head:
            if head in seen:
                return True
            seen.add(head)
            head = head.next
        return False

时间复杂度：O(n)
空间复杂度：O(n)

方法二：快慢指针

定义两个指针，一快一慢，慢指针每一移动一步，快指针每次移动两步，由于快指针比慢指针慢，如果链表有环，则快指针一定会和慢指针相遇。

代码如下：

class Solution:
    def hasCycle(self, head: ListNode) -> bool:
        fast = slow = head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            if fast == slow:
                return True
        return False

时间复杂度：O(N)
空间复杂度：O(1)

环形链表 II（142M）

142. 环形链表 II

难度：【中等】

解题思路：使用快慢指针

首先，我们要做以下设定，设链表共有 a + b个节点，其中链表头部到链表入口（不计链表入口节点）有 a 个节点，链表环有 b 个节点，同时设快指针走了 f 步，慢指针走了 s 步；

显然，由于快指针是慢指针的两倍，因此有：f = 2s

如果两个指针第一次相遇，则满足：f = s + nb（n表示n个环），也就是 fast 比 slow 多走了 n 个环的长度；

由上可得：当两个指针第一次相遇，有s = nb, f = 2nb

现在需要解决的问题，我们如何知道 a 的大小？

假设现在两指针第一次相遇：

对慢指针来说，如果让慢指针走到链表入口节点，需要 a + nb步，而在相遇时，已经走了 nb 步了，因此，再让慢指针走 a 步就可以走到链表入口节点了；

对快指针来说，如果让快指针从头指针开始走 a 步，快指针也正好走到链表入口节点；
由此可见，两指针发生第二次相遇的时候，刚好都在链表入口处。
在这里插入图片描述

代码如下：

class Solution:
    def detectCycle(self, head: ListNode) -> ListNode:
        fast = slow = head
        while True:
            if not (fast and fast.next):return
            fast = fast.next.next
            slow = slow.next
            if fast == slow:break
        fast = head
        while fast != slow:
            fast = fast.next
            slow = slow.next
        return fast

时间复杂度 O(N)
空间复杂度 O(1)

相交链表（160E）

160. 相交链表

难度：【简单】

方法一：暴力解法
对于A中的每一个结点，我们都遍历一次链表B查找是否存在重复结点，第一个查找到的即第一个公共结点。

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        p = headA
        while p:
            q = headB
            while q:
                if p == q:
                    return p
                q = q.next
            p = p.next
        return p

时间复杂度：O(n^2)
空间复杂度：O(1)
无法通过，会超时。

方法二：
对暴力解法的一个优化方案是：先将其中一个链表存到哈希表中，此时再遍历另外一个链表查找重复结点只需 O(n) 时间。

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        s = set()
        p,q = headA,headB
        while p:
            s.add(p)
            p = p.next
        while q:
            if q in s:
                return q
            q = q.next
        return None

时间复杂度：O(n)
空间复杂度：O(n)

方法三：走过彼此的路
利用两链表长度和相等的性质来使得两个遍历指针同步。
具体做法是：让两指针同时开始遍历，遍历到结尾的时候，跳到对方的头指针，如果有公共结点，则，会同时到达相遇的地方。

代码如下：

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        p,q = headA,headB
        while p != q:
            p = p.next if p else headB
            q = q.next if q else headA
        return p

时间复杂度：O(n)
空间复杂度：O(1)

链表中倒数第K个结点（剑22E）

剑指 Offer 22. 链表中倒数第k个节点
难度：【简单】

两种方法：
方法一：先找到 n，再找到 n - k
先遍历统计链表长度。记为 n；
再设置一个指针走（n - k）步，即可找到链表倒数第 k 个节点。

代码如下;

class Solution:
    def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:
        cur = head
        n = 0
        while cur:
            n += 1
            cur = cur.next
        cur = head
        for i in range(n - k):
            cur = cur.next
        return cur

方法二：使用双指针；
先让一个前指针走 k 步，再让两个指针一起走，当前置镇走到最后尾节点时，后指针正好走到n - k。

代码如下：

class Solution:
    def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:
        former = latter = head
        for _ in range(k):
            former = former.next
        while former:
            former, latter = former.next,latter.next
        return latter

时间复杂度：O(n)
空间复杂度：O(1)

反转链表（206）

206. 反转链表
难度：【简单】

参考：https://leetcode-cn.com/problems/reverse-linked-list/solution/shi-pin-tu-jie-206-fan-zhuan-lian-biao-d-zvli/
两种思路：

思路一：迭代

可以使用三个指针来完成迭代，具体可以定义三个指针 pre，cur，nxt，并对 pre 和 cur 进行初始化（令pre为None）

pre = None
cur = head

然后定义一个whlie循环

先更新 nxt = cur.next，并将 nxt.next 指向 cur；
再调换 pre 和 cur 的位置，直到 cur 为空结束。

代码如下：

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        pre = None
        cur = head
        while cur:
            nxt = cur.next
            cur.next = pre
            pre = cur
            cur = nxt
        return pre

时间复杂度：O(n)
空间复杂度：O(1)

思路二：递归

明确递推公式的含义：把拿到的链表进行反转，然后返回新的头结点。
首先要写出Newhead，然后修改指针方向，并将 head.next设为None。
需要注意停止条件： head 为 None 或 head.next 为 None

代码如下：

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        if head == None or head.next == None:
            return head
        newHead = self.reverseList(head.next)
        head.next.next = head
        head.next = None
        return newHead

时间复杂度：O(n)
空间复杂度：O(n)

回文链表（234E）

234. 回文链表

难度：【简单】

思路：将值添加到数组中，翻转后进行比较。

将链表值添加到数组列表中，然后直接比较翻转前后是否相等。

class Solution:
    def isPalindrome(self, head: ListNode) -> bool:
        vals = []
        current_node = head
        while current_node is not None:
            vals.append(current_node.val)
            current_node = current_node.next
        return vals == vals[::-1]

时间复杂度：O(n)
空间复杂度：O(n)

dzysunshine

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Leetcode-链表

文章目录环形链表（141E）环形链表（141E）141. 环形链表难度：【简单】提供两种解题方法，如下：方法一：哈希表遍历所有节点，每次遍历一个节点时，判断该节点此前是否被访问过。如果被访问过，说明该链表是环形链表，并返回True，如果没有，则将该节点加入到哈希表中，遍历完成即可。代码如下：class Solution: def hasCycle(self, head: ListNode) -> bool: seen = set() while
复制链接

扫一扫