剑指offer面试题39(java版):数组中出现次数超过一半的数字

welcome to my blog

剑指offer面试题39(java版):数组中出现次数超过一半的数字

题目描述

数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。

第四次做; 位运算的思想: 如果一个数字的出现次数超过了数组长度的一半, 那么这个数字二进制的各个bit的出现次数同样超过了数组长度的一半

class Solution {
    public int majorityElement(int[] nums) {
        int[] bit = new int[32];
        int n = nums.length;
        for(int a : nums){
            for(int i=0; i<32; i++){
                //无符号右移; 负数的无符号右移移动的是补码还是原码?
                if(((a>>>i) & 1) == 1)
                    bit[i]++;
            }
        }
        
        int res=0;
        for(int i=0; i<32; i++){
            if(bit[i]>n/2)
                res = res | (1<<i);
        }
        return res;
    }
}

第四次做; 分治思想; 本题中使用分治的方法得到的不是众数, 那得到的是什么? 这么说吧, 如果某个元素出现的次数超过了长度的一半, 那么使用分治的思想一定可以得到这个数; 反例: {2,2,3,3,2,2,5,5}, 使用下面的算法返回的是5; 虽然众数是2, 但是2的出现次数没有大于数组长度的一半,所以算法失效了

/*
分治算法; 归并排序就属于分治算法
本题中使用分治的方法得到的不是众数, 那得到的是什么?
这么说吧, 如果某个元素出现的次数超过了长度的一半, 那么使用分治的思想一定可以得到这个数
再次强调: 某个元素出现的次数超过了长度的一半, 该算法才有效

反例:
{2,2,3,3,2,2,5,5}, 使用下面的算法返回的是5; 虽然众数是2, 但是2的出现次数没有大于数组长度的一半,所以算法失效了
*/
class Solution {
    public int majorityElement(int[] nums) {
        return core(nums, 0, nums.length-1);
    }
    private int core(int[] nums, int left, int right){
        //base case
        if(left==right)
            return nums[left];
        //
        int mid = left + ((right-left)>>1);
        int leftRes = core(nums, left, mid);
        int rightRes = core(nums, mid+1, right);
        if(leftRes == rightRes)
            return leftRes;
        int leftCount = count(nums, left, mid, leftRes);
        int rightCount = count(nums, mid+1, right, rightRes);
        return leftCount>rightCount? leftRes:rightRes;
    }
    private int count(int[] arr, int left, int right, int target){
        int count = 0;
        for(int i=left; i<=right; i++){
            if(arr[i] == target)
                count++;
        }
        return count;
    }
}

思路1

• 出发点:数组中出现次数超过数组长度一半的元素, 出现的次数比其他元素加起来都多(这是个充分必要条件)
• 充要条件没法直接用
• 可以做到扫描一遍数组找到出现次数最多的元素。出现次数最多是必要不充分条件。

笔记

• 掌握基础：扫描一遍数组找到出现次数最多的元素

第三次做,核心:分解问题 ? ; 原问题:找出出现的次数超过数组长度的一半的元素; 分解为两个问题:1)找出出现次数最多的元素;2)检查这个元素的出现次数是否超过数组长度的一半

• 代码中的for循环找出的元素有可能是出现次数超过数组长度的一半的元素, 也有可能是出现次数最多的元素, 还有可能是最后一个元素, 例子1,2,2,3,4,5 找出的是5

/*
核心:分解问题
原问题:找出出现的次数超过数组长度的一半的元素
分解为两个问题:1)找出出现次数最多的元素;2)检查这个元素的出现次数是否超过数组长度的一半
*/
public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        if(array==null || array.length==0)
            return 0;
        if(array.length==1)
            return array[0];
        //1)找出出现次数最多的元素
        // 这个方法并不能一定找出出现次数最多的元素, 找出的元素有可能是出现次数超过一半的元素, 需要验证
        int curr=array[0], count=1;
        for(int i=1; i<array.length; i++){
            if(array[i] != curr){
                count--;
                if(count==0){
                    curr=array[i];
                    count=1;
                }
            }
            else
                count++;
        }
        //2)检查这个元素的出现次数是否超过数组长度的一半
        count=0;
        for(int i=0; i<array.length; i++){
            if(array[i]==curr)
                count++;
        }
        return count > array.length/2 ? curr : 0;
    }
}

第二遍做(我写的是错的, 我只进行了一次partition, 正确的做法是对数组完整的排序)，使用的必要条件：满足要求的元素中一定有一个元素位于数组中间

• 为什么这个代码是错的呢? 例如2,2,1,2,3. 如果划分值是3, 那么partition之后的结果是2,2,1,2,3. 中间的元素不是出现次数最多的元素!
• 数组中间的元素索引为(N-1)/2. N为奇数时正好指向中间元素，N为偶数时指向中间两个元素中靠左的那个元素

