剑指offer——数组种出现次数超过一半的数字

题目描述

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

解析：

一种很常规的思路是排序，排过序后，从首元素开始遍历数组，用一个整型变量times记录次数，一个整型变量记temp录正在判断的数字，如果遍历到的数字和正在判断的数字相同，times加1，否则，times就达到了前者出现的最大次数，判断它是否符合条件，如果符合，返回这个元素，如果不符合，就将times置1，temp置为当前遍历到的数字，直到遍历结束，但要注意数组长度为1和为0的特殊情况。当然这个方法不太好，因为时间复杂度为O（nlogn)，而本题是存在时间复杂度为O（n)的解法的。

import java.util.Arrays;
public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        if(array.length == 0 || array == null){
            return 0;
        }
        if(array.length == 1){
            return array[0];
        }
        //调用Arrays类的静态方法sort()来排序
        Arrays.sort(array);
        int start=0;
        int end=0;
        for(int i=1;i<array.length;i++){
            if(array[i]== array[start]){
                continue;
            }else{
                if(2*(i-start)>array.length){
                    return array[start];
                }
                start = i;
            }
        }
        return 0;
         
    }
}

另一种思路是这样的，如果存在一个数字，出现的次数超过一半，那么它和其他数字“做抵消”，以“一换一”的形式，那么最后剩下的一定是这个数字（因为它出现的次数比其余数字加起来还多），所以可以定义两个变量，一个变量times记录次数（但不是总次数），一个记录temp当前正在判断的数字，遍历数组，如果当前数字和正在判断的数字相等，times加一，否则times减一，如果times为0，则temp置为当前遍历到的数字，times置为1，直到遍历结束。

遍历结束后，并不知道temp是不是所要寻找的数字，但这时只有两种情况，一种是temp为所要寻找的数字，一种是不存在索要寻找的数字，这时候可以再遍历一遍数组，判断temp是否符合条件。

第一次用这种方法时，我试图在第一次遍历时设置一个变量maxTimes，记录正在判断的数字出现的最大次数，这样就不用第二次遍历了，但是发现失败了，因为数组无序，相同数字不挨着，maxTimes常常会被置0，无法达到目的。所以，第二次遍历应该还是必要的。

public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        if(array.length == 0 || array == null){
            return 0;
        }
        if(array.length == 1){
            return array[0];
        }
        int times = 1;
        int temp = array[0];
        for(int i=1;i<array.length;i++){
            if(temp == array[i]){
                times++;
            }
            if(temp != array[i]){
                times--;
                if(times == 0){
                    temp = array[i];
                    times =1;
                }
            }
        }
        if(check(array,temp)){
            return temp;
        }else{
            return 0;
        }
    }
    public boolean check(int[] array,int temp){
        int times=0;
        for(int i=0;i<array.length;i++){
            if(array[i] == temp){
                times++;
            }
        }
        if(times*2>array.length){
            return true;
        }else{
            return false;
        }
    }
}

第三种思路，利用Partation思想：一个数组中一个数字出现的次数超过一半，那么，这个数组的中位数一定是这个数字，所以应该找出该中位数，先在数组中随机选择一个数字，然后调整数组中数字的顺序，使得比选中的数字小的数字都排在它的左边，比选中数字的数字排在它的右边。如果这个选中的数字下标刚好是n/2，那么这个数字就是中位数，如果下标大于n/2，那么中位数位于它的左边，反之位于它的右边。这个思路复杂而且时间会改变原来数组中数字的顺序，不推荐。

import java.util.Random;
public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        if(array==null || array.length == 0){
            return 0;
        }
        if(array.length == 1){
            return array[0];
        }
        int mid = array.length/2;
        int index = partition(array,0,array.length-1);
        while(index != mid){
            if(index > mid){
                index = partition(array,0,index-1);
            }else{
                index = partition(array,index+1,array.length-1);
            }
        }
        return check(array,array[mid])?array[mid]:0;
    }
    public int partition(int[] array,int start,int end){
        int randInt = start+new Random().nextInt(end-start);
        int temp = array[randInt];
        int less = start-1;
        swap(array,randInt,end);
       for(int i=start;i<end;i++){
           if(array[i]<temp){
               swap(array,++less,i);
           }
       }
       swap(array,++less,end);
       return less;
    }
    public void swap(int[] array,int i,int j){
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
    public boolean check(int[] array,int temp){
        int times = 0;
        for(int i=0;i<array.length;i++){
            if(array[i] == temp){
                times++;
            }
        }
        return (2*times>array.length)?true:false;
    }
}