LeetCode 热题 HOT 100 -------3. 无重复字符的最长子串、4、寻找两个正序数组的中位数

//解题思路：典型的“滑动窗口”解题，思想就是用哈希表(表示队列思想))，遍历字符串，每个字符作key,而我们的字符对应的位置作value，每次放入前应该判别有没有这个key，如果有我们就 从这个值的下一个字符开始算起(map.containsKey(s.charAt(i))),与遍历到i时的最大字符串长度为Math.max( max,i-left+1)

//一直维持这样的队列，找出队列出现最长的长度时候，求出解！
// class Solution {
//     public int lengthOfLongestSubstring(String s) {
//         //如果字符串长度为0，则返回0
//         if(s.length()==0){
//             return 0;
//         }
//         //定义返回的最大值以及当前重复字符的位置
//         int max = 0;
//         int left = 0;
//         //定义哈希表
//         Map<Character,Integer> map = new HashMap<Character,Integer>();
//         //遍历字符串
//         for(int i = 0 ; i< s.length() ; i++){
//             if(map.containsKey(s.charAt(i))){
//                 //说明包含了重的，我们开始从重复的字符的位置的下一个字符开始记
//                 left = Math.max(left,map.get(s.charAt(i))+1);
//             }
//             //如果不包含我们就把字符放入
//             map.put(s.charAt(i),i);
//             //然后更新最大值
//             max = Math.max(max,i-left+1);
//         }
//         return max;
//     }
// }

//第二遍做，一开始没想起来滑动窗口，多做总结
class Solution {
    public int lengthOfLongestSubstring(String s) {
        if(s.length() == 0)
            return 0;
        //通过哈希表满足滑动窗口
        Map<Character , Integer> map = new HashMap<Character , Integer>();
        int max = 0;   //因为我们求得子串长度，所以取0即可，不然可以取Integer.MIN_VALUE
        int left = 0;
        for(int i=0 ; i<s.length() ; i++){
            if(map.containsKey(s.charAt(i))){   //当遇到重复的字符,将左边界移到当前重复字符的下一个，右边界为当前i
                left = Math.max(left , map.get(s.charAt(i))+1);
            }
            //然后将其放入，如果重复的就覆盖
            map.put(s.charAt(i) , i);
            max = Math.max(max , i-left+1);
        }
        return max;
    }
}

/**我们可以先合并，合并完了再找中位数
注意点：除以2的时候要写成2.0
时间复杂度O(m+n) , 空间复杂度O(m+n)
*/
class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        //先创建一个新的数组,确定个数
        int n1 = nums1.length;
        int n2 = nums2.length;
        int[] nums3 = new int[n1+n2];   //创建了新的数组
        //然后进行排序
        //首先判断是否有其中一个数组为空
        if(n1 == 0){
            //奇偶判断
            if((n2 & 1) == 1){  //奇数
                return nums2[n2/2];
            }else{
                return (nums2[n2/2-1] + nums2[n2/2])/2.0;
            }
        }
        if(n2 == 0){
            if((n1 & 1) == 1){
                return nums1[n1/2];
            }else{
                return (nums1[n1/2-1] + nums1[n1/2])/2.0;
            }
        }
        //当都不为空，进行判断，各数组分别需要一个索引
        int i=0 , j=0 , k=0;
        while(k != (n1+n2)){
            //先判断两个数组剩余的部分
            if(i==n1){
                while(j!=n2){
                    nums3[k++] = nums2[j++];
                }
                break;   
            }
            if(j==n2){
                while(i!=n1){
                    nums3[k++] = nums1[i++];
                }
                break;
            }
            if(nums1[i] >= nums2[j]){
                nums3[k] = nums2[j];
                j++;
            }else{
                nums3[k] = nums1[i];
                i++;
            }
            k++;
        }
        if( (k & 1) == 1){   //奇数
            return nums3[k/2];
        }else{
            return (nums3[k/2 -1] + nums3[k/2])/2.0;
        }
    }
}

