C 查找数组中不同元素数量的最快方法

我有一个包含整数的方阵（不一定是不同的）。我需要最快的方法来找到其中不同元素的数量。我试图将整数存储在一维数组中，对其进行排序，然后找到不同元素的数量……但显然，速度不够快。您能推荐一个更好更快的C语言程序吗？

什么程序最快取决于您处理的数据、涉及的结构大小等

整数可以取的值有界吗？如果是这样，那么保持一个由整数值索引的数组，并将其初始化为零，从而跟踪该值在矩阵中的拷贝数，可能是最快的，而且空间使用也是合理的

如果不是，那么可能使用哈希表来做类似的事情将是最快的

---

但是在任何情况下，为问题提供更精确的参数都是非常有帮助的。

对于任何算法来说，通常在速度、内存和复杂性之间都有一个折衷。正如其他人所说，您对数据了解的信息越多，生成算法的速度就越快。假设你有一个介于1和100之间的数字（作为一个例子），你就能够用这些信息来优化算法

我花时间写了一篇关于任何数据集通用的示例算法的文章。这假设您的设置大小足够小，或者您有足够的可用内存。基本上，简短的版本是分配一个数组，该数组的元素数与原始二维数组的元素数相同。然后在原始数组上循环，并将唯一元素放入新数组中的框中。最后计算新数组中的元素数：

#include <stdio.h>      /* printf, scanf, puts, NULL */
#include <stdlib.h>     /* srand, rand */
#include <time.h>       /* time */
typedef int bool;
#define TRUE 1
#define FALSE 0

/* The actual algorithm function - finds the number of unique values */
int NumberUniqueValues(int **array, int width, int height)
{
  int i = 0, j = 0, k = 0, maxFilled = 0;
  bool wasFound = FALSE;
  int *newElements = malloc(sizeof(int) * width * height);

  for (i = 0; i < height; i++) {
    for (j = 0; j < width; j++) {
      wasFound = FALSE;
      for (k = 0; k < maxFilled; k++) {
        if (newElements[k] == array[i][j]) {
          wasFound = TRUE;
          break;
        }
      }

      if (!wasFound) newElements[maxFilled++] = array[i][j];
    }
  }

  /* Free space */
  free(newElements);
  return maxFilled;
}

int main ()
{
  /* variables */
  int i = 0, j = 0;
  int originalWidth = 10;
  int originalHeight = 10;

  /* initialize array */
  int **originalArray = (int **)malloc(originalHeight * sizeof(int*));
  for (i = 0; i < originalHeight; i++) {
    originalArray[i] = (int *)malloc(originalWidth * sizeof(int));
  }

  /* initialize random seed, then fill with random values */
  srand (time(NULL));
  for (i = 0; i < originalHeight; i++) {
    for (j = 0; j < originalWidth; j++) {
      originalArray[i][j] = rand() % 100;
    }
  }

  printf("Number unique values: %d\n", NumberUniqueValues(originalArray, originalWidth, originalHeight));

  /* Free space */
  for (i = 0; i < originalHeight; i++) free(originalArray[i]);
  free(originalArray);

  return 0;
}

