LeetCode链表ListNode学习笔记

从未学会，从不放弃。

链表概念

指针构成的数组

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

用法简单，一般是

List1.val #当前值
List1.next #下一个节点值
List1.head #头节点

• class ListNode：这行定义了一个名为 ListNode 的新类。
• def __init__(self, x)：这是 ListNode 类的初始化方法（也称为构造函数）。当你创建一个新的 ListNode 对象时，这个方法会被自动调用。它接受两个参数：self 和 x。self 是一个对实例本身的引用，而 x 是我们要存储在节点中的值。
• self.val = x ：这行将传入的参数 x 的值赋给 self.val。这意味着每个 ListNode 对象都有一个 val 属性，用于存储节点的值。
• self.next = None：这行初始化 self.next 属性为 None。self.next 是一个指向下一个 ListNode 对象的指针。在创建新的节点时，我们不知道它的下一个节点是什么，所以我们将它初始化为 None。当我们构建链表时，我们会根据需要更新这个指针。

                        
原文链接：https://blog.csdn.net/qq_43047410/article/details/137993345

热题hot100

1.两数相加

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807

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

class Solution(object):
    def addTwoNumbers(self, l1, l2):
   
        if l1 is None:
            return l2
        if l2 is None:
            return l1
        l1.val += l2.val  # 将两数相加，赋值给 l1 节点
        if l1.val >= 10:
            if l1.next is None:
                l1.next = ListNode3(0)
            if l2.next is None:
                l2.next = ListNode3(0)
            l1.next.val += 1
            l1.next = self.addTwoNumbers(l1.next, l2.next)
            l1.val %= 10
        else:
            l1.next = self.addTwoNumbers(l1.next, l2.next)
        return l1

2.合并两个有序链表

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

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

class Solution:
    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
        #方法一：递归，很高端
        # if list1 is None:
        #     return list2
        # elif list2 is None:
        #     return list1
        # elif list1.val < list2.val:
        #     list1.next = self.mergeTwoLists(list1.next,list2)
        #     return list1
        # else:
        #     list2.next = self.mergeTwoLists(list1,list2.next)
        #     return list2
        
        #方法二：迭代
        prehead = ListNode(-1) #哨兵节点
        prev = prehead  #负责统筹干活的指针
        while list1 and list2:
            if list1.val <= list2.val:
                prev.next = list1
                list1 = list1.next
            else:
                prev.next = list2
                list2 = list2.next
            prev = prev.next

        prev.next = list1 if list1 is not None else list2
        return prehead.next

3.相交链表

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。图示两个链表在节点 c1 开始相交：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3

输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
— 请注意相交节点的值不为 1，因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说，它们在内存中指向两个不同的位置，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向相同的位置。

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
        #天才解法
        A,B = headA,headB
        while A!=B:
            A = A.next if A else headB
            B = B.next if B else headA
        return A
        #另一种解法
        A,B = headA,headB
        while(A != B):
            if A==None:
                A=headB
            else:
                A=A.next
            
            if B==None:
                B=headA
            else:
                B=B.next
        return A

 经常会有把head赋值给另一个变量的操作，这样head+1的时候指针就比另一个变量快了，由此产生区分。

4.反转列表

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

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

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        cur = head
        pre = None
        while cur:
            tmp = cur.next #暂存后继节点
            cur.next = pre #修改引用指向
            pre = cur #暂存当前节点
            cur = tmp #访问下一节点
        return pre

5.回文链表 

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

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

class Solution:
    def isPalindrome(self, head: Optional[ListNode]) -> bool:

        self.front_pointer = head
        def recursively_check(current_node=head):
            if current_node is not None:
                if not recursively_check(current_node.next):
                    return False
                if self.front_pointer.val != current_node.val:
                    return False
                self.front_pointer = self.front_pointer.next
            return True
        return recursively_check()

 6.环形链表

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

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        # 快慢双指针
        fast = slow =head
        while fast and fast.next: #存在fast和fast的下一节点时
            fast = fast.next.next #fast指针走两步
            slow = slow.next #slow指针走一步，这样fast就比slow快，重合时即走过了一个环
            if fast == slow:
                return True
        return False

 链表看上去使用简单，但要是灵活应用还是需要多琢磨。