/*解题思路2：是否可以把空间复杂度降低呢？O(m+n)，我们没必要合并数组
只要找出奇偶数对应的中位数的索引即可   
当m+n为奇数：中位数就是 (m+n)/2
当m+n为偶数：中位数就是 ((m+n)/2)-1 和(m+n)/2 ，我们通过让left每次记录上一次的值，就也相当于求到(m+n)/2即可
时间复杂度O(m+n) 空间复杂度O(1)
*/
class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int n1 = nums1.length;
        int n2 = nums2.length;
        int len = n1 + n2;
        int left =-1 , right = -1;  //当前循环得到的值
        //索引处
        int nums1Idex = 0 , nums2Idex = 0;
        for(int i=0 ; i<=len/2 ; i++){
            left = right;   //先得到上次循环得到的值 
            if(nums1Idex < n1 &&( nums2Idex>=n2 || nums1[nums1Idex] < nums2[nums2Idex])){     
                //nums2Idex>=n2 || nums1[nums1Idex] < nums2[nums2Idex] Ⅰ比较两个数组的大小 Ⅱ其中一个数组已经到头了
                right = nums1[nums1Idex++];
            }else{
                right = nums2[nums2Idex++];
            }
        }
        if((len & 1) == 1){  //奇数
            return right;
        }else{
            return (right + left)/2.0;
        }
    }
}

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int n = nums1.length;
        int m = nums2.length;
        //因为数组是从索引0开始的，因此我们在这里必须+1，即索引(k+1)的数，才是第k个数。
        int left = (n + m + 1) / 2;
        int right = (n + m + 2) / 2;
        //将偶数和奇数的情况合并，如果是奇数，会求两次同样的 k
        return (getKth(nums1, 0, n - 1, nums2, 0, m - 1, left) + getKth(nums1, 0, n - 1, nums2, 0, m - 1, right)) * 0.5;
    }
    private int getKth(int[] nums1, int start1, int end1, int[] nums2, int start2, int end2, int k) {
        //因为索引和算数不同6-0=6，但是是有7个数的，因为end初始就是数组长度-1构成的。
        //最后len代表当前数组(也可能是经过递归排除后的数组)，符合当前条件的元素的个数
        int len1 = end1 - start1 + 1;
        int len2 = end2 - start2 + 1;
        //让 len1 的长度小于 len2，这样就能保证如果有数组空了，一定是 len1
        //就是如果len1长度小于len2，把getKth()中参数互换位置，即原来的len2就变成了len1，即len1，永远比len2小
        if (len1 > len2) return getKth(nums2, start2, end2, nums1, start1, end1, k);
        //如果一个数组中没有了元素，那么即从剩余数组nums2的其实start2开始加k再-1.
        //因为k代表个数，而不是索引，那么从nums2后再找k个数，那个就是start2 + k-1索引处就行了。因为还包含nums2[start2]也是一个数。因为它在上次迭代时并没有被排除
        if (len1 == 0) return nums2[start2 + k - 1];

        //如果k=1，表明最接近中位数了，即两个数组中start索引处，谁的值小，中位数就是谁(start索引之前表示经过迭代已经被排出的不合格的元素，即数组没被抛弃的逻辑上的范围是nums[start]--->nums[end])。
        if (k == 1) return Math.min(nums1[start1], nums2[start2]);

        //为了防止数组长度小于 k/2,每次比较都会从当前数组所生长度和k/2作比较，取其中的小的(如果取大的，数组就会越界)
        //然后数组如果len1小于k / 2，表示数组经过下一次遍历就会到末尾，然后后面就会在那个剩余的数组中寻找中位数
        int i = start1 + Math.min(len1, k / 2) - 1;
        int j = start2 + Math.min(len2, k / 2) - 1;

        //如果nums1[i] > nums2[j]，表示nums2数组中包含j索引，之前的元素，逻辑上全部淘汰，即下次从J+1开始。
        //而k则变为k - (j - start2 + 1)，即减去逻辑上排出的元素的个数(要加1，因为索引相减，相对于实际排除的时要少一个的)
        if (nums1[i] > nums2[j]) {
            return getKth(nums1, start1, end1, nums2, j + 1, end2, k - (j - start2 + 1));
        }else {
            return getKth(nums1, i + 1, end1, nums2, start2, end2, k - (i - start1 + 1));
        }
    }
}