Ç阵列问题

Question

我有一个这样的阵列：

int sayilar[10] = {5,6,2,1,4,2,5,5,5,2}; 

现在我要得到这样的结果：发现2次重复，5 = 4倍，2 = 3次。

无法弄清楚如何做到这一点。这里是我的代码，这是不工作的权利：

#include <stdio.h> 

int main() 
{ 
    int sayilar[10]={5,6,2,1,4,2,5,5,5,2}; 
    int i,j; 
    int matris[5][2]; 

    int ar[5]; 

    int temp=0; 
    int tempX; 
    int k=0; 

    for(i=0; i<10; i++) 
    { 
     for(j=i+1; j<10; j++) 
     { 
      if(sayilar[j]==sayilar[i]) 
      { 
       if(temp==0) 
       { 
        matris[k][0] = sayilar[j]; 
        matris[k][1] = 1; 
        temp=1; 
       } else 
       { 
        matris[k][1]++; 
       } 
      } 
     } 
     if(temp!=0) 
     k++; 
     temp=0; 
    } 

    printf("%d %d",matris[0][0],matris[0][1]+1); 
} 

Answer 1

你知道数组中的数字什么？

如果你知道的，例如，他们都将是1到10之间，那么你可以只创建一个大小为10的阵列，其中将包括对每个数字的计数。

像这样（未测试）

int sayilar[] = {5,6,2,1,4,2,5,5,5,2}; 
int counts[10] = {}; 

for(int i=0; i<10; ++i) 
{ 
    ++counts[sayilar[i]-1]; 
} 

// Now the 'counts' array has: 
// counts[0] == 1  - indicating one '1' found 
// counts[1] == 3  - indicating three '2' found 
// counts[2] == 0  - indicating zero '3' found 
// etc. 

如果你没有什么价值可能在sayilar，然后排序第一，可能是最好的选择，因为其他人所说的任何保证。检查出qsort，它将就地排序你的数组。

Answer 2

我想你应该检查sayilar[i]不matris做嵌套循环之前。

for(i=0; i<10; i++) 
{ 
    int found = 0; 
    for (int l=0; l<k; l++) 
    { 
     if (matris[l][0] == sayilar[i]) { found = 1; break; } 
    } 

    if (!found) 
    { 
     for(j=i+1; j<10; j++) 
     { 
      //... 

如果你想更先进的解决方案，你可以在阵列，它具有O（nlogn）的复杂性进行排序，并不仅仅是简单地重复通数组排序...只是寻找灵感。

Answer 3

如果我写它，我会做它在两个阶段。

首先，我会循环阵列上，并计算每个实例：

int counts[5] = { 0,0,0,0,0 }; 

for (int i=0 ; i < 10 ; ++i) { 
    counts[ sayilar[i] - 1 ] += 1; 
} 

接下来，我会遍历和查找重复的：

for(int i=0 ; i < 5 ; ++i) { 
    if (counts[i] > 1) { 
     printf("Duplicate found: %d with %d instances\n", i+1, counts[i]); 
    } 
} 

这种方法留下它更更具可读性。

Answer 4

理想情况下，你想这样做的一个传球，而不是使用嵌套循环。最好的方法是使用某种映射结构，其中map键是您要计算的值，map值是该值的出现次数。

对于这个具体的例子，最容易做的事情是建立一个单一尺寸的数组，其中指数对应于你正在计算值。例如：

int sayilar[10]={5,6,2,1,4,2,5,5,5,2}; 
size_t counts[10] = {0}; 
size_t dups = 0; 
... 
for (i = 0; i < 10; i++) 
{ 
    /** 
    * Add one to the value of counts[k], where k == sayilar[i] 
    */ 
    counts[sayilar[i]]++; 

    /** 
    * If the count is equal to 2, add one to the value 
    * of dups. We use == 2 instead of > 1 so that we 
    * only count unique duplicates. 
    */ 
    if (counts[sayilar[i]] == 2) 
    { 
    dups++; 
    } 
} 

因此，作为这个循环执行，counts被更新如下：

counts[5] = 1; 
counts[6] = 1; 
counts[2] = 1; 
counts[1] = 1; 
counts[4] = 1; 
counts[2] = 2; dups = 1; 
counts[5] = 2; dups = 2; 
counts[5] = 3; 
counts[5] = 4; 
counts[2] = 3; 

不幸的是，这种方法并不能很好地进行缩放，如果你跟踪一个很宽范围的值，或者不是整数的值。

语言如C++和Java提供了一个内置的这通常是建立在某种平衡树结构就像一个红黑树，这是超越矫枉过正这个特定问题的顶部映射数据类型。