Erreur d'exécution: insertatIndex

Question

#include <stdio.h> 
#include <malloc.h> 

int insertAt(int *Arr, int len, int num) { 
    for (int i = 0; i < len; ++i) { 
     if (num <= Arr[0]) 
      return 0; 
     else if (num >= Arr[len]) 
      return len + 1; 
     else if (num >= Arr[i - 1] && num <= Arr[i]) 
      return i; 
    } 
} 

int * sortedArrayInsertNumber(int *Arr, int len, int num){ 
    int *output = (int *)malloc((len + 1)*sizeof(int)); 

    if (len <= 0) 
     return NULL; 
    for (int i = 0, j = 0; j <= len+1; ++i, ++j) { 
     if (i == insertAt(Arr, len, num) && j==i) { 
      output[j] = num; 
      --i; 
     } 
     else if(insertAt(Arr,len,num)==len+1) { 
      output[j] = num; 
     } 
     else { 
      output[j] = Arr[i]; 
     } 
    } 
    return output; 
} 

int main() { 
    int input[5] = {2,4,6,8,10}; 
    int *out = (int*)malloc(6*sizeof(int)); 
    out = sortedArrayInsertNumber(input, 5, 12); 
    for(int i=0;i<6;++i) { 
     printf("%d\n", out[i]); 
    } 
} 

Lorsque j'essaie ce cas de test, cela me donne parfois une erreur d'exécution. D'autres fois, il sort:

2 
4 
6 
8 
10 
12 

Qui n'a aucun sens?

De plus, y a-t-il un moyen d'améliorer mon code?

La question nécessite que j'insère une valeur num à l'index approprié.

Answer 1

Dans la fonction insertAt, il y a au moins deux tentatives d'accès à la mémoire au-delà de la matrice. La première est dans la déclaration

else if (num >= Arr[len]) 
        ^^^^ 

Et le second est dans la déclaration

else if (num >= Arr[i - 1] && num <= Arr[i]) 
        ^^^^^^ 

lorsque la i variable est égale à 0.

La fonction sortedArrayInsertNumber commence par une mémoire potentielle fuite lorsque la variable len est au moins égale à 0 car d'abord une mémoire est allouée puis il y a sortie de la fonction avec un pointeur NULL.

int * sortedArrayInsertNumber(int *Arr, int len, int num){ 
    int *output = (int *)malloc((len + 1)*sizeof(int)); 

    if (len <= 0) 
     return NULL; 
    // ... 

En outre, il est une mauvaise idée lorsque la longueur d'un tableau est de type int au lieu du type size_t.

Pour appeler plusieurs fois la fonction insertAt dans la fonction sortedArrayInsertNumber n'a pas de sens et casse la boucle.

Dans la principale, il y a encore une fuite de mémoire

int *out = (int*)malloc(6*sizeof(int)); 
out = sortedArrayInsertNumber(input, 5, 12); 

Le programme peut regarder la façon suivante.

#include <stdio.h> 
#include<stdlib.h> 

size_t insertAt(const int *a, size_t n, int num) 
{ 
    size_t i = 0; 

    while (i < n && !(num < a[i])) i++; 

    return i; 
} 

int * sortedArrayInsertNumber(const int *a, size_t n, int num) 
{ 
    int *b = malloc((n + 1) * sizeof(int)); 

    if (b) 
    { 
     size_t pos = insertAt(a, n, num); 

     size_t i = 0; 
     for (; i < pos; i++) b[i] = a[i]; 

     b[i] = num; 

     for (; i < n; i++) b[i+1] = a[i]; 
    } 

    return b; 
} 

int main(void) 
{ 
    int input[] = { 2, 4, 6, 8, 10 }; 
    const size_t N = sizeof(input)/sizeof(*input); 

    int *out = sortedArrayInsertNumber(input, N, 12); 

    if (out) 
    { 
     for (size_t i = 0; i < N + 1; i++) 
     { 
      printf("%d ", out[i]); 
     } 
     putchar('\n'); 
    } 

    free(out); 

    return 0; 
} 

Sa sortie est

2 4 6 8 10 12 

au lieu des boucles dans la fonction sortedArrayInsertNumber vous pouvez utiliser la fonction standard C memcpy déclarée en-tête <string.h>.