题解2

239. 滑动窗口最大值

解法一：

class Solution {
    //暴力解，直接遍历每一个滑动窗口，找到最大值
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums == null || nums.length < 2)
            return nums;
        int max;
        int[] maxvalue = new int[nums.length-k+1];
        for(int i = 0; i < nums.length-k+1; i ++){
            max = nums[i];
            for(int j = i; j < i+k; j++){
                if(max < nums[j])
                    max = nums[j];
            }
            maxvalue[i] = max;
        }
        return maxvalue;
    }
}

解法二：

class Solution {
    /*
    list队列保存当前窗口中最大那个数的下标，list新的头总是当前窗口中最大的那个数。
    遍历数组，依次加入list，并保持队列中元素从大到小排序。如果list内的个数大于等于k，则出队第一个元素，
    */
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums == null || nums.length < 2)
            return nums;
        int[] maxvalue = new int[nums.length-k+1];
        LinkedList<Integer> list = new LinkedList<Integer>();
        for (int i = 0; i < nums.length; i++) {
            //i - list.getFirst()为list中元素的个数
            if (!list.isEmpty() && i - list.getFirst() >= k) {
                list.removeFirst();
            }
            //保持队列的第一个元素为当前窗口的最大元素
            while (!list.isEmpty() && nums[list.getLast()] < nums[i]) {
                list.removeLast();
            }
            list.addLast(i);
            //从第k个元素开始记录最大值
            if (i >= (k - 1)) {
                maxvalue[i-k+1] = nums[list.getFirst()];
            }
        }
        return maxvalue;
    }
}

4. 寻找两个正序数组的中位数

解法一：

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int m = nums1.length, n = nums2.length;
        //如果两个数组有一个为空的情况下，直接取不为空的数组的中间值即可
        if (m == 0) {
            if (n % 2 == 0)
                return (nums2[n / 2 - 1] + nums2[n / 2]) / 2.0;
            else
                return nums2[n / 2];
        }
        if (n == 0) {
            if (m % 2 == 0)
               return (nums1[m / 2 - 1] + nums1[m / 2]) / 2.0;
            else
                return nums1[m / 2];
        }
        //用num数组按大小存储两个数组的元素，然后取中间值
        int[] num = new int[m + n];
        //count为num的下标，i为nums1的下标，j为nums2的下标
        int count = 0, i = 0, j = 0;
        while (count != (m + n)) {
            //如果nums1遍历完了
            if (i == m) {
                while (j != n) {
                    num[count++] = nums2[j++];
                }
                break;
            }
            //如果nums2遍历完了
            if (j == n) {
                while (i != m) {
                    num[count++] = nums1[i++];
                }
                break;
            }
            //取小的数给num
            if (nums1[i] < nums2[j]) {
                num[count++] = nums1[i++];
            } else {
                num[count++] = nums2[j++];
            }
        }
        if(num.length % 2 == 1)
            return (double)num[num.length/2];
        else{
            return ((double)(num[num.length/2-1] + num[num.length/2]))/2;
        }
    }
}

解法二：

class Solution {
    //找到中间数就不找了，如果是奇数，返回最后一个数即可，如果是偶数，则需要返回最后两个数的平均数
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int m = nums1.length, n = nums2.length;
        int len = m + n;
        //p记录q的前一个数，q从小到大记录每一个数，最后一个记录的就是中间数，a记录nums1的下标，b记录nums2的下标
        int p = 0, q = 0, a = 0, b = 0;
        for (int i = 0; i <= len / 2; i++) {
            p = q;
            //如果nums1数组没有遍历完，且当前数小于nums2，或者nums2遍历完了，则赋值给q
            if (a < m && (b >= n || nums1[a] < nums2[b])) {
                q = nums1[a++];
            //同理
            } else {
                q = nums2[b++];
            }
        }
        if ((len & 1) == 0)
            return (p + q) / 2.0;
        else
            return q;
    }
}

264. 丑数Ⅱ

class Solution {
    // 令nums[0] = 1，每一位数都各有一次*2,*3,*5的机会，然后按照大小排列起来，第n个数即为要找的那个数
    public int nthUglyNumber(int n) {
        int[] nums = new int[n];
        nums[0] = 1;
        
        int i2 = 0, i3 = 0, i5 = 0;
        int temp = 1;

        for (int i = 1; i < n; i++) {
            temp = Math.min(Math.min(nums[i2] * 2, nums[i3] * 3), nums[i5] * 5);
            nums[i] = temp;

            if (temp == nums[i2] * 2) {
                i2++;
            } 
            if (temp == nums[i3] * 3) {
                i3++;
            }
            if (temp == nums[i5] * 5) {
                i5++;
            }
        }
        return nums[n - 1];
    }
}

313 超级丑数

class Solution {
    public int nthSuperUglyNumber(int n, int[] primes) {
        //nums记录超级丑数
        int[] nums = new int[n];
        nums[0] = 1;
        //p记录primes中每一个数下次需要乘的下标
        int[] p = new int[primes.length]; 
        for(int i = 0; i < primes.length; i ++){
            p[i] = 0;
        }
        //计算前n个丑数
        for(int i = 1; i < n; i ++){
            int temp = Integer.MAX_VALUE;
            for(int j = 0; j < primes.length; j ++){
                if(temp > primes[j]*nums[p[j]])
                    temp = primes[j]*nums[p[j]];
            }
            nums[i] = temp;
            for(int j = 0; j < primes.length; j ++){
                if(temp == primes[j]*nums[p[j]])
                    p[j] ++;
            }
        }
        return nums[n-1];
    }  
}