力扣1~5题

题1（简单）.

思路：

        因为时间复杂度小于n^2,所以不能双for遍历，怎么优化？

        这里采用一个键值对的形式，存储nums离target的间隔和它的下标，只要n，然后再遍历nums有没有刚好是这个距离的就好了，只要注意两相同的数字这种情况就好了

python3代码

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        need={}
        for i in range(0,len(nums)):
            a=target-nums[i]
            need[a]=i
        for i in range(0,len(nums)):
            if(need.get(nums[i],'')!='' and need.get(nums[i],'')!=i):
                return [i,need[nums[i]]]

题2（中等）：

思路：

无非就是设置一个进位标志就好了，但是呢，这个东西的python，我没看懂它的参数是啥东西，所以用c++，

c++代码

ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode* head;
        ListNode* tail;
        int flag=0;
        for(int i=0;;i++){
            int val1=(l1==NULL)?0:l1->val;
            int val2=(l2==NULL)?0:l2->val;
            int sum=(val1+val2+flag)%10;
            flag=(val1+val2+flag)/10;
            ListNode* newNode=new ListNode(sum);
            if(i==0){
                head=newNode;
                tail=newNode;
            }
            else{
                tail->next=newNode;
                tail=tail->next;
            }
            if(l1!=NULL) {l1=l1->next;}
            if(l2!=NULL) {l2=l2->next;}
            if(l1==NULL&&l2==NULL&&flag==0){
                break;
            }
        
        }
        return head;
            


    }

题3（中等）：

思路：

我们可以用一个字符串来接受子串，如果发现有重复字符就统计长度再切割前面的

python3代码

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        n=[]
        ss=''
        for i in range(len(s)):
            if s[i] not in ss:
                ss+=s[i]
            else:
                n.append(len(ss))
                ss=ss.split(s[i])[-1]+s[i]

        n.append(len(ss))

        return max(n)

题4（困难）：

思路：

找两数组中位数，这个看起来简单，顺手反应就是数第(m+n)/2个，这个难在要求时间复杂度为log(m+n)，所以不能这样搞，我的思路是：每次切割长度为较小长度的一半，然后比较哪个对中位数没有影响就切哪个

python代码

    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        med=None

        while 1:
            if len(nums1) == 0:
                med2 = nums2[(len(nums2)) // 2] if len(nums2) % 2 == 1 else (nums2[len(nums2) // 2 - 1] + nums2[
                    len(nums2) // 2]) / 2
                med = med2
                break
            if len(nums2) == 0:
                med1 = nums1[(len(nums1)) // 2] if len(nums1) % 2 == 1 else (nums1[len(nums1) // 2 - 1] + nums1[
                    len(nums1) // 2]) / 2
                med = med1
                break

            if (len(nums1) + len(nums2) <= 2):
                med = ((nums1[0] if len(nums1) > 0 else 0) + (nums2[0] if len(nums2) > 0 else 0)) / (len(nums1) + len(nums2))
                break

            cutlen=len(nums1)//2 if len(nums1)<=len(nums2) else len(nums2)//2
            if(cutlen<1):
                cutlen=1
            if nums1[cutlen-1]<nums2[cutlen-1]:
                nums1=nums1[cutlen:]
            else:
                nums2=nums2[cutlen:]
            if len(nums1)!=0 and (len(nums2)==0 or nums1[len(nums1)-cutlen]>nums2[len(nums2)-cutlen]) :
                nums1=nums1[:len(nums1)-cutlen]
            else:
                nums2=nums2[:len(nums2)-cutlen]


        return med

题5（中等）：

思路：

第一步，统计所有回文可能的起点

python代码：

def longestPalindrome(self, s: str) -> str:

        if len(s)==0 or len(s)==1:

            return s

        #第一步，统计所有回文可能的起点

        p_start=[]

        #p_start里面含有[左值，右值，长度]

        for i in range(len(s)-1):

            if s[i]==s[i+1]:

                p_start.append({'left':i,'right':i+1,'length':2})

            if i-1>=0 and i+1<len(s) and s[i-1]==s[i+1]:

                p_start.append({'left':i-1,'right':i+1,'length':3})

        for p in p_start:

            while 1:

                if p['left']-1>=0 and p['right']+1<len(s) and s[p['left']-1]==s[p['right']+1]:

                    p['left']-=1

                    p['right']+=1

                    p['length']+=2

                else:

                    break

        res_len=0

        res=0

        for i in range(len(p_start)):

            res_len,res=(p_start[i]['length'],i) if p_start[i]['length']>res_len else (res_len,res)

        return s[p_start[res]['left']:p_start[res]['right']+1] if len(p_start)!=0 else s[0]