#包括/*printf、scanf、put、NULL*/
#包括/*srand，兰特*/
#包括/*时间*/
typedef int bool；
#定义真1
#定义FALSE 0
/*实际算法函数-查找唯一值的数目*/
int numbernuniquevalues（int**array，int width，int height）
{
int i=0，j=0，k=0，maxFilled=0；
bool-wasFound=FALSE；
int*newElements=malloc（sizeof（int）*宽度*高度）；
对于（i=0；i

---

同样，这可能不是最快的算法，因为我不知道所有的细节，但它至少会工作。祝你好运

整数值的有界集合0-99

矩阵尺寸300 x 300

int array[100];
int i;
int j;
int n_unique = 0;

for (i=0;i<300;i++) {
    if (n_unique == 100) break;
    for  (j=0;j<300;j++) {
        if (array[mat[i][j]] == 0) {
            array[mat[i][j]] = 1;
            n_unique++;
            if (n_unique == 100) break;
         }
    }
}

int数组[100]；
int i；
int j；
int n_unique=0；
对于（i=0；i首先，它取决于您对待数组的方式。如果它是动态的或非动态的，您可以使用2d数组作为1d数组，因为静态2d数组是1d数组，而动态数组可以创建为1d数组

const int M = 100;
const int N = 200;
int **a = NULL;
int i, j;

a = (int**) malloc(M * sizeof(int*) + N * M * sizeof(int));
a[0] = (int*)(a + M);
for (i = 1; i < M; i++) {
    a[i] = a[0] + i * N;
}
//code
free(a);

因此，1维阵列的两种算法

typedef int T;
#define EQ(a, b) ((a)==(b))

void quadDiff(T *a, size_t *out_size) {
    size_t i, j;
    size_t size = *out_size;
    size_t pos = 0;
    int unique;

    for (i = 0; i < size; i++) {
        unique = 1;
            for (j = i; j > 0; j--) {
                if (EQ(a[i], a[j-1])) {
                    unique = 0;
                    break;
                }
            }
            if (unique) {
                a[pos++] = a[i];
        }
    }
    *out_size = pos;
}

typedef int T；
#定义等式（a，b）（（a）=（b））
空四分差（T*a，大小\u T*out\u大小）{
尺寸i，j；
大小\u t大小=*输出大小；
大小\u t pos=0；
int-unique；
对于（i=0；i0；j--）{
if（式（a[i]，a[j-1]））{
唯一=0；
打破
}
}
如果（唯一）{
a[pos++]=a[i]；
}
}
*out_size=pos；
}

及

void sortDiff（T*a，size\u T item\u size，size\u T*out\u size，int（*cmp）（常量void*，常量void*））{
尺寸i；
T prev=a[0]；
大小\u t pos=0；
qsort（a，*外尺寸、项目尺寸、cmp）；
对于（i=0；i<*out\u size；i++）{
if（等式（prev，a[i]））{
继续；
}
prev=a[i]；
a[pos++]=a[i]；
}
*out_size=pos；
}
我建议采用以下方法：

在矩阵中的值上创建哈希映射
返回hashmap的大小作为结果
此问题的时间复杂性与创建hashmap所需的时间顺序相同。这不需要任何排序，并且比您正在使用的方法更有效。此方法独立于输入数据的范围，因此更通用

（我不擅长用C实现这些东西）我将包括一个Java代码来演示这种方法

class Distinct {
     public static void main(String ar[]) {
          int size;
          int matrix[][] = new int[size][size]; 
          // POPULATE THE MATRIX BY IMPLEMENTING CUSTOM METHOD
          populate(matrix); 
          // ALGORITHM:
          HashMap<Integer,Boolean> distinct = new HashMap<Integer,Boolean>();
          for(int i=0;i<size;i++) {
              for(int j=0;j<size;j++) {
                  distinct.put(matrix[i][j],true);
              }
          }
          System.out.println("Number of distinct elements:"+distinct.size());
     }
}

类不同{
公共静态void main（字符串ar[]{
整数大小；
整数矩阵[][]=新整数[size][size]；
//通过实现自定义方法填充矩阵
填充（矩阵）；
//算法：
HashMap distinct=新的HashMap（）；
对于（int i=0；i我有一个300x300矩阵…你建议什么方法？重新表述“值有界吗？”-你有一个合理接近的最小值和最大值吗（例如，所有数字都在0和100之间）？值的约束条件是什么？值是正的吗？有最大值吗？这有运行时复杂性O（n*m），其中n=矩阵项的数量，m=不同项的数量。这将在
void sortDiff(T *a, size_t item_size, size_t *out_size, int (*cmp)(const void *, const void *)) {
    size_t i;
    T prev = a[0];
    size_t pos = 0;
    qsort(a, *out_size, item_size, cmp);
    for (i = 0; i < *out_size; i++) {
        if (EQ(prev, a[i])) {
            continue;
        }
        prev = a[i];
        a[pos++] = a[i];
    }
    *out_size = pos;
}

class Distinct {
     public static void main(String ar[]) {
          int size;
          int matrix[][] = new int[size][size]; 
          // POPULATE THE MATRIX BY IMPLEMENTING CUSTOM METHOD
          populate(matrix); 
          // ALGORITHM:
          HashMap<Integer,Boolean> distinct = new HashMap<Integer,Boolean>();
          for(int i=0;i<size;i++) {
              for(int j=0;j<size;j++) {
                  distinct.put(matrix[i][j],true);
              }
          }
          System.out.println("Number of distinct elements:"+distinct.size());
     }
}