Сформировать новый массив из элементов массивов P и Q, присутствующих в них обоих

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
 
void RemoveValues(int* const arr, size_t* const arrLengthPtr, const int value)
{
  int canContinue = 0;
 
  size_t i = 0;
 
  i = 0;
  while (i < ((*arrLengthPtr) - 1))
  {
    canContinue = 1;
    while ((arr[i] == value) && canContinue)
    {
      if (i == ((*arrLengthPtr) - 1))
      {
        canContinue = 0;
      }
      else
      {
        memmove(&arr[i], &arr[i + 1], ((*arrLengthPtr) - i - 1) * sizeof(*arr));
      }
 
      (*arrLengthPtr)--;
    }
    i++;
  }
}
 
int IsValuePresentInArray(const int* const arr, const size_t N, const int value)
{
  int isPresent = 0;
 
  const int* iterator = arr;
 
  while ((iterator < (arr + N)) && !isPresent)
  {
    if (*iterator == value)
    {
      isPresent = 1;
    }
    iterator++;
  }
 
  return isPresent;
}
 
int ConstructThird(int** const firstArrPtr, size_t* const firstArrLengthPtr,
  int** const secondArrPtr, size_t* const secondArrLengthPtr,
  int** const thirdArrPtr, size_t* const thirdArrLengthPtr)
{
  int errorCode = 0;
  int value = 0;
 
  int* newArr = NULL;
  int* temp = NULL;
 
  size_t N = 0;
  size_t i = 0;
 
  do
  {
    newArr = malloc((*firstArrLengthPtr) * sizeof(*newArr));
    if (newArr == NULL)
    {
      errorCode = 1;
      break;
    }
 
    memset(newArr, 0, (*firstArrLengthPtr) * sizeof(*newArr));
 
    while (i < (*firstArrLengthPtr))
    {
      value = (*firstArrPtr)[i];
 
      if (IsValuePresentInArray(*secondArrPtr, *secondArrLengthPtr, value))
      {
        newArr[N] = (*firstArrPtr)[i];
        N++;
 
        RemoveValues(*firstArrPtr, firstArrLengthPtr, value);
        RemoveValues(*secondArrPtr, secondArrLengthPtr, value);
      }
      i++;
    }
 
    temp = realloc(*firstArrPtr, (*firstArrLengthPtr) * sizeof(*temp));
    if (temp == NULL)
    {
      free(newArr);
      errorCode = 1;
      break;
    }
    else
    {
      (*firstArrPtr) = temp;
    }
 
    temp = realloc(*secondArrPtr, (*secondArrLengthPtr) * sizeof(*temp));
    if (temp == NULL)
    {
      free(newArr);
      errorCode = 1;
      break;
    }
    else
    {
      (*secondArrPtr) = temp;
    }
 
    temp = realloc(newArr, N * sizeof(*temp));
    if (temp == NULL)
    {
      free(newArr);
      errorCode = 1;
      break;
    }
    else
    {
      newArr = temp;
    }
 
    (*thirdArrPtr) = newArr;
    (*thirdArrLengthPtr) = N;
  }
  while (0);
 
  return errorCode;
}
 
int CreateAndGenerateArray(int** const arrPtr, const size_t N)
{
  int* temp = NULL;
 
  size_t i = 0;
 
  temp = malloc(N * sizeof(*temp));
  if (temp == NULL)
  {
    return 0;
  }
  else
  {
    for (i = 0; i < N; i++)
    {
      temp[i] = rand() % 10;
    }
 
    (*arrPtr) = temp;
  }
 
  return 1;
}
 
 
void PrintArray(const int* const arr, const size_t N)
{
  size_t i = 0;
 
  for (i = 0; i < N; i++)
  {
    if (i < N - 1)
    {
      printf("%d ", arr[i]);
    }
    else
    {
      printf("%d\n", arr[i]);
    }
  }
}
 
int main(void)
{
  int* P = NULL;
  int* Q = NULL;
  int* Z = NULL;
 
  size_t lP = 8;
  size_t lQ = 6;
  size_t lZ = 0;
 
  srand(time(NULL));
 
  CreateAndGenerateArray(&P, lP);
  CreateAndGenerateArray(&Q, lQ);
 
  printf("Before:\n");
  printf("Array P:\n");
  PrintArray(P, lP);
 
  printf("Array Q:\n");
  PrintArray(Q, lQ);
 
  ConstructThird(&P, &lP, &Q, &lQ, &Z, &lZ);
 
  printf("After:\n");
  printf("Array P:\n");
  PrintArray(P, lP);
 
  printf("Array Q:\n");
  PrintArray(Q, lQ);
 
  printf("Array Z:\n");
  PrintArray(Z, lZ);
 
  return 0;
}

qsort(P, size, sizeof(type), compare_P);
qsort(Q, size, sizeof(type), compare_Q);