【五种方法解决】找出数组中出现次数超过数组长度一半的数字

剑指offerJZ28:数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
这道题是在面试时常问的一道题，有多种解法，我们分别看一下；

方法一：利用map

利用map的key -value模型来存放arr[i]和相对应出现的次数，最后用次数去跟数组长度一半去比较，大于则就是；比如1,2,3,2,2,2,5,4,2；就是1出现一次、2出现5次、3.4.5各出现一次；返回的就是2；

public static int solution1(int[] arr){
        //利用map的key value模型来存放arr[i]和相对应出现的次数
        HashMap<Integer,Integer> map=new HashMap<>();
        for(int i=0;i<arr.length;i++){
            if(map.containsKey(arr[i])){
               map.put(arr[i],map.get(arr[i])+1);//已经存在就给value加1
            }
            else{
                map.put(arr[i],1);
            }
        }
        for(Map.Entry<Integer,Integer> entry:map.entrySet()){
            if(entry.getValue()>arr.length/2){
                return entry.getKey();
            }
        }
        return 0;
    }

方法二：排序求中间值

出现的次数超过长度一半，那给数组排序以后，它一定处在最中间的位置；比如1,2,3,2,2,2,5,4,2排完序是1,2,2,2,2,2,3,4,5,；接下来去统计数组中跟arr[mid]值一样的元素，相等count++;如果count的值大于mid，则说明存在输出，否则返回0；

 public static int solution2(int[] arr){
        //先对数组排序，如果这个数存在，那它一定在arr[mid]的位置，
        Arrays.sort(arr);
        int count=0;
        int mid=arr.length/2;
        for(int i=0;i<arr.length;i++){
            if(arr[i]==arr[mid]){
                count++;
            }
        }
        if(count>mid){//出现的次数超过mid，则返回它；
            return arr[mid];
        }
        return 0;
    }

方法三：抵消法

将target和其他元素进行抵消，由于target出现的次数大于别的元素，所以最后剩下的就是我们要找的；在遍历数组的时候保存两个值：数组中的一个元素(target) 和 该元素出现的次数(times)。当我们遍历到下一个元素的时候，如果下一个元素和我们之前保存的元素相等，则次数加1，如果下一个元素和我们之前保存的元素不相等，则次数减1。如果次数为零，我们需要保存下一个元素，并且把次数重设为1。由于目标元素出现的次数比其它所有元素出现的次数之和还要多，所以目标元素肯定是最后一次把次数设为1时对应的元素。
*

public static int solution3(int[] arr){
        //抵消法：将target和其他元素进行抵消，由于target出现的次数大于别的元素，所以最后剩下的就是我们要找的
        //1,4,5,7,2,4,5,4,6,4,5,4,4,4,4
        int target=arr[0];//target先设为arr[0];
        int times=1;
        for(int i=0;i<arr.length;i++){
            if(times==0){//重新设置
                target=arr[i];
                times=1;
            }
            else
            {
                if(arr[i]==target){
                    times++;
                } else {
                    times--;
                }
            }
        }
        return target;
    }

方法四：利用快排的思想

使用partition()方法获取基准元素的下标。若基准元素的下标为length/2，则基准元素是数组的中位数，即基准元素就是目标元素。若基准元素的下标大于length/2，则数组的中位数位于基准元素的左边。若基准元素的下标小于length/2，则数组的中位数位于基准元素的右边。

 public static int solution4(int[] arr){
        int low=0;
        int high=arr.length-1;
        int mid=(high-low)/2;
        int index=partition(arr,low,high);
        while(index!=arr.length/2){
            if(index<arr.length/2){
                low=index+1;
                index=partition(arr,low,high);
            }
            else{
                high=index-1;
                index=partition(arr,low,high);
            }
        }
        int num=arr[index];
        int times=0;
        for(int i=0;i<arr.length;i++){
            if(arr[i]==num){
                times++;
            }
        }
        if(times*2>arr.length){
            return num;
        }
        return 0;
    }
    public static int partition(int[] arr,int low,int high){
        int key=arr[low];
        while(low<high){
            while(low<high&&arr[high]>=key){
                high--;
            }
            int temp=arr[low];
            arr[low]=arr[high];
            arr[high]=temp;
            while(low<high&&arr[low]<=key){
                low++;
            }
            temp=arr[low];
            arr[low]=arr[high];
            arr[high]=temp;
        }
        return low;
    }

方法五：target-other>=1

和方法三思想基本一致，因为这个数字出现次数超过数组长度的一半，所以目标数字的个数 减去其他数字的个数总和 一定是大于等于1的，当我们遇到目标值时+1，否则-1，当count为0时重新设置目标值，最后记录的位置一定是目标数字

public  static int solution(int[] arr){
        int count=0;
        int aws=0;
        for(int i=0;i<arr.length;i++){
            if(count==0){
                aws=arr[i];
            }
            if(arr[i]==aws){
                count++;
            } else {
                count--;
            }
        }
        return aws;
    }