在C中计算重复项

如果将阵列设置为：

test[10] = {1,2,1,3,4,5,6,7,8,3,2}

---

我想返回数字3，因为有一个重复的1，一个重复的2和一个重复的3。我怎样才能做到这一点？效率无关紧要。

首先必须对数组进行排序，以便更容易找到重复的数组

以下是排序（气泡排序）的示例：

void bubbleSort（整数[]，整数数组大小）{
int i，j，温度；
对于（i=（数组大小-1）；i>0；i--）{
对于（j=1；j个数[j]）{
温度=数字[j-1]；
数字[j-1]=数字[j]；
数字[j]=温度；
}
}
}
}

然后再次循环，找出

值[i]

是否为

=

到

值[i+1]

---

注意：当您创建for循环时，将其长度缩短1，以补偿

值[i+1]

，这样它就不会超出范围。

我花了一些时间来调试它。因为它应该是

int-test[11]={1,2,1,3,4,5,6,7,8,3,2}

而不是

int-test[10]

。每个元素都有0到10的订阅。总共有11个元素

    #include <stdlib.h>
    #define LEN (11)
    int test[LEN] = {1,2,1,3,4,5,6,7,8,3,2};
    void sort(int n, int *test){//sort them, use whatever you like
        int i,j,y;
        for (i=0;i<n;++i){
            for (j=i+1;j<n;++j)
                if (test[i]>test[j]){
                    y=test[i];
                    test[i]=test[j];
                    test[j]=y;
                }
            }
    }
    int main(){
        sort(LEN,test);//sort first
        int cnt = 0 , i ;
        for(i=1;i<LEN;++i)
            cnt += (test[i]==test[i-1]);//count duplicates
        printf("%d\n",cnt);//print result

    }

#包括
#定义LEN（11）
int test[LEN]={1,2,1,3,4,5,6,7,8,3,2}；
void sort（int n，int*test）{//对它们进行排序，可以随意使用
int i，j，y；
对于（i=0；i您可以使用此代码

int main()
{
 int test[10] = {1,2,1,3,4,5,6,7,8,3,2};
 int i,j,dupliCount = 0;
 for (i =0; i<(sizeof(test)/sizeof(int));i++)
  {
  for(j=i+1;j<(sizeof(test)/sizeof(int));j++)
   {
    if (test[i] == test[j])
     {
      ++dupliCount;
      break;
     }
   }
  }
printf("duplicate count %d",dupliCount);
}

intmain（）
{
int测试[10]={1,2,1,3,4,5,6,7,8,3,2}；
int i，j，dupliCount=0；
对于（i=0；i如果内存空间不重要（我的意思是不受内存使用的限制）但是运行时间很重要并且您知道数组中的值不大于数组的大小，那么
Bucket Sort
听起来像是执行此任务的人。它将在O（n）而不是O（nlgn）中执行此任务（如果您决定先对数组进行排序）

intmain（）
{
int test[LEN]={1,2,1,3,4,5,6,7,8,3,2}；
int ndup=0；
int bucket_数组[LEN]={0}；
对于（i=0；i

我还没有编译，但我想应该可以

注意：非常感谢jim balter的有用评论。
对其进行排序，然后检查重复项是很简单的。假设列表扩展为另外3个；您想要答案3还是4？如果再添加3个，则重复项将是4个数组，大小固定。无需排序（参见Mani的答案，以及我在infihorz的答案下的评论）。但你永远不会得到正确的答案，因为你试图将11个数字放入10个元素的数组中。然而，这是一个真正的问题；这不是结束此操作的有效理由。更好：
int test[]={1,2,1,3,4,5,6,7,8,3,2}；#define LEN（sizeof test/sizeof*test）
。冒泡排序很糟糕。@JimBalter冒泡排序更容易实现，示例序列也很短。我无法想象任何能够理解
qsort
的人都无法想出解决这个重复计数问题的方法。你不必理解qsort，你只需调用它。无论如何，冒泡排序很糟糕，no任何人都应该接触到它。但是…你的排序不是邪恶的冒泡排序；我的错误；它是一种不太糟糕的选择排序。（最好的简单的o（n^2）排序是插入排序。）对不起。现在看看我编辑的代码：）你比这些可笑的o（n^2）排序更接近，但你根本不需要排序…
int bucket[MAXVAL+1]={0}；int ndups=0；for（i=0；i

int main()
{
 int test[10] = {1,2,1,3,4,5,6,7,8,3,2};
 int i,j,dupliCount = 0;
 for (i =0; i<(sizeof(test)/sizeof(int));i++)
  {
  for(j=i+1;j<(sizeof(test)/sizeof(int));j++)
   {
    if (test[i] == test[j])
     {
      ++dupliCount;
      break;
     }
   }
  }
printf("duplicate count %d",dupliCount);
}

int main()
{
    int test[LEN] = {1,2,1,3,4,5,6,7,8,3,2};
    int ndup = 0;
    int bucket_array[LEN] = {0};

    for (i = 0; i < LEN; i++) {
        if (bucket_array[test[i]]++) {
            ndup++;
        }
    }

    printf("%d duplicates\n", ndup);
    return 0;
}