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

题目描述

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

      需要找的数字超过数组长度的一半，那么如果对它进行排序，再取数姐中间那个数字即为所求，但是这种做法的时间复杂度最少为O(NlogN)，如果需要要控制到O(n),可以采用下面三种方式。

       我们使用两个变量分别保存数组中的一个数字以及次数（不是出错的总次数哟！）。然后遍历数组，发现如果遍历的数字跟我们保存的数字一样，则次数加1，否则减1；如果次数为0，则保存此刻遍历的数字，次数记为1.原理是什么呢？这相当于同时删掉两个不同的数，因为我们要找的数的个数大于数组长度，所以如果按这种方法计算的话，剩下的即为我们要找的。但是我们也要考虑到非法输入的情况，假如我们传入的容器值为0，或者我们输入的数字序列没有次数超过数组长度一半的怎么办？这时，我们就需要设置一个非法输入判定函数。

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        if(!numbers.size())
            return 0;
        int counts = 1;
        int  result = numbers[0];
        for(vector<int>::size_type i = 1; i < numbers.size(); i ++){
            if(counts == 0){
                result = numbers[i];
                counts ++;
            }else if(result == numbers[i])
                counts ++;
                else{
                counts --;
            }             
        }
        if(!CheckMoreThanHalf(numbers,result))
            result = 0;
        return result;       
    }
    
    bool CheckMoreThanHalf(vector<int> numbers, int find){
        int len = numbers.size();
        int count = 0;
        for(vector<int>::size_type i = 0; i < len; i ++){
            if(numbers[i] == find)
                count ++;
        }
        if(count * 2 <= len)
            return false;
        return true;
    }
};

      另外一种方法是，是使用C++的map容器，健为数组元素，它的健值为该数字出现的次数。如果出现次数大于长度的一半，即我们需要找的值，如果遍历完，仍然没有出现长度大于一半的值，则返回0；这种方法，可以不用写非法输入的判定式了！很奇怪，我觉得map很好用呀，为什么那么多解析书上都会用哈希表，我觉得还要设置一个数组麻烦多了。是不是内存的原因？待解。

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        
        map<int, int> temp;
        int len = numbers.size();
        if(len == 1)
            return 1;
        else if(len == 0)
            return 0;
            
        for(vector<int>::size_type i = 0; i < len; i ++){
            temp[numbers[i]] ++;
            if(temp[numbers[i]] > (len / 2))
                return numbers[i];
               
        }
        return 0;              
    }};

      第三种方法是借用于快排的思想，快排里面可以使用partition函数来划分值，把小于分界线的放在右边，大于分界值的放在左边，我们可以找到数组中值的Partition序列，然后取中值 即为所求。

class Solution2 {
public:
	int MoreThanHalfNum_Solution(vector<int> numbers) {
		int len = numbers.size();
		int mid = (len / 2);
		int start = 0;
		int end = len -1;
		int index;
		index = Partition(numbers, 0, numbers.size() -1);
		while(index != mid){
			if(index > mid){
				end = index -1;
				index = Partition(numbers, start, index -1);
			}
			else{
				start = index +1;
				index = Partition(numbers, index +1, end);

			}
		}
		if(!CheckMoreThanHalf(numbers, numbers[mid]))
			return 0;
		return numbers[mid];  

	}

	int Partition(vector<int> &numbers, int start, int end){
		if(start == end)
			return start;
		int len = numbers.size();
		if ((len == 0) || start < 0 || end > len)
		{
			throw new std::exception("invalid parameters");
		}
		//随机选择一个数
		int index = (rand()%(end - start)) + start;
		swap(numbers[index], numbers[end]);
		int small = start -1;
		for(int i = start; i < end; i ++){
			if(numbers[i] < numbers[end]){
				small ++;
				if(small != i)
					swap1(numbers[small], numbers[i]);                    
			}                
		}
		small ++;
		swap1(numbers[small], numbers[end]);
		return small;        
	}

	void swap1(int& a, int& b){
		int temp = a;
		a = b;
		b = temp;        
	}

	bool CheckMoreThanHalf(vector<int> numbers, int find){
		int len = numbers.size();
		int count = 0;
		for(vector<int>::size_type i = 0; i < len; i ++){
			if(numbers[i] == find)
				count ++;
		}
		if(count * 2 <= len)
			return false;
		return true;
	}
};