merge sort

sort.c

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

#define NDATA   100000

void swap(uint32_t* );
uint32_t** sepaTwo(uint32_t*, uint32_t);
uint32_t* mergeTwo(uint32_t*, uint32_t, uint32_t*, uint32_t);
uint32_t* mergeSort(uint32_t*, uint32_t);

int main(void) {
    FILE *f = fopen("IntegerArray.txt","r");
    uint32_t *data = (uint32_t*) malloc(sizeof(uint32_t)*NDATA);
    uint32_t iArray = 0;
    while (!feof(f) && iArray < NDATA) {
        fscanf (f, "%d\n", &data[iArray++]);
    }

    for (int i=0; i<iArray; ++i) printf("%d\n", data[i]);
    uint32_t *dataSort = mergeSort(data, iArray);

    for (int i=0; i<iArray; ++i) printf("%d\n", dataSort[i]);
    free(data);
    free(dataSort);
    fclose(f);
    return 0;
}

void swap(uint32_t* data) {
    uint32_t b = data[0];
    data[0] = data[1];
    data[1] = b;
}

uint32_t** sepaTwo(uint32_t* data, uint32_t size_data){
    uint32_t** sepData = (uint32_t**) malloc(sizeof(uint32_t*)*2);
    sepData[0] = &data[0];
    sepData[1] = &data[size_data/2];

    return sepData;
}

uint32_t* mergeTwo(uint32_t* A, uint32_t nA, uint32_t* B, uint32_t nB){
    uint32_t iA = 0, iB = 0, iC = nA+nB;
    uint32_t* data_merged = (uint32_t*) malloc(sizeof(uint32_t)*iC);
    for (int i=0; i<iC; ++i) {
        if ( (iB==nB) || (iA != nA && A[iA]<B[iB]) ) {
            data_merged[i] = A[iA++];
        } else{
            data_merged[i] = B[iB++];
        }
    }
    return data_merged;
}


uint32_t* mergeSort(uint32_t* data, uint32_t size_data) {
    uint32_t* data_sorted;

    if (size_data <=2) {
        data_sorted = (uint32_t*) malloc(sizeof(uint32_t)*size_data);
        for (int i=0; i<size_data; ++i) {
            data_sorted[i] = data[i];
        }

        if (size_data == 1) {
            return data_sorted;
        }

        if (size_data == 2) {
            if (data[0] > data[1]) swap(data_sorted);
        }
        return data_sorted;
    }

    uint32_t** sepData = sepaTwo(data, size_data);
    uint32_t* data1 = mergeSort(sepData[0], size_data/2);
    uint32_t* data2 = mergeSort(sepData[1], (size_data+1)/2);
    data_sorted = mergeTwo(data1, size_data/2, data2, (size_data+1)/2);

    free(data1);
    free(data2);
    free(sepData);

    return data_sorted;
}