剑指offer39 数组中出现次数超过一半的数字

题目描述

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

解题思路一：时间复杂度O(n)，空间复杂度O(1)，不需要改变数组

采用阵地攻守的思想：

第一个数字作为第一个士兵，守阵地；count = 1；

遇到相同元素，count++;

遇到不相同元素，即为敌人，同归于尽,count--；当遇到count为0的情况，又以新的i值作为守阵地的士兵，继续下去，到最后还留在阵地上的士兵，有可能是主元素。

再加一次循环，记录这个士兵的个数看是否大于数组一般即可。

public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        if(array.length == 0)
            return 0;
        if(array.length == 1)
            return array[0];
        int ans = array[0];
        int ansCount = 1;
        for(int i=1;i<array.length;i++){
            if(array[i] == ans){
                ansCount++;
            }else{
                ansCount--;
                if(ansCount == 0){
                    ans = array[i];
                    ansCount = 1;
                }
            }
        }
        ansCount = 0;
        for(int i=0;i<array.length;i++){
            if(ans == array[i])
                ansCount++;
        }
        if(ansCount > array.length/2)
            return ans;
        else 
            return 0; 
    }
}

解题思路二：时间复杂度O(n)，空间复杂度O(1)，需要修改数组

采用修改快排的思想，数组中有一个数字出现的次数超过一半，如果把这个数组排序，那么排序之后位于数组中间的数字就是出现超过一半的数字。这个数字就是统计学上的中位数。

在快速排序中，我们选择一个枢轴pivot，然后进行一次partition，数组中比pivot小的数字都出现在pivot左边，比pivot大的数字都出现在pivot右边，如果选中的这个数字的下标恰好是n/2，那么则就是中位数，如果下标大于n/2，那么应该在左边部分的数组继续寻找，如果下标小于n/2，那么应该在右边部分的数组中继续寻找。

public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        if(array.length <= 0)
            return 0;
        if(array.length == 1)
            return array[0];
        int start = 0;
        int middle = array.length/2;
        int end = array.length;
        int index = partition(array, start, end);
        while(index != middle){
            if(index > middle){
                index = partition(array, start, index-1);
            }else{
                index = partition(array, index+1, end);
            }
        }
        int ans = array[index];
        int count = 0;
        for(int i = 0;i<array.length;i++){
            if(array[i] == ans)
                count++;
        }
        if(count > array.length/2)
            return ans;
        else
            return 0;
    }
    public int partition(int [] array, int start, int end){
        int pivot = array[start];
        int pos = start;
        for(int i=start+1;i<end;i++){
            if(array[i]<pivot){
                pos++;
                if(i != pos)
                    swap(array, pos, i);
            }
        }
        swap(array, pos, start);
        return pos;
    }
    public void swap(int []array, int i , int j){
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

上例中的partition方法是单指针扫描法，存在问题，即比pivot小的数字只交换一次，但比Pivot大的数会交换多次，改为双指针扫描法。

public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        if(array.length <= 0)
            return 0;
        if(array.length == 1)
            return array[0];
        int start = 0;
        int middle = array.length/2;
        int end = array.length-1;
        int index = partition(array, start, end);
        while(index != middle){
            if(index > middle){
                index = partition(array, start, index-1);
            }else{
                index = partition(array, index+1, end);
            }
        }
        int ans = array[index];
        int count = 0;
        for(int i = 0;i<array.length;i++){
            if(array[i] == ans)
                count++;
        }
        if(count > array.length/2)
            return ans;
        else
            return 0;
    }
    public int partition(int [] array, int start, int end){
        int pivot = array[start];
        int low = start;
        int high = end;
        while(low < high){
            while(low < high && array[high]>=pivot) high--;
            if(low < high) array[low++] = array[high];
            while(low < high && array[low]<pivot) low++;
            if(low < high) array[high--] = array[low];
        }
        array[low] = pivot;
        return low;
    }
}