力扣解题思路：480. 滑动窗口中位数 纠错记录

思路：
这一题我本来是会的，结果时隔一段时间就有错了，再次记录一下，与这一题类似的有295. 数据流的中位数
和239. 滑动窗口最大值，这两题都是使用堆来解题的，中位数的话就需要两个堆，两个堆的堆顶取平均就是对的啦~

于是我就开始：

class Solution {
    public double[] medianSlidingWindow(int[] nums, int k) {
        double[] medians = new double[nums.length - k + 1];
        int index = 0;
        PriorityQueue<Integer> large = new PriorityQueue<Integer>(new Comparator<Integer>(){
            public int compare(Integer o1,Integer o2){
                return o2 - o1;
            }
        });
        PriorityQueue<Integer> small = new PriorityQueue<Integer>();
        for(int i=0;i<nums.length;i++){
            if(i<k){
                small.add(nums[i]);
                if(small.size() > large.size()) large.add(small.poll());
                if(i == k-1) medians[index++] = largeHeap.size() == smallHeap.size() ? (largeHeap.peek() + smallHeap.peek()) * 0.5 : largeHeap.peek();
            }else{
                if(nums[i - k] <= large.peek()) { // 被替换的元素在大顶堆中
        			large.remove(nums[i - k]);
        			small.add(nums[i]);
                    large.add(small.poll());
        		}
        		else {
        			small.remove(nums[i - k]);
        			large.add(nums[i]);
                    small.add(large.poll());
        		}
                medians[index++] = largeHeap.size() == smallHeap.size() ? (largeHeap.peek() + smallHeap.peek()) * 0.5 : largeHeap.peek();
            }
        }
        return medians;
    }
}

然后就出现了第一个错，测试用例中有的数在return o2 - o1;这里超出了int类型的最大长度。。。
于是我懒得管了，干脆用long吧，把所有类型都换成long(我太笨了，当时其实可以换成new PriorityQueue<>((o1,o2)->Integer.compare(o2,o1))的，但是我既然都改成了long就放弃挣扎了。。。)
注意换成long后这里不可以直接return o2 - o1噢，因为我们需要的返回值类型必须是int，所以就自己定义啦~

class Solution {
    public double[] medianSlidingWindow(int[] nums, int k) {
        double[] medians = new double[nums.length - k + 1];
        int index = 0;
        long[] longNums = new long[nums.length];
		for(int i = 0; i < nums.length; i++) {
			longNums[i] = nums[i];
		}
        PriorityQueue<Long> large = new PriorityQueue<Long>(new Comparator<Long>(){
            public int compare(Long o1,Long o2){
                if(o2 - o1 > 0) {
        			return 1;
        		}
        		else if(o2 - o1 < 0) {
        			return -1;
        		}
        		else {
        			return 0;
        		}
            }
        });
        PriorityQueue<Long> small = new PriorityQueue<Long>();
        for(int i=0;i<nums.length;i++){
            if(i<k){
                small.add(longNums[i]);
                if(small.size() > large.size()) large.add(small.poll());
                if(i == k-1) medians[index++] = large.size() == small.size() ? (large.peek() + small.peek()) * 0.5 : large.peek();
            }else{
                if(nums[i - k] <= large.peek()) { // 被替换的元素在大顶堆中
        			large.remove(longNums[i - k]);
        			small.add(longNums[i]);
                    large.add(small.poll());
        		}
        		else {
        			small.remove(longNums[i - k]);
        			large.add(longNums[i]);
                    small.add(large.poll());
        		}
                medians[index++] = large.size() == small.size() ? (large.peek() + small.peek()) * 0.5 : large.peek();
            }
        }
        return medians;
    }
}

改好之后又出现了新的问题！！我这个堆的插入方法就是有问题的，因为我每次先往小顶堆插，再往大顶堆插，这就导致最开始放入大顶堆的那个数字永远无法进入小顶堆（也是就是nums数组中第一个数）。我们都知道这个小顶堆实际上存放的就是最大的一半数，而大顶堆存放的最小一半的数，如果最开始不分青红皂白直接把第一个数放入大顶堆，假如这个数很大（应该属于小顶堆），那么答案就会出错。

那么如何解决呢？我的方法是：来回倒饬😂，那样即使是开始第一个数被分错，那他也有机会在来回倒饬的时候被换到正确的位置！！！

                large.add(longNums[i]);
                small.add(large.poll());
                if(small.size() > large.size()) large.add(small.poll());

完整代码就是这样：

    public double[] medianSlidingWindow(int[] nums, int k) {
        double[] medians = new double[nums.length - k + 1];
        int index = 0;
        long[] longNums = new long[nums.length];
		for(int i = 0; i < nums.length; i++) {
			longNums[i] = nums[i];
		}
        PriorityQueue<Long> large = new PriorityQueue<Long>(new Comparator<Long>(){
            public int compare(Long o1,Long o2){
                if(o2 - o1 > 0) {
        			return 1;
        		}
        		else if(o2 - o1 < 0) {
        			return -1;
        		}
        		else {
        			return 0;
        		}
            }
        });
        PriorityQueue<Long> small = new PriorityQueue<Long>();
        for(int i=0;i<nums.length;i++){
            if(i<k){
                large.add(longNums[i]);
                small.add(large.poll());
                if(small.size() > large.size()) large.add(small.poll());
                if(i == k-1) medians[index++] = large.size() == small.size() ? (large.peek() + small.peek()) * 0.5 : large.peek();
            }else{
                if(nums[i - k] <= large.peek()) { // 被替换的元素在大顶堆中
        			large.remove(longNums[i - k]);
        			small.add(longNums[i]);
                    large.add(small.poll());
        		}
        		else {
        			small.remove(longNums[i - k]);
        			large.add(longNums[i]);
                    small.add(large.poll());
        		}
                medians[index++] = large.size() == small.size() ? (large.peek() + small.peek()) * 0.5 : large.peek();
            }
        }
        return medians;
    }
}