Отсортировать по возрастанию массив, заданный в виде файла

#include <stdio.h>
#include <stdlib.h>
 
#define ARRAY_BLOCK_SIZE (32)
 
typedef struct ARRAY {
    int * data;
    size_t elements;
    size_t volume;
} array_t;
 
array_t * array_new(void) {
    array_t * arr = malloc(sizeof(array_t));
    
    if ( ! arr )
        return NULL;
        
    arr->elements = 0;
    arr->volume = ARRAY_BLOCK_SIZE;
    arr->data = malloc(sizeof(int) * ARRAY_BLOCK_SIZE);
    
    if ( ! arr->data ) {
        free(arr);
        return NULL;
    }
    
    return arr;
}
 
void array_free(array_t * array) {
    free(array->data);
    free(array);
}
 
int array_add(array_t * array, const int value) {
    if ( array->elements == array->volume ) {
        array->volume += ARRAY_BLOCK_SIZE;
        int * tmp = realloc(array->data, sizeof(int) * array->volume);
        if ( ! tmp ) {
            array->volume -= ARRAY_BLOCK_SIZE;
            return -1;
        }
        else
            array->data = tmp;
    }
    
    array->data[array->elements++] = value;
    
    return 0;
}
 
array_t * array_from_file(const char * filename) {
    array_t * arr;
    FILE * f;
    int n;
    
    if ( ! ( f = fopen(filename, "r") ) )
        return NULL;
        
    if ( ! ( arr = array_new() ) ) {
        fclose(f);
        return NULL;
    }
    
    while ( fscanf(f, "%d", &n) == 1 ) {
        if ( array_add(arr, n) ) {
            array_free(arr);
            fclose(f);
            return NULL;
        }
    }
    
    fclose(f);
    return arr;
}
 
int array_to_file(array_t * array, const char * filename) {
    size_t i = 0;
    FILE * f = fopen(filename, "w");
    
    if ( ! f )
        return -1;
    
    while ( i < array->elements ) {
        if ( fprintf(f, "%d ", array->data[i++]) == EOF ) {
            fclose(f);
            return -1;
        }
    }
    fprintf(f, "\n");
    
    return ( ferror(f) | fclose(f) );
}
 
void array_sort(array_t * array, int (*cmpfunc)(const void *, const void *)) {
    qsort(array->data, array->elements, sizeof(int), cmpfunc);
}
 
int asccmp(const void * a, const void * b) {
    return *(int*)a - *(int*)b;
}
 
#define FILE_NAME "numbers.txt"
 
int main(void) {
    array_t * array = array_from_file(FILE_NAME);
    
    if ( ! array ) {
        fprintf(stderr, "Can't create array from file!\n");
        return 1;
    }
    array_sort(array, asccmp);
    if ( array_to_file(array, FILE_NAME) ) {
        fprintf(stderr, "Can't save array to file!\n");
        return 1;
    }
    array_free(array);
    
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
const int N = 10;
int main()
{
    int i, j, c, A[N];
    FILE *fp;
    fp = fopen("input.txt", "r");
    if(fp == NULL){
        printf("Net faila dannyh\n");
        return 1;
    }
    for(i = 0; i < N; ++i)
        if(1 != fscanf(fp, "%d", &A[i])){
        printf("Ne hvataet dannyh v faile\n");
        return 1;
        }
    fclose(fp);
    for(i = 0; i < N - 1; ++i){
        for(j = N - 2; j >= i; --j)
            if(A[j] > A[j + 1]){
                c = A[j];
                A[j] = A[j + 1];
                A[j + 1] = c;
            }
    }
    printf("otsortirovanniy massiv\n");
    for(i = 0; i < N; ++i)
        printf("%d ", A[i]);
    return 0;
}