力扣练习2:分治

  1. 多数元素
    解法一: 遍历整个数组,然后用另一重循环统计每个数字出现的次数。将出现次数大于len/2的数字返回。
    时间复杂度:O(n^2)
class Solution {
    public int majorityElement(int[] nums) {
        int majorityCount = nums.length/2;

        for (int num : nums) {
            int count = 0;
            for (int elem : nums) {
                if (elem == num) {
                    count ++;
                }
            }

            if (count > majorityCount) {
                return num;
            }

        }

        return -1;    
    }
}

解法二: 如果所有数字被单调递增或者单调递减的顺序排了序,那么众数的下标为 n/2(偶数时为n/2+1)
时间复杂度:O(nlgn)
力扣练习2:分治_第1张图片

class Solution {
    public int majorityElement(int[] nums) {
        Arrays.sort(nums);
        return nums[nums.length/2];
    }
}

  1. 数组中的第K个最大元素
    解法一: 直接使用库函数sort排序后输出len-k即可,时间复杂度:O(Nlog⁡N)
    解法二: 快速排序的思想是每轮选中一个基准值,然后两个指针分别从头尾遍历直到相遇,在该轮结束时,将基准值调换到合适的位置,使他左边都比他小,右边都比他大。这道题显然可以利用这种思想,先将比基准值大的元素都分到数组的右边,看基准值的位置是否是len-k,大了就到前半再排,小了就到后半再排,直到相等。
    这种情况下时间复杂度:O(以n为首项,1/2为公比的等比数列的和) = O(n)
    需要注意的时,这种方法对于越混乱的越高效,如果面对最坏情况(已经有序排列),这种方法会达到 O(N^2),毫无意义。所以必须随机选择初始基准值。
import java.util.Random;
public class Solution {
 	private static Random random = new Random(System.currentTimeMillis());
    public int findKthLargest(int[] nums, int k) {
        int len = nums.length;
        int left = 0;
        int right = len - 1;

        int target = len - k;

        while (true) {
            int index = partition(nums, left, right);
            if (index == target) {
                return nums[index];
            } else if (index < target) {
                left = index + 1;
            } else {
                right = index - 1;
            }
        }
    }

   
    public int partition(int[] nums, int left, int right) {
    // 在区间随机选择一个元素作为标定点
        if (right > left) {
            int randomIndex = left + 1 + random.nextInt(right - left);
            swap(nums, left, randomIndex);
        }


        int pivot = nums[right];
        int j = right;
        for (int i = right-1; i>=left; i--) {
            if (nums[i] > pivot) {
                // 大于 pivot 的元素都被交换到后面
                j--;
                swap(nums, j, i);
            }
        }
      
        swap(nums, j, right);
      
        return j;
    }

    private void swap(int[] nums, int index1, int index2) {
        int temp = nums[index1];
        nums[index1] = nums[index2];
        nums[index2] = temp;
    }
}


  1. 寻找两个有序数组的中位数
    解法一: 因为是两个有序数组,所以只要设置两个指针遍历两个数组,找到中位数即可。注意区别总长奇偶两种情况,且两种情况都需要遍历len/2+1次:
    如果是奇数,我们需要知道第 (len+1)/2 个数,
    如果是偶数,我们需要知道第 len/2和 len/2+1 个数
    时间复杂度:遍历 len/2+1 次,len=m+n,所以时间复杂度O(m+n)O(m+n)O(m+n)。
    空间复杂度:申请了常数个变量,所以空间复杂度是 O(1)O(1)O(1)。
class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int n=nums1.length;
        int m=nums2.length;
        int len=n+m;
        int pa=0,pb=0;//两个指针
        int before=-1,after=-1;//长为偶数时需存储前一个值

        for(int i=0;i<len/2+1;i++){
	        //最后一次循环befor保存前一次,after更新
            before=after;
            //a,b未到头时a值比b值小 a++ 否则 b++
            //a 到头,即b剩下的都比a大,继续遍历b;b到头同理
            //因为遍历len/2+1次,所以不会a,b同时到头
            if(pa<n & (pb>=m || nums1[pa]<nums2[pb])){
                after=nums1[pa++];
            }else{
                after=nums2[pb++];
            }
        }
        if(len%2==0){
            return (before+after)/2.0;
        }else{
            return after;
        }
    }
}

