28 数组中出现次数超过一半的数字

//数组中出现次数超过一半的数字
//数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。
    由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
//
//常规思路1：先对这个数组进行排序，排序的时间复杂度为O(nlogn),然后进行遍历，进行查找。不建议使用这种方法；


//常规思路2：基于Partition函数的O(n)的算法
//如果对这个数组进行排序，那么排序之后位于数组中间的数字一定是那个出现次数超过数组长度一半的数字。
    即这个数字就是统计学中的中位数。即长度为n的数组中第n/2大的数字。
//利用成熟的O(n)算法得到数组中任意第K大的数字--利用的快排思想
//快排思想：先在数组中随机选择一个数字，然后调整数组中数字的顺序，使得比选中的数字小数字都排在它前边，比选中数字大的数字都排在它后面。
//例如：如果这个选中的数字下标刚好是n/2，那么该数字就是数组中位数；如果它的下标大于n/2，
     那么中位数应该位于它的左边，我们可以继续在它的左边中进行查找。如果他的下标小于n/2，
     那么中位数应该在它的右边，接着在右边进行查找。
int Partition(int data[], int length, int start, int end)
{
    if(data == NULL || length<=0 || start <= 0 || end <= 0)
    {
        return 0;
    }
    int index = RangdomInRange(start, end);
    int pv = data[index];//选择最后一个结点为枢轴
    Swap(&data[index], &data[start]);
    while(start < end)
    {
        if ((start < end) && (data[end]> pv))//先从右边开始
        {
            end--;
        }
        Swap(&array[index], &array[end]);
        if ((start < end) && (data[start])< pv)
        {
            start++;
        }
        Swap(&array[index], &array[start]);
    }
    return start;
}
void QuickSort(int data[], int length, int start, int end)
{
    if (start == end)
    {
        return ;
    }
    int pivot = Partition(data, length, start, end);
    QuickSort(data, length, start ,pivot-1);
    QuickSort(data, length, pivot+1, end);
}

//---------------------解答题---------------
class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) 
    {
        if (numbers.size() <= 0)
        {
            return 0;
        }
        //利用快排思想解决问题
        int length = numbers.size()-1;
        int middle = length>>1;
        int start  = 0;
        int end    = length -1;
        int index = Partition(numbers, length, start, end);//上述快排参数类型是数组，此处是vector类型
        while(index != middle)
        {
            if (index > middle)
            {
                end = index - 1;
                index = Partition(numbers, length, start, end);
            }
            else
            {
                start = index +1;
                index = Partition(numbers, length, start, end);
            }
        }
        int result = numbers[middle];
        int times = 0;//计算累计次数
        for (int i = 0; i < length; ++i)
        {
            if (numbers[i] == result)
            {
                times++;
            }

        }
        if (times * 2 <= length)
        {
            return 0;
        }
        return result;
    }
};

//思路2：根据数组特点找出O(N)的算法。
//遍历数组的时候，保存2个值---一个是数组中的数字，一个是次数。当我们遍历到下一个数字的时候，
    如果下一个数字和我们之前保存的数字相同，则次数加一；如果下一个数字和我们之前保存的数字不同，
    则次数减1.如果次数为0，我们需要保存下一个数字，并将次数设为1；
class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) 
    {
        int length = numbers.size();
        if (length <= 0)
        {
            return 0;
        }
        int times = 1;
        int result = numbers[0];
        for (int i = 1; i <= length-1; ++i)
        {
            if (0 == times)
            {
                result = numbers[i];//将次数多且累计次数的，存放起来，若最后次数还大于1，则就是要找的数字是最后将次数设置为1对应的数字
                //eg:1 3 1 1 9
                //最后一次将次数设置为1的是第三个数字1.
                times = 1;
            }
            if (result == numbers[i])
            {
                times++;
            }
            else
                times--;
        }
        
        //还要判断输入的数字是否满足条件eg:[1,2,3,2,4,2,5,2,3]
        int counts = 0;//计算累计次数
        for (int i = 0; i < length; ++i)
        {
            if (numbers[i] == result)
            {
                counts++;
            }

        }
        if (counts * 2 <= length)
        {
            return 0;
        }
        return result;
    }
};