剑指offer面试题39：数组中出现次数超过一半的数字（Java 实现）

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

测试用例：

1. 功能测试：数组中存在或者不存在一个出现次数超过数组长度一半的数字。
2. 特殊测试：输入的数组为空；输入的数组只有一个数字。

方法一：时间复杂度为O（nlogn）

思路：直接把数组进行排序，然后再统计每一个数字在数组中出现的次数。

方法二：时间复杂度为O（n），需要修改输入的数组。

思路：利用快速排序中对数组进行快速划分的思想，构造一个划分函数，快速找到数组中第 n/2 大的数，也就是数组的中位数，根据数组的特点这个数就是要找的数。

假如选取的分区点为index，第一次进行划分后位于index前面的元素都比位于index的元素小，位于index后面的元素都比位于index的元素大。

然后再用 index 与 middle 作比较，如果 index > middle，说明最小的k个数都位于 middle 的前面，利用递归的思想对 middle 前面的元素再一次进行划分即可；如果index <= middle，说明 index 前面的最小数还不够k个，同样利用递归对 index 后面的元素再一次划分即可。

 public int MoreThanHalfNum_Solution(int[] array) {
        int length = array.length;
        if (array == null || length <= 0) return 0;

        int start = 0;
        int end = length-1;
        //index表示划分函数以index为下标的元素为分区点
        int index = partition(array, start, end);
        int middle = length>>1;

        while (index != middle){
            //表示k个最小元素一定在index左边，需要对index的左边再一次划分
            if (index > middle){
                end = index-1;
                index = partition(array, start, end);
            }
            //表示index左边不够k个最小元素，需要对index的右边再一次划分
            else {
                start = index+1;
                index = partition(array, start, end);
            }
        }
       int result = array[middle];

        int times = 0;
        //这个循环是用来判断当前保存的元素在数组中出现的次数
        //以便比较它出现的次数是否超过数组长度的一半
        for (int i=0; i<length; i++){
            if (result == array[i]){
                times++;
            }
        }
        if (times*2 <= length){
            result = 0;
        }
        return result;
    }
    //构造划分函数（利用快排的思想对数组进行排序）
    private int partition(int[] nums, int start, int end) {
        int pivot = nums[start];  //选取数组的第一个元素作为分区点

        while (start < end){     //当区间缩小为1，说明数组已经排好序
            while (start < end && pivot <= nums[end]){  //比分区点元素值大的不用交换
                end--;
            }
            swap(nums, start, end);    //交换比分区点元素值大的元素到分区点前面

            while (start < end && pivot >= nums[start]){  //比分区点小的不用交换
                start++;
            }
            swap(nums, start, end);    //交换比分区点值大的元素到分区点后面
        }
        return start;
    }
    //交换函数
    private void swap(int[] nums, int start, int end) {
        int temp = nums[start];
        nums[start] = nums[end];
        nums[end] = temp;
    }

方法三：利用数组的特点，时间复杂度为O（n），不用修改数组。

思路：

如果有符合条件的数字，则它出现的次数比其他所有数字出现的次数和还要多。
在遍历数组时保存两个值：一是数组中一个数字，一是次数。遍历下一个数字时，若它与之前保存的数字相同，则次数加1，否则次数减1；若次数为0，则保存下一个数字，并将次数置为1。遍历结束后，所保存的数字即为所求。然后再判断它是否符合条件即可。

 public int MoreThanHalfNum_Solution(int[] array){
        int length = array.length;
        if (array == null || length <= 0)return 0;

        int times = 1;
        int result = array[0];   //首先保存数组的第一个元素

        for (int i=1; i<length; i++){    //从第二个元素开始遍历
            if (times == 0){       //如果次数减到为0
                result = array[i]; //保存下一个数组元素
                times = 1;         //然后重新设置次数为一

            } else {
                //后面每一个遍历到的元素与当前保存的元素相等，次数加一
                if (array[i] == result) {
                    times++;

                } else {      //若不相等则次数减一
                    times--;
                }
            }
        }
        times = 0;
        //这个循环是用来判断当前保存的元素在数组中出现的次数
        //以便比较它出现的次数是否超过数组长度的一半
        for (int i=0; i<length; i++){
            if (result == array[i]){
                times++;
            }
        }
        if (times*2 <= length){
            result = 0;
        }
        return result;
    }
}