Ç陣列問題

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提供了一個內置的這通常是建立在某種平衡樹結構就像一個紅黑樹，這是超越矯枉過正這個特定問題的頂部映射數據類型。