Leetcode 学习计划之21天算法 (五）

fire2fire2

已于 2022-03-12 18:15:42 修改

阅读量311

点赞数

分类专栏： Leetcode 文章标签： leetcode 学习链表算法

于 2022-03-11 13:31:24 首次发布

本文链接：https://blog.csdn.net/qq_41973062/article/details/123421265

版权

Leetcode 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

这篇博客介绍了两种常见的链表操作：如何找到链表的中间节点以及如何删除链表的倒数第N个节点。作者提供了三种不同的解决方案，包括使用双指针和计数法，确保在不同情况下都能正确处理。对于删除操作，特别注意了处理头节点的情况。

摘要由CSDN通过智能技术生成

第5天双指针

876.链表的中间结点

1、快慢指针快指针每走两步，慢指针走一步；也可写成快指针一次走两步，慢指针一次走一步。

2、遍历链表计数，再遍历数组只遍历到一半。

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def middleNode(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        #slow = head
        slow = fast = head
        j = 0
        while fast != None:
            j=j+1            
            fast = fast.next
            if j%2 == 0:
                slow = slow.next

        return slow

# Definition forxf singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def middleNode(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        slow = fast = head
        while fast != None and fast.next != None:
            fast = fast.next.next
            slow = slow.next
        return slow

# Definition forxf singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def middleNode(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        ans = 0
        index = head
        while head!= None:
            head = head.next
            ans+=1
        ans = ans // 2 
        while ans!=0:
            index = index.next
            ans -= 1
        return index

19、删除链表的倒数第N个结点

1、先遍历链表看一共有几个结点，再减去倒数就得到正数第几个结点。

对于特殊情况（仅有一个结点，去除头节点）特殊处理。

2、先后指针，快指针先走n步，随后再快慢指针一起走，当快指针到末尾时，慢指针就到了倒数第n个结点。注意要特殊处理删除头节点，即倒数第n个为头节点的情况。

如果不特殊处理头节点，就要新建一个结点dummy.next指向头节点，让慢指针也等于这个结点dummy，最后return dummy.next

3、也可以用栈实现，先入栈，再出栈,第n个出来的即为倒数第n个，栈顶元素即为倒数n-1个。

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def removeNthFromEnd(self, head, n):
        """
        :type head: ListNode
        :type n: int
        :rtype: ListNode
        """
        index = head 
        if head.next == None: #如果只有一个结点 那肯定返回None
            return None           
        l = 0
        while head: #计数一共有多少个结点
            head = head.next
            l+=1

        t = l - n  #记录是正数第几个节点
        if t == 0: #如果要去除的是正数第1个节点 直接return index.next
            return index.next        
        head = index #否则要一直遍历到第t个结点 
        while t > 0:
            t-=1
            tmp = head
            head = head.next
        tmp.next = head.next
        return index

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def removeNthFromEnd(self, head, n):
        """
        :type head: ListNode
        :type n: int
        :rtype: ListNode
        """
        fast = slow = head
        while n>0: #让快指针先走n步
            fast = fast.next
            n-=1
        if fast == None: #如果此时快指针为空，即要删的是头节点直接return head.next
            return head.next
        while fast and fast.next: #否则快指针走到链表结尾时，慢指针正好走到了倒数第n个
            fast = fast.next
            slow = slow.next
        slow.next = slow.next.next
        return head