LeetCode每日一刷

day1

链接地址：https://blog.csdn.net/qq_40872999/article/details/105209750

003 无重复字符的最长子串

题目：给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。
示例 2:

输入: “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。
示例 3:

输入: “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-substring-without-repeating-characters
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
这是我很久之前写的，当我尝试重新再写的时候发现写不出来了，而且我自己看不懂自己的代码，论注释的重要性，，，，

class Solution {
  public int lengthOfLongestSubstring(String s) {
        char[] s_char = s.toCharArray();
        int[] len = new int[s.length()];
        for (int i = 0; i < len.length; i++) {
            len[i]=find(i,s_char[i],s_char);
        }
        int max=0;
        for (int j=0;j<len.length;j++){
            int maxlen=maxLen(j,len);
            max=maxlen>max?maxlen:max;
        }
        return max;
    }
    /**
     * 找的到返回出现位置，找不到返回最大长度
     * @param start
     * @param index
     * @param s
     * @return
     */
    public static int find(int start,char index,char[] s){
        start=start+1;
        for (;start<s.length;start++){
            if (index==s[start]){
                return start;
            }
        }
        return s.length;
    }
    public static int maxLen(int index,int[] len){
        int in=index+1;
        for (;in<len[index];in++){
            if (len[in]<len[index]){
                len[index]=len[in];
            }
        }
        return len[index]-index;
    }
}

004 寻找两个有序数组的中位数

题目：给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。

请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。

你可以假设 nums1 和 nums2 不会同时为空。

示例 1:

nums1 = [1, 3]
nums2 = [2]

则中位数是 2.0
示例 2:

nums1 = [1, 2]
nums2 = [3, 4]

则中位数是 (2 + 3)/2 = 2.5

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/median-of-two-sorted-arrays
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

看我写了折磨多，实际上考虑了想把时间浮渣度减下来，太南了

class Solution {
public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int len;
        if(nums1==null||nums1.length==0){
            len = nums2.length;
            int center = len/2;
            if((len&1^1)==0){
                return nums2[center];
            }else{
                return  (nums2[center]+nums2[center-1])/2.0;
            }

        }else if(nums2==null||nums2.length==0){
            len = nums1.length;
            int center = len/2;
            if((len&1^1)==0) {
                return nums1[center];
            }
            else{
                return  (nums1[center]+nums1[center-1])/2.0;
            }
        }else{
            int len1 = nums1.length;
            int len2 = nums2.length;
            int n1t = nums1[0];
            int n1w = nums1[len1-1];
            int n2t = nums2[0];
            int n2w = nums2[len2-1];
            if (n1w<=n2t){
                if (len1>len2){
                    return (nums1[(len1+len2)/2]+nums1[(len1+len2)/2-((len1+len2)&1^1)])/2.0;
                }else if (len1==len2){
                    return (n1w+n2t)/2.0;
                }else{
                    return (nums2[(len2-len1)/2]+nums2[(len2-len1)/2-((len1+len2)&1^1)])/2.0;

                }
            }else if(n2w<=n1t){
                if (len1>len2){
                    return (nums1[(len1-len2)/2]+nums1[(len1-len2)/2-((len1+len2)&1^1)])/2.0;
                }else if (len1==len2){
                    return (n1t+n2w)/2.0;
                }else{
                    return (nums2[(len1+len2)/2]+nums2[(len1+len2)/2-((len1+len2)&1^1)])/2.0;
                }
            }else {
                return sort(nums1,nums2,len1,len2);
            }
        }
    }
    public double sort(int a[],int b[],int len1,int len2){
        int[] nums=new int[len1+len2];
       for (int i=0,j=0,k=0;k<len1+len2;k++){
           if (i==len1){
               nums[k]=b[j];
               j++;
               continue;
           }
           if (j==len2){
               nums[k]=a[i];
               i++;
               continue;
           }
           if (a[i]<b[j]){
               nums[k]=a[i];
               i++;
           }else if(a[i]>b[j]){
               nums[k]=b[j];
               j++;
           }else {
               nums[k]=b[j];
               j++;
               k++;
               nums[k]=a[i];
               i++;
           }
       }
        return (nums[(len1+len2)/2]+nums[(len1+len2)/2-((len1+len2)&1^1)])/2.0;
    }
}