他是通过这一个for (m=0, j=i+1;j<14;j++) 的m=0使每次外循环前都把m归零，使得先前m的值不带入下次循环。

想必您有好方法，指点一下吧？

[ 本帖最后由 qhxxbc 于 2010-12-11 16:03 编辑 ]

我按照您的意思编了1个类似程序：
{
    int s[]={1,4,4,6, 6,7,7,7,7,8,8}, i, j, m;
    for (i=0;i<14;i++)
    {
        for (m=0, j=i+1;j<14;j++)   
            if(s[i]==s[j])
            {
                m=m+1;
            }   
        if (m>2)
        {            
            printf("%d\n",m);
            break;            
        }
    }
}
但存在几个问题：
1.我的本意是若两个相邻的数不相等，那么就没必要继续比了；而这个程序要每两个数都比一下。
2.一旦我想要的结果，比如说找到了4个7，就想退出循环。而这个程序还要接着比后面的8。
这样的话效率低，因为我的实际问题中有很多数据。

希望各位高手帮帮我，课题需要用到C语言编程，而我以前从未接触过任何语言，难啊！

您说的 i=j-1;是什么意思？

众高手们，帮一下忙吧！等了几个小时了。

#include<stdio.h>
void main()
{
     int i,j,k;
     int a[20]={1,2,3,4,7,7,7,5,7,8,8,5,8,8,9,9,10,11,11,12};
     for(i=0;i<=(20-5);i++)
     {
         for(j=1;j<5;j++)
         {
             if(a[i]==a[i+j])
                 k=0;
             else

             {
                 k=1;
                 break;
             }
         }
         if(k==0)
         {
             printf("有连续5个%d\n",a[i]);
             break;
         }
      }
     if(k!=0)
         printf("没有连续相等的5个数字!\n");
}
感觉基本上都能满足你的要求，你换不同的数运行下试试看，不行再讨论…

收到的鲜花

• qhxxbc 于 2010-12-12 15:18 送鲜花  3朵   附言：最佳答案

和7楼想一块去了 一次循环实现

#include<stdio.h>
int main()
{
    int a[201] = {1};
    int k = 1;
    int m = a[0];
    int len = sizeof(a)/sizeof(int);
    for(int i=1;i!=len;++i)
    {
        if(a[i] == m)
        {
            ++k;
        }
        else
        {
            m = a[i];
            k = 1;
        }
        if(100==k)
        {
            k = 0;
            printf("找到连续相等的100个%d\n",m);
        }
    }
    getchar();
}

收到的鲜花

• qhxxbc 于 2010-12-12 15:18 送鲜花  2朵   附言：感谢高手

感谢各位回答者，在下受益匪浅！

你以为一重循环就真的比二重循环要好？
劝你一句：不要自以为是了，也不要把目光定位在这个论坛上。

我给一个二重循环的另一个版本：
  1。 确定第一个数据 s1
  2。 确定第100个数据 s2
     2.1  如果s2大于终止点end,跳到步骤6
  3。 用walk从s2开始向左查找，直到找到*s不等于*walk为止 或者 walk小于s1
     3.1  如果walk小于s1，那么s1就是符合要求的,返回s1
     3.2  否则把walk+1赋值给s1，并且把此时s1后面的第100个数据定为终止点end2
     3.3  如果终止点end2大于终止点end, 跳到步骤6
  4. 再用walk从s2开始向右边查找，直到找到*s不等于*walk为止 或者 walk大于终止点end2
     4.1  如果walk大于end2，那么s1就是符合要求的，返回s1
     4.2  否则把walk赋值给s1
  5. 重复1~4的步骤
  6. 返回NULL指针，没找到

#define TYPE char

/*
从数组s中查找连续n个 相同的数据(类型为TYPE)， 最多查找size个数据
返回 第一次查到的 那个元素的 地址 ；或者 NULL指针(没有要求的数据)
*/
TYPE *
fun (const TYPE *s, unsigned int size, unsigned int n)
{
  const TYPE *s1, *s2, *end;
  const TYPE *walk,    *end2;

 
  if ((n-- < 2))   return (TYPE*)s;

  s1  = s;
  end = s +size -1;
  for ( ; ; )
    {
    if ((s2 = s1+n) > end)   break;
   
    walk = s2;
    while ((--walk >= s1) && (*walk == *s2)){ }
   
    if ((walk < s1))  
      return (TYPE*)s1;//可以去掉这句
   
    s1   = walk + 1;
    walk = s2;
   
    if ((end2 = s1 + n) > end)  
      break;
   
    while ((++walk <= end2) && (*walk == *s2)){ }
   
    if ((walk > end2))  
      return (TYPE*)s1;
   
    s1 = walk;
    }

  return (TYPE*)NULL;
}

 

我上面的方法 比直接从头到尾的检查 可能效率要高 几十倍（连续100个数的话）。
如果连续的数目越多，这个算法的效率越能体现优势、