二刷 leetcode（8）

237. 删除链表中的节点

请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。

现有一个链表 -- head = [4,5,1,9]，它可以表示为:

    4 -> 5 -> 1 -> 9

示例 1:

输入: head = [4,5,1,9], node = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.

示例 2:

输入: head = [4,5,1,9], node = 1
输出: [4,5,9]
解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.

说明:

• 链表至少包含两个节点。
• 链表中所有节点的值都是唯一的。
• 给定的节点为非末尾节点并且一定是链表中的一个有效节点。
• 不要从你的函数中返回任何结果。

代码;

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def deleteNode(self, node):
        """
        :type node: ListNode
        :rtype: void Do not return anything, modify node in-place instead.
        """
        #### the first method
        # node.val = node.next.val
        # node.next = node.next.next
        
        #### the second method
        del_node = node.next
        node.val = node.next.val
        node.next = node.next.next
        del del_node

203. 删除链表中的节点

删除链表中等于给定值 val 的所有节点。

示例:

输入: 1->2->6->3->4->5->6, val = 6
输出: 1->2->3->4->5

代码：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def removeElements(self, head, val):
        """
        :type head: ListNode
        :type val: int
        :rtype: ListNode
        """
        pre_node = ListNode(None)
        pre_node.next = head
        q = pre_node
        while q.next:
            if q.next.val == val:
                q.next = q.next.next
            else:
                q = q.next
        return pre_node.next
    
        fake_head = ListNode(None)
        fake_head.next = head
        current_node = fake_head
        while current_node and current_node.next:
            next_node = current_node.next
            if next_node.val == val:
                current_node.next = next_node.next
                del next_node
            else:
                current_node = next_node
        return fake_head.next
    

19. 删除链表的倒数第N个节点

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

示例：

给定一个链表: 1->2->3->4->5, 和 n = 2.

当删除了倒数第二个节点后，链表变为 1->2->3->5.

说明：

给定的 n 保证是有效的。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def removeNthFromEnd(self, head, n):
        """
        :type head: ListNode
        :type n: int
        :rtype: ListNode
        """
        ##### the first method , 把链表的所有值都存在一个list中，
        # list_node = []
        # count = 0
        # while head:
        #     list_node.append(head)
        #     head = head.next
        #     count += 1
        # if count == 1:
        #     return None
        # if list_node[-n].next != None:
        #     list_node[-n].val = list_node[-n].next.val
        #     list_node[-n].next = list_node[-n].next.next
        # else:
        #     list_node[-n-1].next = None
        #     return list_node[0]
        # return list_node[0]
        
        #####  分析：设置两个指针 p1、p2，首先 p1 和 p2 都指向 head，然后 p2 向前走 k 步，这样 p1 和 p2 之间就间隔 k 个节点，
        #####  最后 p1 和 p2 同时向前移动，直至 p2 走到链表末尾。
        p1 = head
        p2 = head
        for i in range(n-1):
            p1 = p1.next
        pre = head
        idx = 0
        while p1.next:
            p1 = p1.next
            pre = p2
            p2 = p2.next
            idx += 1
        if idx == 0:
            node = head
            head = head.next
            del node
        else:
            node = p2
            pre.next = p2.next
            del node
       
        return head
            

206 .  反转链表

反转一个单链表。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

代码：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        #### the first method
        
        # cur = head
        # pre = None
        # h = head
        # list = []
        # while cur:
        #     h = cur
        #     temp = cur.next
        #     cur.next = pre
        #     pre = cur
        #     cur = temp
        #     list.append(h.val)
        # return list[::-1]
        
        #### the second method
        current, prev= head, None
        while current:
            current.next, prev, current = prev, current, current.next
        return prev