一枚菜鸟的leetcode刷题笔记 - Day13

面试题 - 链表相交

给定两个（单向）链表，判定它们是否相交并返回交点。请注意相交的定义基于节点的引用，而不是基于节点的值。换句话说，如果一个链表的第k个节点与另一个链表的第j个节点是同一节点（引用完全相同），则这两个链表相交。

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        listA = []
        while headA is not None:
            listA.append(headA)
            headA = headA.next
        while headB is not None:
            if headB in listA:
                return headB
            else:
                headB = headB.next
        return None

时间复杂度应该是$O(n^2)$，因为对链表B进行循环时，每一次都要和链表A的每一个node进行比对，最后也确实超时了。

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        numA, numB = 0, 0
        headAA, headBB = headA, headB
        while headA is not None:
            numA += 1
            headA = headA.next
        while headB is not None:
            numB += 1
            headB = headB.next
            
        if numA > numB:
            while numA-numB > 0:
                headAA = headAA.next
                numA -= 1
            while headBB is not None:
                if headAA == headBB:
                    return headAA
                headAA = headAA.next
                headBB = headBB.next
        else:
            while numB-numA > 0:
                headBB = headBB.next
                numB -= 1
            while headAA is not None:
                if headAA == headBB:
                    return headAA
                headAA = headAA.next
                headBB = headBB.next
        return None

这个方法先分别数出两个链表的节点个数，让数目多的链表先走，直到剩余节点数目相等。再让两个链表一起走，每走一步比对两个链表的节点是否相等即可。该方法时间复杂度为$O(n)$，因为没有循环套循环这种情况。

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        headAA, headBB = headA, headB
        
        #第一个循环考虑的是两个链表的节点数目相等的情况，若相交，则会在这一循环返回
        while headA is not None and headB is not None:
            if headA == headB:
                return headA
            headA = headA.next
            headB = headB.next
        
        #若两个链表节点数目不相等，则会进入判断
        if headA is None:
            headA = headBB
            while headB is not None:
            #此处无需再判断节点相等了，因为若节点数不相等，必然这个循环阶段是不会存在交点的
                headA = headA.next
                headB = headB.next
            headB = headAA
            while headA is not None and headB is not None:
                if headA == headB:
                    return headA
                headA = headA.next
                headB = headB.next
        
        elif headB is None:
            headB = headAA
            while headA is not None:
                headA = headA.next
                headB = headB.next
            headA = headBB
            while headA is not None and headB is not None:
                if headA == headB:
                    return headA
                headA = headA.next
                headB = headB.next
        
        else:
            print('python3 is crazy')
       
        return None

双指针法，时间复杂度为$O(n)$，实际上最多就是遍历了两个链表各两遍。

206 - 反转链表

反转一个单链表

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

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        if not head or not head.next:
            return head
        second = head.next
        reverse = self.reverseList(second)  #递归
        second.next = head
        head.next = None
        return reverse

这道题用递归解决会更清晰，递归相当于打开一个新的函数空间，本质是栈。程序里递归之前的语句可以看作是前馈的过程，在具体的递归函数具体执行前进行的铺垫或准备；程序里递归函数后的部分可以看作是反馈过程，在每层的递归调用后进行相关操作。

本题中reverse一直是链表的尾巴节点，也就是反转后链表的头节点，仅作返回值，递归操作的具体执行过程在于second = head.next和self.reverseList(second)

169 - 多数元素

给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。你可以假设数组是非空的，并且给定的数组总是存在多数元素。

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        nums.sort()
        return nums[len(nums)//2]

注意len(nums)//2处的数一定是众数。