剑指Offer29：数组中出现次数超过一半的数字问题

数组中出现次数超过一半的数字问题

问题描述

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

问题分析：

 *      如果数组是一个排序数组，那么很容易找出出现次数超过一半的数字（位于数组中间位置的数字），但是对数组排序的时间复杂度为o（nlogn），因此并不是最优的解法。
 *      思路一：
 *      基于Partition函数的时间复杂度为o（n）的解法：
 *          在随机快速排序算法中，我们先在数组中随机选择一个数字，然后调整数组中数字的顺序，使得比选中数的数字小的数字都排在它的左边，比选中数字
 *          大的数字都排在它的右边。如果这个选中数字的下标刚好是n/2，那么这个数字就是数组的中位数。如果它的下标大于n/2，那么中位数应该位于它的左边，我们
 *          可以直接在它的左边额部分数组中查找。如果它的下标小于n/2，那么中位数位于它的右边。这是一个典型的递归过程。

public class Code029 {
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        String[] inLine=sc.nextLine().split(",");
        int len=inLine.length;
        int[] data=new int[len];
        for(int i=0;i<len;i++){
            data[i]=Integer.parseInt(inLine[i]);
        }
//        System.out.print(MoreThanHalfNum(data,len));
        System.out.print(CountAppearTimes(data,len));
    }
    //思路一解法极为复杂；
    private static int MoreThanHalfNum(int[] data,int length){
        if(CheckInvalidArray(data,length)){
            return 0;
        }
        int middle=length>>1;
        int start=0;
        int end=length-1;
        int index=Partition(data,length,start,end);
        while (index!=middle){
            if(index>middle){
                end=index-1;
                index=Partition(data,length,start,end);
            }else {
                start=index+1;
                index=Partition(data,length,start,end);
            }
        }
        int result=data[middle];
        if(!CheckMoreThanHalf(data,length,result)){
            result=0;
        }
        return result;
    }
    static boolean InputInvalid=false;
    //判断输入数组是否合法
    private static boolean CheckInvalidArray(int[] data, int length) {
        InputInvalid=false;
        if(data==null ||length<=0){
            InputInvalid=true;
        }
        return InputInvalid;
    }
    private static boolean CheckMoreThanHalf(int[] data, int length, int number) {
        int times=0;
        for(int i=0;i<length;i++){
            if(data[i]==number){
                times++;
            }
        }
        boolean isMoreThanHalf=true;
        if(times*2<=length){
            InputInvalid=true;
            isMoreThanHalf=false;
        }
        return isMoreThanHalf;
    }

    private static int Partition(int[] data, int length, int start, int end) {
        if(data==null || length<=0 ||end>=length ||start<0){
            return 0;
        }
        //java在某区间产生随机数的方式
        Random rand=new Random();
        int index=rand.nextInt(end-start+1)+start;
        Swap(data[index],data[end]);
        int small=start-1;
        for(index=start;index<end;index++){
            if(data[index]<data[end]){
                small++;
                if(small!=index){
                    Swap(data[index],data[small]);
                }
            }
        }
        small++;
        Swap(data[small],data[end]);
        return small;
    }

    private static void Swap(int datum, int datum1) {
        int temp=datum;
        datum=datum1;
        datum1=temp;
    }
    //思路二：采用一个hashmap来存储每一个数字出现的次数
    private static int CountAppearTimes(int[] data, int length){
        int result=0;
        if(data==null || length<=0){
            return 0;
        }
        HashMap<Integer,Integer> map=new HashMap<>();
        for(int i=0;i<length;i++){
            if(map.containsKey(data[i])){
                int value=map.get(data[i]);
                value+=1;
                map.put(data[i],value);
            }else {
                map.put(data[i],1);
            }
        }
        for(int i:map.keySet()){
            if(map.get(i)>length/2){
                result=i;
            }
        }
        return result;
    }
}