找出数组中出现次数超过一半的数

算法--找出数组中出现次数超过一半的数
     每当我看到经典的算法题，就怀念高中，感觉很多算法题就是高中的题目，谁叫哥只读了个专科，高数基本相当没学。
     有空要看看高数啊，想当年数学那是相当的......

#include <iostream>
using namespace std;
class FindTheOne
{
public:
  方法一
  第一个想到的方法是见一个二维数组，一维存数组中的数据，二维存这个数出现的次数。出现次数最多的那个数就是要找的那个数
  由于某个数出现的次数超过数组长度的一半，所以二维数组的长度只需要这个数组的一半。代码实现如下，
  当然这个方法很糟糕，时间复杂度和空间复杂度都比较大，想练手的我还是写了一下。

　　

方法一

void  Search( int  A[], int  len, int &  theOne)
{
if (NULL == A  ||  len <= 0 )
{
return  ;
}

int  ( * B)[ 2 ] = new int [len / 2 ][ 2 ];
B[ 0 ][ 0 ] = A[ 0 ];
B[ 0 ][ 1 ] = 1 ;

int  t = 0 ;
bool  notExist = true ;
for ( int  i = 1 ;i < len; ++ i)
{
for ( int  j = 0 ;j < t; ++ j)
{
if (A[i] == B[j][ 0 ])
{
B[j][ 1 ] ++ ;
notExist = false ;
break ;
}
}
if (notExist)
{
B[t ++ ][ 0 ] = A[i];
}
}

int  max = 1 ;
int  k = 0 ;
for ( int  i = 0 ;i < len / 2 ; ++ i)
{
if (B[i][ 1 ] > max)
{
max = B[i][ 1 ];
k = i;
}
}

theOne = B[k][ 0 ];
}

方法二
     将数组排序，最中间的那个数就是您要找的数。
     如果出现最多的那个数是最小的，那么1至(n+1)/2都是那个数
     如果出现最多的那个数是最大的，那么(n-1)/2至n都是那个数
     如果不是最小也不是最大，当这个数由最小慢慢变成最大的最大的数时，你会发现中间的那个数的值是不变的。
     综上所述，中间的那个数就是你要找的那个数。
     时间复杂度就是你排序用的时间。排序真的不想写了（可以参考《我的另一篇博客》）。大家都知道排序还是相当费时的，当然这个方法还是不太好。

 方法三
     这个方法借用了别人的思路。
     在这里我做一下简单的分析。
     这个算法的时间复杂度是O(n)，另外用了两个辅助变量。
     k用于临时存储数组中的数据，j用于存储某个数出现的次数。
     开始时k存储数组中的第一个数,j为0，如果数组出现的数于k相等，则j加1，否则就减1，如果j为0，就把当前数组中的数赋给k
     因为指定的数出现的次数大于数组长度的一半，所有j++与j--相抵消之后，最后j的值是大于等于1的，k中存的那个数就是出现最多的那个数。

    下面这个算法只适合数组中数组中某个数的出现次数超过数组长度一半的数组，符合题意。

方法三

int  Search( int  A[], int  len)
{
if (NULL == A  ||  len <= 0 )
{
return - 1 ;
}

int  k, j = 0 ;
for ( int  i = 0 ;i < len; ++ i)
{
if (j == 0 )
{
k = A[i];
}
if (k == A[i])
{
++ j; // 有人说++j比j++有先天的优势，不知你是否听说，如果你也听说，有没有想过More Effective C++(C++程序员必看书籍)
} else
{
-- j;
}
}

return  k;
}

};

另外一种：

题目：数组中有一个数字出现的次数超过了数组长度的一半，找出这个数字。  

分析：

     1.首先我们想到如果是一个排序好的数组，那么我们只需要遍历一次数组，统计好每个数字出现的次数，如果大于数组长度的一半就输出这个数字。或者只需要直接输出array[N/2]的值即可。 

     2.如果是杂乱无章的数据我们可能回想先排序，然后按1操作即可。但是排序的最小时间复杂度（快速排序）O（N*logN） , 加上遍历，时间复杂度为: O（N*logN+N） ,如果选择直接输出array[N/2]的值的话，时间复杂度缩小为O（N*logN） 。

     3.如果说数字只有0-9的话可以考虑设计一个Hash table，遍历一次就能知道每个数字出现的次数。但是数字范围不知，所以Hash表不好创建。

     4.出现的次数超过数组长度的一半，表明这个数字出现的次数比其他数字出现的次数的总和还多。所以我们可以考虑每次删除两个不同的数，那么在剩下的数中，出现的次数仍然超过总数的一半。通过不断重复这个过程，不断排除掉其它的数，最终找到那个出现次数超过一半的数字。这个方法，免去了上述思路一、二的排序，也避免了思路三空间O（N）的开销，总得说来，时间复杂度只有O（N），空间复杂度为O（1），不失为最佳方法。

     例：数组 a[5]={0,1,2,1,1};

                 我们要查找的数字为1，操作步骤为：遍历整个数组，然后每次删除不同的两个数字，过程如下：

               0 1 2 1 1 =>2 1 1=>1

