C 在数组中查找匹配的连续整数

给定两个包含整数的数组，找出两个数组中是否都存在三个连续整数。 例如：A=[1,4,5,7,2]和B=[3,1,4,5,9]将导致“true”/1，因为[1,4,5]在两个数组中都存在

我对这项任务的解决方案如下，但我觉得必须有一个比这更优化的解决方案

int consecutiveInts(int *a, int sizeA, int *b, int sizeB){
    int i, j;

    // Iterate over every integer in array b for every integer in array a.
    for (i = 0 ; i < sizeA - 2 ; i++){
        for (j = 0 ; j < sizeB - 2 ; j++){
            if (a[i] == b[j] && a[i + 1] == b[j + 1] && a[i + 2] == b[j + 2])
                return 1;
        }
    }
    return 0;
}

int连续（int*a、int-sizeA、int*b、int-sizeB）{
int i，j；
//对数组a中的每个整数迭代数组b中的每个整数。
对于（i=0；i

我想我应该说，在循环之外声明I和j是无用的，而且没有优化

比如：

for (unsigned i = 0; i < sizeA - 2; i++) // i will only exist inside the loop

for（unsigned i=0；i

会好一点。

---

我使用无符号类型，因为这是我在使用迭代变量时的习惯。我认为这是一个问题，如果你感兴趣并且还没有被告知，你可以通过阅读这个主题来学习

for(int i=0;i<A.length;i++)
{
    for(int j=0;j<A.length;j++)
    {
        if(A[i]==B[j])
        {
            count=count+1; //It checks how many times equal elements have been found
                           //ensure to declare and initialize int count=0;
        }
    }
}
if(count>=3)
    System.out.println("true");

---

for（int i=0；i不确定它是否优化了运行速度，但我注意到，如果有重复的数字，您不需要反复检查它们

例如，第一个数组中的三个连续元素都是
1
。在检查
a[i]
并发现不匹配后，您可以直接跳到
a[i+3]
，而无需比较
a[i+1]
或
a[i+2]
（它们也是不匹配）

对这种情况的管理，特别是当它是一个短的重复序列时，可能不会提高运行时间。您必须测量。
对于不影响性能的代码更改，任何候选改进都需要分析（测量性能的测试）来验证

如果
a[]
中也存在重复值，则以下仍然是一个O（n*m），但系数会减小，因为它可以更快地通过
b[]
。这会加快内部
b[]
循环，其中大部分时间被消耗


查看
a[]
模式中的不同值，以便
j
可能会提升得更快。

例如：

从2开始迭代。相应地调整索引

for (i = 2 ; i < sizeA ; i++){
  ...

（i=2；i{
...

对于小数组，OP方法是可以的。对于数组长度

m，n

它有

O（m*n）

运行时间

另一种方法是生成两个值数组，对它们进行排序，然后查找一个公共元素。它有

O（m*log2（m）+n*log2（n））

运行时。使用大型数组肯定比OP的代码更快

typedef struct {
  int i[3];
} int3;

void Init3(int3 *i3, const int *i, size_t n) {
  while (n--) {
    i3[n].i[0] = i[n];
    i3[n].i[1] = i[n + 1];
    i3[n].i[2] = i[n + 2];
  }
}

int fcmp(const void *a, const void *b) {
  return memcmp(a, b, sizeof (int3));
}

bool Pattern3(const int *a, size_t size_a, const int *b, size_t size_b) {
  if (size_a < 3 || size_b < 3) return false;

  int3 a3[size_a - 2];
  Init3(a3, a, size_a - 2);
  qsort(a3, size_a - 2, sizeof *a3, fcmp);

  int3 b3[size_b - 2];
  Init3(b3, b, size_b - 2);
  qsort(b3, size_b - 2, sizeof *b3, fcmp);

  while (size_a && size_b) {
    int cmp = fcmp(&a[size_a - 1], &b[size_b - 1]);
    if (cmp == 0) return true;
    if (cmp > 0) size_a--;
    else size_b--;
  }
  return false;
}

int main() {
  int A[] = { 1, 4, 5, 7, 2 };
  int B[] = { 3, 1, 4, 5, 9 };
  printf("%d\n", Pattern3(A, sizeof A / sizeof *A, B, sizeof B / sizeof *B));
}

typedef结构{
int i[3]；
}int3；
void Init3（int3*i3，常数int*i，大小n）{
而（n--）{
i3[n].i[0]=i[n]；
i3[n].i[1]=i[n+1]；
i3[n].i[2]=i[n+2]；
}
}
整数fcmp（常数无效*a，常数无效*b）{
返回memcmp（a，b，sizeof（int3））；
}
bool Pattern3（常数int*a、大小t大小a、常数int*b、大小t大小b）{
如果（大小a<3 | |大小b<3）返回false；
int3 a3[尺寸a-2]；
初始值3（a3，a，尺寸_a-2）；
qsort（a3，尺寸为a-2，尺寸为*a3，fcmp）；
int3 b3[size_b-2]；
Init3（b3，b，大小为b-2）；
qsort（b3，尺寸为b-2，尺寸为*b3，fcmp）；
while（尺寸a和尺寸b）{
int cmp=fcmp（&a[尺寸a-1]，&b[尺寸b-1]）；
如果（cmp==0）返回true；
如果（cmp>0）大小_a--；
其他尺寸_b--；
}
返回false；
}
int main（）{
inta[]={1,4,5,7,2}；
int B[]={3,1,4,5,9}；
printf（“%d\n”，Pattern3（A，sizeof A/sizeof*A，B，sizeof B/sizeof*B））；
}

---

另一种方法是使用

bsearch（）

而不是形成第二个

int3 b3[]/qsort（）

我会在循环之前做一些测试，这样它就不会毫无用处地循环。例如，检查A和B的大小是否大于3。您可能希望以更完整的方式编写示例，并在上征求评论。请务必先阅读，因为那里的某些事情做得不同！使用动态编程。我建议您可以缩进代码以使其更易于阅读。

for (i = 2 ; i < sizeA ; i++){
  ...

typedef struct {
  int i[3];
} int3;

void Init3(int3 *i3, const int *i, size_t n) {
  while (n--) {
    i3[n].i[0] = i[n];
    i3[n].i[1] = i[n + 1];
    i3[n].i[2] = i[n + 2];
  }
}

int fcmp(const void *a, const void *b) {
  return memcmp(a, b, sizeof (int3));
}

bool Pattern3(const int *a, size_t size_a, const int *b, size_t size_b) {
  if (size_a < 3 || size_b < 3) return false;

  int3 a3[size_a - 2];
  Init3(a3, a, size_a - 2);
  qsort(a3, size_a - 2, sizeof *a3, fcmp);

  int3 b3[size_b - 2];
  Init3(b3, b, size_b - 2);
  qsort(b3, size_b - 2, sizeof *b3, fcmp);

  while (size_a && size_b) {
    int cmp = fcmp(&a[size_a - 1], &b[size_b - 1]);
    if (cmp == 0) return true;
    if (cmp > 0) size_a--;
    else size_b--;
  }
  return false;
}

int main() {
  int A[] = { 1, 4, 5, 7, 2 };
  int B[] = { 3, 1, 4, 5, 9 };
  printf("%d\n", Pattern3(A, sizeof A / sizeof *A, B, sizeof B / sizeof *B));
}