Me gustaría pedirle a un experto en informática que me ayude a resolver un problema de estructura de datos al escribir una tabla de secuencia en lenguaje C.

#include

_Bool?isSorted(size_t?arr[],?size_t?n){

para?(int?i?=?n-1;?i& gt;0;?i--){

para? (int?j?=?0;?j

si?

}

}

retorno?*(pa?+?i));

printf("\n");

}

unsigned?short?int?find(size_t?*pa,?size_t?n,?size_t?e) {

para? (size_t?i?=?0;?i

return?0;

}

void?insert(size_t?arr[],?size_t?n,?size_t? e){

arr[n-1]=?e;

int?t;

for??1;?i>0;?i --){

for?(int?j?=?0;?j

si?(arr[j]>arr[j? +?1]){

t?=?arr[j];

arr[j]? =?arr[j?+?1];

arr[j?+?1]? =?t;

}

}

}

}

int?main(){

size_t?_max,*pa;

printf("Tamaño de matriz de entrada:");

scanf( "%d",? &_max);

///?1) Asignar dinámicamente una unidad de memoria de un tamaño específico

pa?=?(size_t*)calloc(_max,? sizeof( size_t));

///?2)Recorra los elementos incrementales para construir la tabla secuencial (con cada elemento separado por un espacio o un retorno de carro)

for? (size_t ?i?=?0;?i?

///?(1) {

if(isSorted(pa, _max))?break;

printf("No incremental, reescriba:");

for(size_t? i? =?0;?i?

///?i));

}

///?4) Recorrer la tabla de secuencia

iterator(pa,? _max);

///?5) Dinámicamente ajustar el tamaño de la unidad de memoria

_max?(size_t*)realloc(pa,?

if ((pa?=? (size_t*)realloc(pa,? _max*siz

eof(size_t)))?{

printf("¿reasignar?memoria?error!");

exit(EXIT_FAILURE);

}

///?6) Ajustar antes de insertar nuevos elementos para que sigan en orden

insert(pa,?_max,?50);

iterador ( pa,? _max);

///?7) Ajusta dinámicamente el tamaño de la memoria de la tabla de secuencia al doble del tamaño original

_max?(size_t*)realloc(pa,?

if ((pa?=?(size_t*)realloc(pa,? _max*sizeof(size_t)))?{

printf("realloc?memoria?error!" );

exit(EXIT_FAILURE);

}

///?8) Liberar memoria solicitada dinámicamente

free(pa);

sistema(" PAUSA");

retorno?0;

}

///?