C 如何找到数组中重复次数最多的值？

我试图找到向量中重复次数最多的整数。 这是我的密码

for(i=0; i < dim; i++){
        temp=vet[i];
    for(i=0; i < dim; i++){
        if(vet[i]==temp){
            count++;
        }
    }
    if(most < count){
        most=count;
        elem=vet[i];
    }
}
return elem;}

（i=0；i{ 温度=兽医[i]； 对于（i=0；i

---

这是不对的。。我希望你能帮助我。。谢谢大家!

最明显的问题是，您的代码在内部循环和外部循环中都使用了

i

。在上述代码中，

most

和

count

变量未初始化，每次启动内部循环之前需要重置

count

在这段代码中，对每个元素遍历整个数组以计算外观的方法不是很有效。通过从

i+1

而不是从

0

启动内环，可以提高效率。通过这样做，每个元素的第一个频率计数将是正确的，尽管后面的计数将很低，因为之前的索引将不会被访问。但这并不重要，因为如果可能，第一次计数将设置

most

变量。

count

变量可以在内部循环开始之前设置为

1

，因为

i

th元素是测试值，内部循环将跳过该索引。此更改将大大减少阵列访问的数量

请注意，此函数将返回数组中出现频率最高的第一个元素的值

int get_most_common(int vet[], size_t dim)
{
    size_t i, j, count;
    size_t most = 0;
    int temp, elem;

    for(i = 0; i < dim; i++) {
        temp = vet[i];
        count = 1;
        for(j = i + 1; j < dim; j++) {
            if(vet[j] == temp) {
                count++;
            }
        }
        if (most < count) {
            most = count;
            elem = vet[i];
        }
    }
    return elem;
}

int-get\u-most\u-common（int-vet[]，size\t-dim）
{
尺寸i，j，计数；
最大尺寸=0；
内部温度，元素；
对于（i=0；i

最明显的问题是，您的代码在内部和外部循环中都使用了

i

。在上述代码中，

most

和

count

变量未初始化，每次启动内部循环之前需要重置

count

在这段代码中，对每个元素遍历整个数组以计算外观的方法不是很有效。通过从

i+1

而不是从

0

启动内环，可以提高效率。通过这样做，每个元素的第一个频率计数将是正确的，尽管后面的计数将很低，因为之前的索引将不会被访问。但这并不重要，因为如果可能，第一次计数将设置

most

变量。

count

变量可以在内部循环开始之前设置为

1

，因为

i

th元素是测试值，内部循环将跳过该索引。此更改将大大减少阵列访问的数量

请注意，此函数将返回数组中出现频率最高的第一个元素的值

int get_most_common(int vet[], size_t dim)
{
    size_t i, j, count;
    size_t most = 0;
    int temp, elem;

    for(i = 0; i < dim; i++) {
        temp = vet[i];
        count = 1;
        for(j = i + 1; j < dim; j++) {
            if(vet[j] == temp) {
                count++;
            }
        }
        if (most < count) {
            most = count;
            elem = vet[i];
        }
    }
    return elem;
}

int-get\u-most\u-common（int-vet[]，size\t-dim）
{
尺寸i，j，计数；
最大尺寸=0；
内部温度，元素；
对于（i=0；i

您可以尝试暴力法，计算每个元素的频率，然后找到最大值

为了高效地实现此类函数的完整版本，您将需要特殊的数据结构，如

哈希表

或

字典

但是，如果您只需要返回符合此条件的第一项，那么下面的代码就可以正常工作

#include <stdio.h>

// returns the first matched most frequent item of a list
// list items of same value must be grouped, for example, a sorted list
// only returns the first matched item
int max_frequent_item_of(int vet[], int dim)
{
  int i = 0;
  // element and its count of current sublist
  int current = vet[0];
  int current_count = 0;
  // most frequent element and its count of the list so far
  int most = vet[0];
  int most_count = 0;
  while (i < dim) {
    // if i-th element still belong to current sublist, run the counter
    if (vet[i] == current) {
      current_count += 1;
      i += 1;
    }
    // otherwise, the current sublist just ended
    else {
      // update the most frequent element
      if (current_count > most_count) {
        most = current;
        most_count = current_count;
      }
      // reset current sublist
      current = vet[i];
      current_count = 1;
      i += 1;
    }
  }
  printf("most frequent item %d, count %d\n", most, most_count);
  return most;
}

int main(void)
{
  // vet must be in order, sort with `qsort` if necessary
  int vet[] = {1, 1, 2, 3, 4, 4, 4, 8, 9, 9};
  int size = 10;
  int n;
  printf("list: ");
  for (n = 0 ; n < size; n++)
    {
      printf("%d ", vet[n]);
    }
  printf("\n");
  max_frequent_item_of(vet, size);
  return 0;
}

---

你可以尝试蛮力法，计算每个元素的频率，然后找到最大值

为了高效地实现此类函数的完整版本，您将需要特殊的数据结构，如

哈希表

或

字典

但是，如果您只需要返回符合此条件的第一项，那么下面的代码就可以正常工作

#include <stdio.h>

// returns the first matched most frequent item of a list
// list items of same value must be grouped, for example, a sorted list
// only returns the first matched item
int max_frequent_item_of(int vet[], int dim)
{
  int i = 0;
  // element and its count of current sublist
  int current = vet[0];
  int current_count = 0;
  // most frequent element and its count of the list so far
  int most = vet[0];
  int most_count = 0;
  while (i < dim) {
    // if i-th element still belong to current sublist, run the counter
    if (vet[i] == current) {
      current_count += 1;
      i += 1;
    }
    // otherwise, the current sublist just ended
    else {
      // update the most frequent element
      if (current_count > most_count) {
        most = current;
        most_count = current_count;
      }
      // reset current sublist
      current = vet[i];
      current_count = 1;
      i += 1;
    }
  }
  printf("most frequent item %d, count %d\n", most, most_count);
  return most;
}

int main(void)
{
  // vet must be in order, sort with `qsort` if necessary
  int vet[] = {1, 1, 2, 3, 4, 4, 4, 8, 9, 9};
  int size = 10;
  int n;
  printf("list: ");
  for (n = 0 ; n < size; n++)
    {
      printf("%d ", vet[n]);
    }
  printf("\n");
  max_frequent_item_of(vet, size);
  return 0;
}

---

我写这段代码做你需要的，如果两个数字有相同的重复时间，它会返回较大的一个

     int ReturnMostRepeated(int val[], size_t dim)
{

size_t i,j,count;



int temp=0, temp2;





for(i =0;i<dim;i++)
        {


count = 1;

        for(j=i+1;j<dim;j++)
            {


if(val[j]==val[i])
            {
                count++;
            }

            }


if (count>temp)
        {
            temp = count;
            temp2 = val[i];
        }else if(count == temp) if (val[i]>temp2) temp2 = val[i];

        }

        return temp2;

    }

int返回最重复（int val[]，大小\u t dim）
{
尺寸i，j，计数；
int temp=0，temp2；
对于（i=0；itemp2）temp2=val[i]；
}
返回temp2；
}

我写这段代码是为了满足您的需要，如果两个数字的重复时间相同，它会返回较大的一个

     int ReturnMostRepeated(int val[], size_t dim)
{

size_t i,j,count;



int temp=0, temp2;





for(i =0;i<dim;i++)
        {


count = 1;

        for(j=i+1;j<dim;j++)
            {


if(val[j]==val[i])
            {
                count++;
            }

            }


if (count>temp)
        {
            temp = count;
            temp2 = val[i];
        }else if(count == temp) if (val[i]>temp2) temp2 = val[i];

        }

        return temp2;

    }

int返回最重复（int val[]，大小\u t dim）
{
尺寸i，j，计数；
int temp=0，temp2；
对于（i=0；itemp2）temp2=val[i]；
}
返回temp2；
}

也许您可以按顺序访问每个元素，并且无论何时访问特定元素，都可以将其添加到另一个向量中，并确保下次在添加结果之前检查要访问的数字是否尚未包含在该向量中。虽然我不推荐有很多元素的向量，因为它会很慢。我知道哪里不对。它不能编译！对于

C

这是一个相当棘手的问题，您需要一个好的算法（先对数组排序，然后使用caterpillar方法）或一个好的数据结构（类似

Python

的哈希表或字典），然后你自己会很快发现bug。也许你可以按顺序访问每个元素，每次访问某个特定元素时，你都要将其添加到另一个向量中，并确保下次在添加结果之前检查要访问的数字是否还包含在该向量中。图格