Leetcode刷题 Day7～Day8

3.20

昨天晚上（or今天凌晨？）讨论的需要去看一下链表和迭代相关的内容。

跟妈妈讨论了一下实习大概就想离开家换一个环境了，妈妈说在成都不是挺好的吗，我也知道挺好，可是我不能放任自己一直在父母的庇护下自废武功啊，这样我永远也成长不起来。

3.22

果然烂桃花就是会影响人进步啊.....劝不喜欢的人别来找我没想到劲也要缓好多天.....多少有点无语了

3.23

好像也怪不了别人，主要还是懒

3.24

终于开始了，今天跟同学交流了一下暑假找实习的事情，感觉互联网寒冬还是有点suffering的，加油加油支棱起来啊  

141. 环形链表

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        if not head or not head.next:
            return False
        
        slow = head
        fast = head.next

        while slow != fast:
            if not fast or not fast.next:
                return False
            slow = slow.next
            fast = fast.next.next
        return True

学习的官方的题解，感觉用快慢指针这道题还挺好理解的

if not head or not head.next:

如果结点为空或者结点的后继也为空，如果结点为None,那么not head就为True

第二个白痴问题是这么多return会打印吗（可能主要还是因为没有理解到意思）

不会的，因为函数return了就会自动退出，不会执行后面的语句了，所以一次调用只会执行一次return，return语句就标志着函数运行结束了

这道题另外一个hash的做法不是很理解

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        s = set()
        node = head
        while node:
            s.add(node)
            node = node.next
            if node in s:
                return True
        
        return False

其中

s = set()

是创建一个空集合

另外，提问关于表里面有一样的数字，他在set里面用s.add来加链表里的东西，当遇到node in s就会return true了，那么电脑怎么判断这个node是重复的还是循环的呢？

因为他是直接把结点放进链表的，不是结点的值，所以有遇到重复结点时必是环形链表。就我们遍历到-4这个结点的时候，他的下一结点是-2这个结点，而-2这个结点之前已经遍历过且加入到集合里面了，说明肯定是环形的。相当于是放进去了一个地址，是唯一的，所以遇到重复的话必有环。

3.25

好像又想起了那个人，什么时候才能放下这种习惯呢

​​​​​​160. 相交链表

 这道题是真的给我整不会了，看官方的图片、视频题解都说这道题像极了爱情，破防了

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        if not headA or not headB:
            return None
        
        i = headA
        j = headB

        while i != j:
            if i:
                i = i.next
            else:
                i = headB
            if j:
                j = j.next
            else:
                j = headA
        return i

好像没有什么特别好批注的地方，双指针就是从头往后数，每个指针跑完自己那条链表，就跑下一条链表，如果两条链表相交，他们就会相遇。

另一个从尾往头数的办法

链表题一般存在字典里比较好理解（但是相应会损失空间复杂度）

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        list1 = []
        list2 = []
        i = headA
        j = headB

        while i:
            list1.append(i)
            i = i.next
        while j:
            list2.append(j)
            j = j.next

        l1, l2 = len(list1), len(list2)
        pos = -1

        while -pos <= l1 and -pos <= l2:
            if list1[pos] == list2[pos]:
                pos -= 1
            else:
                break
        if pos == -1:
            return None
        else:
            return(list1[pos + 1])

if list1[pos] == list2[pos]:
    pos -= 1

 如果两个指针指向一个位置就往前移动一个

else:
    break

break：不可以删，因为是在两个链表的交集处(或者没有)break

但这样好像时间复杂度比上一个高一点点但是都是O(n)