public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        /*
        之前写的方案是使用了必要条件之一: 满足要求的元素是数组中出现次数最多的元素
        现在用一用另一个必要条件：满足要求的元素一定出现在arr[N/2]处, 配合partition使用
        */
        if(array==null || array.length < 1 )
            return 0;
        //
        partition(array, 0, array.length-1);
        int curr = array[(array.length-1)/2], count = 0;
        for(int i=0; i<array.length; i++){
            if(array[i] == curr)
                count++;
        }
        return count > array.length/2 ? curr : 0;
    }
    public void partition(int[] arr, int left, int right){
        int random = (int)(Math.random()*(right-left+1)+left);
        swap(arr,random, right);
        int small=left-1;//小于区
        int big=right;//大于区
        while(left<big){
            if(arr[left] < arr[right])
                swap(arr, left++, ++small);
            else if(arr[left] > arr[right])
                swap(arr, left, --big);
            else
                left++;
        }
        swap(arr, big, right);//将划分值放到大于区的边界
        //return new int[]{small+1, big};//没用到快排，不用返回等于区边界
    }
    public void swap(int[] arr, int i, int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

第二遍做，使用的必要条件：满足要求的元素一定是数组中出现次数最多的元素

public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        if(array==null || array.length<1)
            return 0;
        int curr=array[0], count=1;
        for(int i=1; i<array.length; i++){
            if(array[i] == curr)
                count++;
            else{
                count--;
                if(count==0){
                    curr = array[i];
                    count = 1; //第一次忘记更新次数。 更新curr必须更新count
                }
            }
        }
        //count>0,说明对应的curr是数组中出现次数最多的元素，需要进一步检查是否满足出现次数大于数组长度一半的条件
        if(count>0){
            count=0;//记录出现次数最多的元素的出现次数
            for(int i=0; i<array.length;i++)
                if(array[i]==curr)
                    count++;
        }
        return count > array.length/2 ? curr : 0;
    }
}

public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        //input check
        if(array.length<1)
            return 0;
        //execute
        /*
        出发点:数组中出现次数超过数组长度一半的元素, 出现的次数比其他元素加起来都多(实际上这只是必要条件,并不是充分条件! 反例见下面的分析), 所以可以这样做
        用curr记录当前的元素, count表示当前元素出现的次数.
        如果下一个元素和curr相等, 则count++
        如果下一个元素和curr不等,则count--
            如果count==0, 那么令curr等于下一个元素, count=1
        循环结束后,如果,count>0, 那么curr就是结果. 不对. 因为如果
        (有没有可能, count>0, curr不是正确的结果? 这就需要证明最开始的出发点是不是正确的. 看起来出发点不够完备, 反例:[1,2,3,2,4,2,5,2,3])
        */
        int curr = array[0];
        int count = 1;
        for(int i=1; i<array.length; i++){
            if(array[i] == curr)
                count++;
            else{
                count--;
                if(count==0){
                    curr = array[i];
                    count = 1;
                }
            }
        }
        //check result 检查curr是不是出现次数超过数组长度的一半
        count = 0;
        for(int i=0; i<array.length; i++){
            if(array[i]==curr)
                count++;
        }
        if(count > array.length/2)
            return curr;
        return 0;
    }
}

笔记

• 务必掌握快速排序, 由其弄清楚partition的写法, 比如处理输入长度为1的数组{6}

思路2 快速排序的partition

• 出发点:对于出现次数超过数组长度一半的元素,对该数组进行排序,排序后索引为N/2的元素就是结果
• 上面的出发点仍然是个必要条件.
• 可以想象一个长度大于N/2的滑窗在数组中滑动,无论怎么滑动都会包含索引为N/2的元素. 如果相同的元素挨在一起,也就是对元素进行排序的话,出现次数超过N/2的元素组成的滑窗中一定包含索引为N/2的元素
• 相当于找一组数中的中位数,可以采用快速排序中的partition想法

public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        //input check
        if(array.length < 1)
            return 0;
        //execute
        int index = partition(array, 0, array.length-1);
        while(true){
            if(index ==  array.length/2)
                break;
            else if(index < array.length/2)
                index = partition(array, index+1, array.length-1);
            else
                index = partition(array, 0, index-1);
        }
        int curr = array[index];
        int count = 0;
        for(int i=0; i<array.length; i++)
            if(array[i]==curr)
                count++;
        if(count > array.length/2)
            return curr;
        return 0;
    }
    public int partition(int[] array, int lo, int hi){
        int pivot = array[lo];
        int i=lo, j=hi+1;
        while(true){
            while(++i < array.length && array[i] < pivot)
                if(i==hi)
                    break;
            while(--j >= 0 && array[j] >= pivot) //这里一定要用>=,不能只用>
                if(j==lo)
                    break;
            if(i>=j)
                break;
            swap(array, i, j);
        }
        swap(array, lo, j);
        return j;
    }
    public void swap(int[] array, int i, int j){
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

稍微简洁些

• index就是第K个数字, 所以index等于K-1时即可

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        // 基于partition的方法
        //input check
        ArrayList<Integer> al = new ArrayList<Integer>();
        if(input.length < k || k<=0)
            return al;
        //execute
        int index = partition(input, 0, input.length-1);
        while(index != k-1){
            if(index > k-1)
                index = partition(input, 0, index-1);
            if(index < k-1)
                index = partition(input, index+1, input.length-1);
        }
        for(int i=0; i<=index; i++)
            al.add(input[i]);
        return al;
    }
    public int partition(int[] input, int lo, int hi){
        //注意input只有一个元素的情况, 此时要注意数组索引是否越界
        int i=lo, j=hi+1, pivot=input[lo];
        while(true){
            while(++i < input.length && input[i] < pivot)
                if(i==hi)
                    break;
            while(--j >= 0 && input[j] >= pivot)
                if(j==lo)
                    break;
            if(i>=j)
                break;
            swap(input, i, j);
        }
        swap(input, lo, j);
        return j;
    }
    public void swap(int[] input, int i, int j){
        int temp = input[i];
        input[i] = input[j];
        input[j] = temp;
    }
}