具体实现：我们在考虑删除两个不同的数字的时候，实际上可以同过计数来实现，而不是物理上真正的删除。 在遍历数组的时候保存两个值：一个是数组中的一个数字，一个是次数。当我们遍历到下一个数字的时候，如果下一个数字和我们之前保存的数字相同，则次数加1。如果下一个数字和我们之前保存的数字不同，则次数减1。如果次数为零，我们需要保存下一个数字，并把次数设为1。由于我们要找的数字出现的次数比其他所有数字出现的次数之和还要多，那么要找的数字肯定是最后一次把次数设为1时对应的数字。

基于这个思路，我们不难写出如下代码：

bool g_bInputInvalid = false;
//
// Input: an array with "length" numbers. A number in the array
// appear more than "length / 2 + 1" times.
// Output: If the input is valid, return the number appearing more than
// "length / 2 + 1" times. Otherwise, return 0 and set flag g_bInputInvalid
// to be true.
//
int MoreThanHalfNum(int* numbers, unsigned int length)
{
    if(numbers == NULL && length == 0)
    {
        g_bInputInvalid = true;
        return 0;
    }
 
    g_bInputInvalid = false;
 
    int result = numbers[0];
    int times = 1;
    for(int i = 1; i < length; ++i)
    {
        if(times == 0)
        {
            result = numbers[i];
            times = 1;
        }
        else if(numbers[i] == result)
            times++;
        else
            times--;
    }
 
    // verify whether the input is valid
    times = 0;
    for(int i = 0; i < length; ++i)
    {
        if(numbers[i] == result)
            times++;
    }
 
    if(times * 2 <= length)
    {
        g_bInputInvalid = true;
        result = 0;
    }
 
    return result;
}
 

       在上述代码中，有两点值得讨论：

（1）      我们需要考虑当输入的数组或者长度无效时，如何告诉函数的调用者输入无效。关于处理无效输入的几种常用方法，在本博客系列的第17题中有详细的讨论；

（2）      本算法的前提是输入的数组中的确包含一个出现次数超过数组长度一半的数字。如果数组中并不包含这么一个数字，那么输入也是无效的。因此在函数结束前我还加了一段代码来验证输入是不是有效的。

---

另外一种思路：

分析：

如果一个数字才数组中出现的次数超过了数组长度的一半，那么对这个数组进行排序，位于数组中间位置的那个数就是出现次数超过一半的那个数。对数组排序的时间复杂度是O(nlog(n))，但是对于这道题目，还有更好的算法，能够在时间复杂度O(n)内求出。我们写过快速排序算法，其中的Partition()方法是一个最重要的方法，该方法返回一个index，能够保证index位置的数是已排序完成的，在index左边的数都比index所在的数小，在index右边的数都比index所在的数大。那么本题就可以利用这样的思路来解。

1. 通过Partition()返回index，如果index==mid，那么就表明找到了数组的中位数；如果index<mid，表明中位数在[index+1,end]之间；如果index>mid，表明中位数在[start,index-1]之间。知道最后求得index==mid循环结束。
2. 根据求得的index，遍历一遍数组，每当出现一个等于index所指向的数时time++，最后判断time是否大于数组长度的一半，如果大于则表明index所指向的数就是所求的数，如果不是，则表明不存在一个数出现的次数超过数组长度的一半。

代码实例：

View Code

#include<iostream> #include<stdlib.h> using namespace std;  //函数声明 int MoreThanHalf(int arry[],int start,int end,int len);//函数入口 int Partition(int arry[],int start,int end);//返回一个index，使index左边的数都比index所在的数小，index右边的数都比index所在数大 bool CheckMoreThanHalf(int arry[],int len,int result);//判断一个数在数组中是否有超过一半  int Partition(int arry[],int start,int end) {     int pivotkey=arry[start];     while(start<end)     {         while(start<end&&arry[end]>=pivotkey)             end--;         arry[start]=arry[end];         while(start<end&&arry[start]<=pivotkey)             start++;         arry[end]=arry[start];     }     arry[start]=pivotkey;     return start; }  bool CheckMoreThanHalf(int arry[],int len,int result) {     int time=0;     for(int i=0;i<len;i++)     {         if(arry[i]==result)             ++time;     }      bool isMoreThanHalf=true;     if(time*2<=len)         isMoreThanHalf=false;     return isMoreThanHalf; }  int MoreThanHalf(int arry[],int start,int end,int len) {     if(arry==NULL&&len<=0)         return -1;      int index=Partition(arry,start,end);     int middle=len/2;//中间位置     while(index!=middle)     {         if(index>middle)//如果调整数组以后获得的index大于middle，则继续调整start到index-1区段的数组             index=Partition(arry,start,index-1);         else//否则调整index+1到end区段的数组             index=Partition(arry,index+1,end);     }     //最后获取的index=middle，此时在middle左边的数小于arry[middle]，在其右边的数大于arry[middle]     int result=arry[middle];     if(!CheckMoreThanHalf(arry,len,result))         return -1;      return arry[middle]; }  void main() {     //int arry[]={5,1,7,3,0,2,8};//定义数组     int arry[]={2,2,1,1,3};//定义数组     int len=sizeof(arry)/sizeof(int);//求数组长度      int half=MoreThanHalf(arry,0,len-1,len);     cout<<half<<endl;      system("pause"); }