Test FuDePan

/* Examen de tesinas para FuDePAN */

/** TADs usados en la resolucion */
typedef struct {
    unsigned int index;     /* El indice del arreglo que estamos recorriendo */
    int ended;      /* Flag para indicar si llegamos al final del arreglo (1),
                o todavia se lo esta recorriendo (0) */
} ArrayIndex;

/** Funciones Auxiliares */

/* Assignandcheck coloca el valor de array[arrindex.index] en res[place], aumenta arrindex.index en 1,
   y verifica si se ha llegado al final de array; si es asi, le da el valor 1 a arrindex.ended;
   devuelve el nuevo valor de arrindex */
ArrayIndex assignandcheck (ArrayIndex arrindex, const int place, const unsigned int size, const int array[], int * res) {
    res[place] = array[arrindex.index];
    arrindex.index ++;
    if (arrindex.index == size) {
        arrindex.ended = 1;
    }
    return arrindex;
}

/* Arraychunkcopy toma copyamount elementos desde la posicion arrindex de array,
   y los va colocando en res a partir de la posicion resindex */
void arraychunkcopy (const unsigned int arrindex, const unsigned int copyamount, const unsigned int resindex, const int array [], int * res) {
    unsigned int i;
    for (i=0; i<copyamount; i++) {
        res[resindex+i] = array[arrindex+i];
    }
}

/** La funcion requerida en el enunciado */

unsigned int merge(const int array1[], unsigned int size1, const int array2[], unsigned int size2, int result[])
    {

    ArrayIndex fstindex, sndindex; /* Indices para recorrer el primero y segundo arreglos, respectivamente */

    unsigned int i;
    unsigned int remainder; /* La cantidad de elementos de un arreglo que falta copiar, cuando se termino
                   el recorrido del otro arreglo */

    const unsigned int size_result = size1 + size2;

    fstindex.index = 0;
    fstindex.ended = 0;
    sndindex.index = 0;
    sndindex.ended = 0;

    i = 0;
    while (i<size_result && fstindex.ended == 0 && sndindex.ended == 0) {
        /* Si no se llego al final de ninguno de los arreglos, comparamos el primer elemento de cada arreglo */
        if (array1[fstindex.index] <= array2[sndindex.index]) {
            fstindex = assignandcheck (fstindex, i, size1, array1, result);
        } else {
            sndindex = assignandcheck (sndindex, i, size2, array2, result);
        }
        i++;
    }
    if (i<size_result) { /* Si el ciclo termino, pero no recorrimos ambos arreglos... */
                /*... entonces falta copiar parte de un arreglo */
        remainder = size_result - i;

        if (sndindex.ended == 1) {
            arraychunkcopy (fstindex.index, remainder, i, array1, result);
        } else if (fstindex.ended == 1) {
            arraychunkcopy (sndindex.index, remainder, i, array2, result);
        }
    }

    return size_result;
}