amazon刷题记录

Easy

1. Two Sum ->hashtable

题目：返回数组内两个数加起来等于target的索引

法1⃣️: brute force 双指针前后遍历

        for i in range(len(nums)-1):
            for j in range(i+1,len(nums)):
                if nums[i]+nums[j] == target:
                    ans[0] = i
                    ans[1] = j

⚠️ 两个指针范围不能重合

法2⃣️：y = target-x
⚠️ 出现两个y值时要处理

        for i in range(len(nums)-1):
            if target - nums[i] in nums:
                f = 0
                for k in range(nums.count(target - nums[i])):
                    j = nums.index(target - nums[i],f,len(nums))
                    if j != i:
                        ans[0] = i
                        ans[1] = j
                        return ans
                    else:
                        f = j+1

法3⃣️：hashtable

         map = {}
         for i, n in enumerate(nums):
             diff = target - n
             if diff in map:
                 print( map[diff], i)
             map[n] = i
             print(map)
         return

20 Valid Parentheses ->stack,hashmap

题目：大中小括号对称

法1⃣️：stack 栈

		stack = []
        for letter in s:
            if letter in [ "(" ,"{" , "["]:
                stack.append(str(letter))
            elif letter == ")":
                if not stack or stack.pop() != "(":
                    return False
            elif letter == "}":
                if not stack or stack.pop() != "{":
                    return False
            elif letter == "]":
                if not stack or stack.pop() != "[":
                    return False      
        return stack == []

法2⃣️：hashmap

		stack = []
        dictt={"(":")","{":"}","[":"]"}
        for i in s:
            if i in dictt:
                stack.append(i)
            elif stack==[] or dictt[stack.pop()]!=i:
                return False
        return stack==[]

21 Merge Two Sorted Lists ->singlelink,recursion

题目：按大小合并两个列表
⚠️：排除空链表->1空，2空或都空

		if not list1:
            return list2
        if not list2:
            return list1
        node1 = list1
        node2 =list2

法1⃣️：链表每个节点比较大小，连起来

        if node2.val <node1.val:
            node = node2
            node2 = node.next
        else:
            node = node1
            node1 = node.next
        head = node
        while node.next is not None:
            if node1.val > node2.val:
                node.next = node2
                node2 = node2.next
            else:
                node.next = node1
                node1 = node1.next
            node = node.next
        if node1:
            node.next = node1
        if node2:
            node.next = node2
        return head

法2⃣️：递归写入

        if list1.val <list2.val:
            list1.next = self.mergeTwoLists(list1.next,list2)
            return list1
        else:
            list2.next = self.mergeTwoLists(list1,list2.next)
            return list2

119 Pascal’s Triangle II

题目：输出杨辉三角某一行
法1⃣️：一行一行遍历

		yang = list(1 for i in range(rowIndex+1))
        for i in range(2,rowIndex+1):
            for j in range(i-1,0,-1):
                yang[j] += yang[j-1]
        return yang 

⚠️内层要倒着遍历，否则改变前值影响后值

法2⃣️：用排列组合c公式：本质是（a+b）^2拆开各项系数

class Solution:
    
    def comb(self, n, m):
        
        if n == m or m == 0:
            return 1
        else:
            return factorial(n) // ( factorial(m) * factorial(n-m) )
            #factorial 阶乘 

        
    def getRow(self, rowIndex: int) -> List[int]:       
        return [ self.comb(rowIndex,i) for i in range(0, rowIndex+1) ]
 

或：

        triangle = [1]
        
        for i in range(1, rowIndex + 1):
            triangle.append(int(triangle[i - 1] * (rowIndex - (i - 1)) / i))
        
        return triangle

141 Linked List Cycle->two pointers, dict

判断链表中有没有环
⚠️判断空指针

		if head == None:
            return False
        if head.next ==None:
            return False