解法2: 题目要求算法的时间复杂度为 O(log(m + n)),所以要运用分治法,也就是上一题“输出前K大的元素“。
时间复杂度:每进行一次循环,就减少 k/2 个元素,所以时间复杂度是 O(log(k)),而
k=(m+n)/2,所以最终的复杂度为 O(log(m+n)。
空间复杂度:O(1)。

解法一中,我们一次遍历就相当于去掉不可能是中位数的一个值,也就是一个一个排除。由于数列是有序的,其实我们完全可以一半儿一半儿的排除。假设我们要找第 k 小数,我们可以每次循环排除掉 k/2 个数。看下边一个例子。

假设我们要找第 7 小的数字。
力扣练习2:分治_第2张图片

我们比较两个数组的第 k/2 个数字,如果 k 是奇数,向下取整。也就是比较第 3 个数字,上边数组中的 4 和下边数组中的3,哪个小,就表明该数组的前 k/2 个数字都不是第 k 小数字,所以可以排除。也就是 1,2,3 这三个数字不可能是第7 小的数字,我们可以把它排除掉。将 1349和 45678910两个数组作为新的数组进行比较。

更一般的情况 A[1] ,A[2] ,A[3],A[k/2] … ,B[1],B[2],B[3],B[k/2] … ,如果
A[k/2]

A 数组中比 A[k/2] 小的数有 k/2-1 个,B 数组中,B[k/2] 比 A[k/2] 小,所以比 A[k/2] 小的数字最多有 k/2-1+k/2-1=k-2个,所以 A[k/2]最多是第 k-1 小的数。而比 A[k/2] 小的数更不可能是第 k 小的数了,所以可以把它们排除。

橙色的部分表示已经去掉的数字。

力扣练习2:分治_第3张图片

由于我们已经排除掉了 3 个数字,就是这 3 个数字一定在最前边,所以在两个新数组中,我们只需要找第 7 - 3 = 4小的数字就可以了,也就是 k = 4。此时两个数组,比较第 2 个数字,3 < 5,所以我们可以把小的那个数组中的 1 ,3 排除掉了。

力扣练习2:分治_第4张图片

我们又排除掉 2 个数字,所以现在找第 4 - 2 = 2 小的数字就可以了。此时比较两个数组中的第 k / 2 = 1 个数,4 == 4,怎么办呢?由于两个数相等,所以我们无论去掉哪个数组中的都行,因为去掉 1 个总会保留 1 个的,所以没有影响。为了统一,我们就假设 4>4 吧,所以此时将下边的 4 去掉。

力扣练习2:分治_第5张图片

由于又去掉 1 个数字,此时我们要找第 1 小的数字,所以只需判断两个数组中第一个数字哪个小就可以了,也就是 4。

所以第 7 小的数字是 4。

我们每次都是取 k/2 的数进行比较,有时候可能会遇到数组长度小于 k/2的时候。

力扣练习2:分治_第6张图片

此时 k / 2 等于 3,而上边的数组长度是 2,我们此时将箭头指向它的末尾就可以了。这样的话,由于 2 < 3,所以就会导致上边的数组 1,2 都被排除。造成下边的情况。

力扣练习2:分治_第7张图片

由于 2 个元素被排除,所以此时 k = 5,又由于上边的数组已经空了,我们只需要返回下边的数组的第 5 个数字就可以了。

从上边可以看到,无论是找第奇数个还是第偶数个数字,对我们的算法并没有影响,而且在算法进行中,k 的值都有可能从奇数变为偶数,最终都会变为 1,或者由于一个数组空了,直接返回结果。

所以我们采用递归的思路,为了防止数组长度小于 k/2,所以每次比较 min(k/2,len(数组)
对应的数字,把小的那个对应的数组的数字排除,将两个新数组进入递归,并且 k 要减去排除的数字的个数。递归出口就是当 k=1
或者其中一个数字长度是 0 了。

作者:windliang
链接:https://leetcode-cn.com/problems/median-of-two-sorted-arrays/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by-w-2/
来源:力扣(LeetCode)

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
    int n = nums1.length;
    int m = nums2.length;
    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) {
        int len1 = end1 - start1 + 1;
        int len2 = end2 - start2 + 1;
        //让 len1 的长度小于 len2,这样就能保证如果有数组空了,一定是 len1 
        if (len1 > len2) return getKth(nums2, start2, end2, nums1, start1, end1, k);
        if (len1 == 0) return nums2[start2 + k - 1];

        if (k == 1) return Math.min(nums1[start1], nums2[start2]);

        int i = start1 + Math.min(len1, k / 2) - 1;
        int j = start2 + Math.min(len2, k / 2) - 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));
        }
    }

}

你可能感兴趣的:(力扣练习2:分治)