刷题记录之两个数组合并得到最大值

发现了一个特别有意思的事情，以前认为是很简单的，昨天下午到今天发现，事情原来不是那么的简单,原题链接见：

根据部分题解，我以为这道题主要是考察单调栈，分别从两个数组中找出各自最大的单调队列，然后将两个单调递减合并就可以得到结果值。

首先，我的思路是：先将两个数组进行合并成为一个大的数组值，然后从中删除num1.length+num2.length-k位数字就可以得到结果，当然这个思路是错误的，因为它没有考虑到，如果一个数组为：
arr1 = {5,6,3,9,2};
arr2 = {8,3,5,4};
k = 5;

他无法能够使得真正的98354成为结果，因为9永远不可能根据这种方法成为第一个数字;

第二种思路：从第一个数组中找出最大序列子串长度为n1,从第二个数组中找出最大序列子串长度为n2,使得n1+n2 == k,这大大的加大了时间复杂度，需要从0到k分别遍历尝试。有趣的是，写本篇博客的地方出现了，当我分别从数组1，数组2中找到了各自最大的子串，要进行合并时，我本来以为和归并排序中一样，可以随便把=分到一边，让另一个数组的序列进行索引递增，但是现实表示这个是不行的，具体例子，参考：

[6,7]
[6,0,4]
5
输出：
[6,6,7,0,4]
预期：
[6,7,6,0,4]

本来按照肉眼的情况，应该先对第一个数组索引进行后移，当我们把等号分给第一个num1[i1] <= num2[i2]时，就会让先将第二个子串的6放到数组中，再然后第一个数组6和第二个数组0进行比较，自然是第二位为6，导致了结果错误。相反的，如果把等号分给了第二个，就让两个数组互换，还是不满足情况，因此这种一边倒，给另一边的想法是错误的。代码可见：

  public int[] merge(int[] nums1,int[] nums2){
        int[] nums = new int[nums1.length+nums2.length];
        int i1 = 0;
        int i2 = 0;
        int index = 0;

        while(i1 < nums1.length && i2 < nums2.length){
            if(nums1[i1] <= nums2[i2]){
                nums[index++] = nums2[i2];
                i2++;
            }else{
                nums[index++] = nums1[i1];
                i1++;
            }
        }

        while(i1 < nums1.length){
            nums[index++] = nums1[i1];
            i1++;
        }

        while(i2 < nums2.length){
            nums[index++] = nums2[i2];
            i2++;
        }
        return nums;
    }

于是，需要对等号进行特殊的处理，我想的是，先进行一次预判，如果第一个数组相等后面的数字比第二个数组相等后面的数字大，就先去移动第一个数组索引，否则，就移动第二个数组索引，（这里的后面的数字相等，我觉得不需要考虑，总是移动第一个，因为，当相等的时候，移动哪个都可以，总会在下次比较中得到大小）
但是，这里同时也存在着一个问题，就是我们要进行预判，需要访问当前元素的下一个元素，需要判断数组越界情况，如果当前元素已经是第一个数组的最后一个元素，使用num1[i1+1]会造成越界，因此，在这种情况下，先移动第二个数组索引，反之，移动第一个数组索引，看起来已经考虑到了所有的情况，已经天衣无缝。可还是报错了，还是有的情况没有考虑到，具体样例如下：
输入：
[5,0,2,1,0,1,0,3,9,1,2,8,0,9,8,1,4,7,3]
[7,6,7,1,0,1,0,5,6,0,5,0]
31
输出：
[7,6,7,5,1,0,2,1,0,1,0,3,9,1,2,8,0,9,8,1,4,7,3,0,1,0,5,6,0,5,0]
预期：
[7,6,7,5,1,0,2,1,0,1,0,5,6,0,5,0,1,0,3,9,1,2,8,0,9,8,1,4,7,3,0]

当执行到1010的时候，由于相等，而且预判相等，于是我们先执行第一个数组，于是当0执行完后，就会造成第一个的3与第二个的1进行比较，这是就开始执行选上了3，这与本来结果应该选择6完全不一样，答案错误。

不断地分情况判断，导致思路混乱，这完完全全是一个不好的编程习惯；
当时的解法如下：

public int[] merge(int[] nums1,int[] nums2){
        int[] nums = new int[nums1.length+nums2.length];
        int i1 = 0;
        int i2 = 0;
        int index = 0;

        while(i1 < nums1.length && i2 < nums2.length){
            if(nums1[i1] < nums2[i2]){
                nums[index++] = nums2[i2];
                i2++;
            }else if(nums1[i1] > nums2[i2]){
                nums[index++] = nums1[i1];
                i1++;
            }else{
                if(i1+1 >= nums1.length){
                    nums[index++] = nums2[i2];
                    i2++;
                    continue;
                }else if(i2+1 >= nums2.length){
                    nums[index++] = nums1[i1];
                    i1++;
                    continue;
                }else if(nums1[i1+1] >= nums2[i2+1]){
                    nums[index++] = nums1[i1];
                    i1++;
                    continue;
                }else if(nums2[i2+1] > nums1[i1+1]){
                    nums[index++] = nums2[i2];
                    i2++;
                    continue;
                }
            }
        }

        while(i1 < nums1.length){
            nums[index++] = nums1[i1];
            i1++;
        }

        while(i2 < nums2.length){
            nums[index++] = nums2[i2];
            i2++;
        }
        return nums;
    }

下来说一下题解中的正确答案，它的时间复杂度更大，每次要选择右移哪个索引的时候，总是会比较从当前元素开始，后面的子串比较大的哪个。而不用纠结预判什么的，太妙了，比自己错误的想法逻辑简单，而且很容易想清楚，不用纠结于太多的细节,代码如下：

 private int compare(int[] arr1, int i, int[] arr2, int j) {
        for (; i < arr1.length && j < arr2.length && arr1[i] == arr2[j]; i++, j++) 
        	;
        if (i == arr1.length && j == arr2.length)
            return 0;
        if (i == arr1.length) 
            return -1;
        if (j == arr2.length) 
            return 1;
        return arr1[i] > arr2[j] ? 1 : -1;

    }

    private int[] merge(int[] sub1, int[] sub2) {
        int[] merge = new int[sub1.length + sub2.length];
        for (int i = 0, j = 0, k = 0; k < merge.length; k++) {
            if (i == sub1.length)
                merge[k] = sub2[j++];
            else if (j == sub2.length)
                merge[k] = sub1[i++];
            else if (compare(sub1, i, sub2, j) >= 0) 
                merge[k] = sub1[i++];
            else 
                merge[k] = sub2[j++];
        }
        return merge;
    }