160.相交链表 234.回文链表

160.相交链表

1.用set（）检测是否有重复元素

需要遍历并储存所有元素，时间空间复杂度都为O(n)

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

2.双指针

指针A从headA开始走，走到null时指向headB，到达公共节点时，A走过的路径为a→None→(b-c)
指针B从headB开始走，走到null时指向headA，到达公共节点时，B走过的路径为b→None→(a-c)
指针A、B同时到达第一个公共节点，如果不存在公共节点，那么A、B同时到达null
需要遍历链表，只储存指针，时间复杂度O(n)空间复杂度O(1)

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

234.回文链表

1.链表转list，判断list是否回文

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

class Solution:
    def getlist(self,head):
        l=[]
        while head:
            l.append(head.val)
            head=head.next
        return l
    def isPalindrome(self, head: ListNode) -> bool:
        l=self.getlist(head)
        if l==l[::-1]:
            return True
        else:
            return False

2.反转后一半链表，判断与前一半是否一致

①找中点：双指针
②翻转
③判断是否回文
（④恢复原链表）
时间复杂度O(n)，空间复杂度O(1)

class Solution:
    def isPalindrome(self, head: ListNode) -> bool:
        s,f=head,head
        #####寻找中间Node####
        while f and f.next:
            s=s.next
            f=f.next.next
        ######反转链表#######
        new=ListNode(s.val,None)
        s=s.next
        while s:
            new=ListNode(s.val,new)
            s=s.next
        #####检测后半反转链表与前一半是否相等#####
        while new:
            if head.val!=new.val:
                return False
            else:
                head=head.next
                new=new.next
        return True