法1⃣️：快慢指针：两指针重合证明有环

        slow = head
        fast = head.next
        while fast.next !=None and fast.next.next !=None:
            slow = slow.next
            fast = fast.next.next
            if slow == fast:
                return True
        return False

法2⃣️：字典
节点为key，值存什么都行

        dictionary = {}
        node = head
        while node:
            if node in dictionary:
                return True
            else:
                dictionary[node] =True
            node = node.next
        return False

155 Min Stack-> stack design

输出栈内最小值
法1⃣️：遍历栈

    def __init__(self):
        self.stack=[]

    def push(self, val: int) -> None:
        self.stack.append(val)

    def pop(self) -> None:
        self.stack.pop() 

    def top(self) -> int:
        return self.stack[-1]
        

    def getMin(self) -> int:
        minnum = self.stack[0]
        for item in self.stack:
            if item < minnum:
                minnum = item
        return minnum

法2⃣️：利用栈的特点，每个节点加一个最小值节点

    def __init__(self):
        self.stack=[]
        self.min = []

    def push(self, val: int) -> None:
        self.stack.append(val)
        if self.min:
            self.min.append(min(val,self.min[-1]))
        else:
            self.min.append(val)

    def pop(self) -> None:
        self.stack.pop() 
        self.min.pop()

    def top(self) -> int:
        return self.stack[-1]
        
    def getMin(self) -> int:
        return self.min[-1]

160 Intersection of Two Linked Lists

找到两个链表相交的位置

法1⃣️：字典

        dic = {}
        nodea =headA
        while nodea:
            dic[nodea] = nodea.val
            nodea = nodea.next
        nodeb = headB
        while nodeb:
            if nodeb in dic:
                return nodeb
            else:
                nodeb = nodeb.next
        return None

法2⃣️：拼接链表：重合的节点位置会对齐

⚠️：标记循环结束的位置

        nodea = headA
        nodeb = headB
        flaga =2
        flagb =2
        while (flagb or flaga):
            if nodea ==nodeb:
                return nodea
            if nodea.next:
                nodea = nodea.next
            else:
                nodea = headB
                flaga =flaga -1
            if nodeb.next:
                nodeb = nodeb.next
            else:
                nodeb = headA
                flagb =flagb-1
        return None

法3⃣️：根据题目值非0的特点判断,把一个链表转为全负值，看另一链表是否受影响（不普遍）

class Solution:
    def zeroreverse(self,head: ListNode)-> None:
        while head:
            head.val = head.val*(-1)
            head = head.next


    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
        self.zeroreverse(headA)
        nodeb = headB
        while nodeb:
            if nodeb.val<0: break
            nodeb = nodeb.next
        self.zeroreverse(headA)
        return nodeb

206 Reverse Linked List ->recursion❓

题目：反转字符串

法1⃣️：改下一个节点指针

		node = head
        if head ==None or head.next ==None:
            return  head
        mid =node.next
        node.next = None
        while mid:
            bac = mid.next
            mid.next = node
            node =mid
            mid = bac
        return node

法2⃣️：递归❓

    def reverseList(self, head: Optional[ListNode],prev = None) -> Optional[ListNode]:
        if not head:
            return prev
        temp = head.next
        head.next = prev
        return self.reverseList(temp, head)

234 Palindrome Linked List

检测链表是否回文
法1⃣️：转list验证

        value =[]
        while head:
            value.append(head.val)
            head =head.next
        first =0
        while first < len(value)-1-first:
            if value[first] != value[len(value)-1-first]:
                return False
            else:
                first = first +1
        return True

法2⃣️：反转后验证一半

        fast = slow = head
        while fast and fast.next:
            fast =fast.next.next
            slow = slow.next
        
        fast = slow
        prev =None
        while fast:
            nextnode = fast.next
            fast.next = prev
            prev = fast
            fast = nextnode
        slow = head
        while prev:
            if slow.val !=prev.val:
                return False
            else:
                slow =slow.next
                prev =prev.next
        return True