Test FuDePan

/* Examen de tesinas para FuDePAN */

/** TADs usados en la resolucion */

typedef enum {FALSE=0, TRUE=!0} Boolean;

typedef struct {
    unsigned int index;     /* El indice del arreglo que estamos recorriendo */
    Boolean ended;      /* Flag para indicar si llegamos al final del arreglo */
} ArrayIndex;

/** Funciones Auxiliares */

/* Rutina de inicializacion para el TAD arriba definido */
ArrayIndex ArrIndInit (void) {
    ArrayIndex result;

    result.index = 0;
    result.ended = FALSE;

    return result;
}

/* 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 */
void 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 = TRUE;
    }
}

/* 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;

    const unsigned int size_result = size1 + size2;

    fstindex = ArrIndInit();
    sndindex = ArrIndInit();

    i = 0;
    while (i<size_result && ! fstindex.ended && ! sndindex.ended ) {
        /* 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]) {
            assignandcheck (&fstindex, i, size1, array1, result);
        } else {
            assignandcheck (&sndindex, i, size2, array2, result);
        }
        i++;
    }

    /* Si el ciclo termino, pero no recorrimos ambos arreglos... */
    /*... entonces falta copiar size_result - i elementos de un arreglo */
    if (i<size_result && sndindex.ended) {
        arraychunkcopy (fstindex.index, size_result-i, i, array1, result);
    }
    if (i<size_result && fstindex.ended) {
        arraychunkcopy (sndindex.index, size_result-i, i, array2, result);
    }

    return size_result;
}