力扣刷题｜链表

题目来源：力扣

删除链表中的节点

题目：有一个单链表的 head，我们想删除它其中的一个节点 node。给你一个需要删除的节点 node 。你将 无法访问 第一个节点  head。链表的所有值都是 唯一的，并且保证给定的节点 node 不是链表中的最后一个节点。

删除给定的节点。注意，删除节点并不是指从内存中删除它。这里的意思是：

给定节点的值不应该存在于链表中。
链表中的节点数应该减少 1。
node 前面的所有值顺序相同。
node 后面的所有值顺序相同。
自定义测试：

对于输入，你应该提供整个链表 head 和要给出的节点 node。node 不应该是链表的最后一个节点，而应该是链表中的一个实际节点。
我们将构建链表，并将节点传递给你的函数。
输出将是调用你函数后的整个链表。

示例：

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

算法思路：这个题需要定义一个虚拟头结点，然后把上一个指向它的节点指向下一个节点。(但是答案的思路就是把它的值指向下一个，它的指针指向下一个，没有说是它的上一个节点，也没有创建虚拟节点。

python代码：

# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def deleteNode(self,node):
        node.val = node.next.val
        node.next = node.next.next

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

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

示例：

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

算法思路：如何使用链表来倒序遍历？正常删掉len(head)-n吗？这样也是可行的，但是求链表的长度需不需要全部遍历呢？其次就是使用双指针的方法，让fast指针走N步，然后再让slow和fast一起走，直到fast走到最后。

求链表长度，有两种方法，一种就是全部遍历，另外一种就是使用递归的方法求链表长度。

这个题需要加上虚拟结点，创建虚拟节点如下。(注意：没有slow.val = slow.next.val是因为，slow是从虚拟节点出发的，所以slow是在的是N的上一个节点。以及最后返回需要返回头节点。

python代码：

# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def removeNthFromEnd(self,head,n):
        dummy = ListNode(0)
        dummy.next = head

        slow,fast = dummy,head

        for i in range(n):
            fast = fast.next
        
        while fast is not None:
            fast = fast.next
            slow = slow.next

        #slow.val = slow.next.val
        slow.next = slow.next.next
        
        return dummy.next

反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

算法思路：反转链表的话，就是反转指针，答案里面的方法有使用栈的方法，双链表，双指针，以及使用递归的方法。以下代码里使用了双指针的方法，temp = cur.next用来保存下一个指针，为了遍历的时候不被影响，然后使用cur.next = pre开始反转，然后pre = cur和cur = temp是为了更新双指针的位置。

python代码：

class ListNode(object):
    def __init__(self,val = 0,next = None):
        self.val = val
        self.next = next

class Solution(object):
    def reverseList(self,head):
        cur = head
        pre = None
        while cur:
            temp = cur.next
            cur.next = pre
            pre = cur
            cur = temp
        return pre

合并两个有序链表

题目：将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例：

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

算法思路：这个题中，其实是使用了三个头指针，cur,list1和list2,（注意这三个都只是表示头指针），开始先判断list1和list2的第一个节点的值，谁小那么虚拟节点的值就指向谁，同时，虚拟节点和小的那个值都向前移1，然后再判断list1和list2的值的大小。值得它们不为空。

python代码：

class ListNode(object):
    def __init__(self,val = 0,next = None):
        self.val = val
        self.next = next
class Solution(object):
    def mergeTwoLists(self,list1,list2):
        dummy = ListNode(0)
        cur = dummy

        while list1 and list2:
            if list1.val <= list2.val:
                cur.next = list1
                list1 = list1.next
            else:
                cur.next = list2
                list2 = list2.next
            cur = cur.next

        cur.next = list1 if list1 else list2
        return dummy.next

# 将列表构建成链表节点
l1 = ListNode(1)
node2 = ListNode(2)
node3 = ListNode(4)
l1.next = node2
node2.next = node3

l2 = ListNode(1)
node4 = ListNode(3)
node5 = ListNode(4)
l2.next = node4
node4.next = node5

solution = Solution()
mergeTwoLists = solution.mergeTwoLists(l1, l2)
# 遍历打印合并后的链表
cur = mergeTwoLists
while cur:
    print(cur.val)
    cur = cur.next

回文链表

题目：给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。

示例：

输入：head = [1,2,2,1]
输出：true

算法思路：也就是说倒序后判断该链表是否相等？这样的话需要把链表转换为数组的形式，代码如下：

python代码：

class Solution(object):
    def isPalindrome(self,head):
        res = True
        l = []
        while head:
            l.append(head.val)
            head = head.next
        temp = []
        for i in range(len(l)-1,-1,-1):
            temp.append(l[i])
        for i in range(len(l)):
            if l[i] !=temp[i]:
                res = False
                break
        return res 

环形链表

题目：给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

如果链表中存在环 ，则返回 true 。 否则，返回 false 。

算法思路：这个题其实没有看懂，代码随想录​​​​​​​里给了两种解法，快慢指针法，和集合法。这里就用集合法吧，这个题的快慢指针法没有看懂。

python代码：

class Solution:
    def hasCycle(self, head):
        visited = set()
        
        while head:
            if head in visited:
                return head
            visited.add(head)
            head = head.next
        
        return None