LinkedList.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "LinkedList.h"

static Node* getNode(LinkedList* this, int nodeIndex);
static int addNode(LinkedList* this, int nodeIndex,void* pElement);

/** \brief Crea un nuevo LinkedList en memoria de manera dinamica
 *
 *  \param void
 *  \return LinkedList* Retorna (NULL) en el caso de no conseguir espacio en memoria
 *                      o el puntero al espacio reservado
 */
LinkedList* ll_newLinkedList(void)
{
    LinkedList* this;

    this = (LinkedList*) malloc(sizeof(LinkedList));
    if(this!=NULL)
    {
        this->size = 0;
        this->pFirstNode = NULL;
    }

    return this;
}

/** \brief Retorna la cantidad de elementos de la lista
 *
 * \param this LinkedList* Puntero a la lista
 * \return int Retorna (-1) si el puntero es NULL o la cantidad de elementos de la lista
 *
 */
int ll_len(LinkedList* this)
{
    int returnAux = -1;
    if(this!=NULL)
    {
        returnAux = this->size;
    }


    return returnAux;
}


/** \brief  Obtiene un nodo de la lista
 *
 * \param this LinkedList* Puntero a la lista
 * \param index int Indice del nodo a obtener
 * \return Node* Retorna  (NULL) Error: si el puntero a la lista es NULL o (si el indice es menor a 0 o mayor al len de la lista)
                        (pElement) Si funciono correctamente
 *
 */
static Node* getNode(LinkedList* this, int nodeIndex)
{
    Node* pNode = NULL;
    int i=0;
    if(this != NULL && nodeIndex > -1 && nodeIndex < ll_len(this))
    {
        pNode = this->pFirstNode;
        while(i != nodeIndex)
        {
            pNode = pNode->pNextNode;
            i++;
        }
    }


    return pNode;
}

/** \brief  Permite realizar el test de la funcion getNode la cual es privada
 *
 * \param this LinkedList* Puntero a la lista
 * \param index int Indice del nodo a obtener
 * \return Node* Retorna  (NULL) Error: si el puntero a la lista es NULL o (si el indice es menor a 0 o mayor al len de la lista)
                        (pElement) Si funciono correctamente
 *
 */
Node* test_getNode(LinkedList* this, int nodeIndex)
{
    return getNode(this, nodeIndex);
}


/** \brief Agrega y enlaza un nuevo nodo a la lista
 *
 * \param this LinkedList* Puntero a la lista
 * \param nodeIndex int Ubicacion donde se agregara el nuevo nodo
 * \param pElement void* Puntero al elemento a ser contenido por el nuevo nodo
 * \return int Retorna  (-1) Error: si el puntero a la lista es NULL o (si el indice es menor a 0 o mayor al len de la lista)
                        ( 0) Si funciono correctamente
 *
 */
static int addNode(LinkedList* this, int nodeIndex,void* pElement)
{
    int returnAux = -1;
    Node* prev;
    Node* next;
    Node* nuevoNodo;
    //printf("HOLA\n");

    if(this != NULL && nodeIndex > -1 && nodeIndex <= ll_len(this)) //&& nodeIndex < ll_len(this) no entra al if
    {
        //printf("nodeindex = %d y ll_len = %d\n", nodeIndex, ll_len(this));
        nuevoNodo = (Node*) malloc(sizeof(Node));
        nuevoNodo->pNextNode=NULL;
        if(nodeIndex == 0)
        {
            if(this->pFirstNode == NULL)
            {
                //printf("1-nodeindex = %d y ll_len = %d\n", nodeIndex, ll_len(this));
                this->pFirstNode = nuevoNodo;
            }
            else
            {
                //printf("1.5-nodeindex = %d y ll_len = %d\n", nodeIndex, ll_len(this));
                nuevoNodo->pNextNode=this->pFirstNode;
                this->pFirstNode = nuevoNodo;
            }
        }
        else if(nodeIndex == ll_len(this))
        {
            prev = getNode(this, nodeIndex-1);
            prev->pNextNode = nuevoNodo;
        }
        else
        {
            printf("push\n");
            prev=getNode(this, nodeIndex-1);
            next=getNode(this, nodeIndex);
            nuevoNodo->pNextNode=next;
            prev->pNextNode=nuevoNodo;
        }

        nuevoNodo->pElement = pElement;
        this->size++;
        returnAux = 0;
    }


    return returnAux;
}


/** \brief Permite realizar el test de la funcion addNode la cual es privada
 *
 * \param this LinkedList* Puntero a la lista
 * \param nodeIndex int Ubicacion donde se agregara el nuevo nodo
 * \param pElement void* Puntero al elemento a ser contenido por el nuevo nodo
  * \return int Retorna  (-1) Error: si el puntero a la lista es NULL o (si el indice es menor a 0 o mayor al len de la lista)
                        ( 0) Si funciono correctamente
 *
 */
int test_addNode(LinkedList* this, int nodeIndex,void* pElement)
{
    return addNode(this,nodeIndex,pElement);
}


/** \brief  Agrega un elemento a la lista
 * \param pList LinkedList* Puntero a la lista
 * \param pElement void* Puntero al elemento a ser agregado
 * \return int Retorna  (-1) Error: si el puntero a la lista es NULL
                        ( 0) Si funciono correctamente
 *
 */
int ll_add(LinkedList* this, void* pElement)
{
    int returnAux = -1;
    int indice = 0;

    if(this != NULL)
    {
        indice = ll_len(this);
        returnAux = addNode(this, indice, pElement);
    }
    return returnAux;
}
//  ******* OJO CORREGIR *******************
/** \brief Devuelve el elemento de la linkedlist del indice selecionado
 *
 * \param this LinkedList* Puntero a la lista
 * \param nodeIndex int Ubicacion del elemento a obtener
 * \return void* Retorna    (NULL) Error: si el puntero a la lista es NULL o (si el indice es menor a 0 o mayor al len de la lista)
                            (pElement) Si funciono correctamente
 *
 */
void* ll_get(LinkedList* this, int index)
{
    void* returnAux = NULL;
    Node* nPedido;

    if(this != NULL && index >= 0 && index < ll_len(this))
    {
        nPedido = getNode(this, index);
        if(nPedido->pElement != NULL)
        {
            returnAux = nPedido->pElement;
        }
    }

    return returnAux;
}


/** \brief Modifica un elemento de la lista
 *
 * \param this LinkedList* Puntero a la lista
 * \param nodeIndex int Ubicacion del elemento a modificar
 * \param pElement void* Puntero al nuevo elemento
 * \return int Retorna  (-1) Error: si el puntero a la lista es NULL o (si el indice es menor a 0 o mayor al len de la lista)
                        ( 0) Si funciono correctamente
 *
 */
int ll_set(LinkedList* this, int index,void* pElement)
{
    int returnAux = -1;
    Node* actual;
    if(this != NULL && index >= 0 && index < ll_len(this))
    {
        actual=getNode(this, index);
        actual->pElement = pElement;
        returnAux=0;
    }


    return returnAux;
}


/** \brief Elimina un elemento de la lista
 *
 * \param this LinkedList* Puntero a la lista
 * \param nodeIndex int Ubicacion del elemento a eliminar
 * \return int Retorna  (-1) Error: si el puntero a la lista es NULL o (si el indice es menor a 0 o mayor al len de la lista)
                        ( 0) Si funciono correctamente
 *
 */
int ll_remove(LinkedList* this,int index)
{
    int returnAux = -1;
    Node* actual;
    Node* next;
    Node* prev;
    if(this != NULL && index >= 0 && index < ll_len(this))
    {
        actual=getNode(this, index);
        if(index == 0)
        {
            this->pFirstNode = actual->pNextNode;
        }
        else
        {
            prev=getNode(this, index-1);
            next=actual->pNextNode;
            prev->pNextNode = next;
        }
        free(actual);
        this->size--;
        returnAux=0;
    }


    return returnAux;
}


/** \brief Elimina todos los elementos de la lista
 *
 * \param this LinkedList* Puntero a la lista
 * \return int Retorna  (-1) Error: si el puntero a la lista es NULL
                        ( 0) Si funciono correctamente
 *
 */
int ll_clear(LinkedList* this)
{
    int returnAux = -1;
    //Node* nodo;
    int i;
    int len;
    if(this != NULL)
    {
        len = ll_len(this);
        for(i=0; i<len; i++)
        {
            ll_remove(this, i);
        }
        returnAux=0;
    }


    return returnAux;
}


/** \brief Elimina todos los elementos de la lista y la lista
 *
 * \param this LinkedList* Puntero a la lista
 * \return int Retorna  (-1) Error: si el puntero a la lista es NULL
                        ( 0) Si funciono correctamente
 *
 */
int ll_deleteLinkedList(LinkedList* this)
{
    int returnAux = -1;
    if(this != NULL)
    {
        ll_clear(this);
        free(this);
        returnAux=0;
    }

    return returnAux;
}

/** \brief Busca el indice de la primer ocurrencia del elemento pasado como parametro
 *
 * \param this LinkedList* Puntero a la lista
 * \param pElement void* Puntero al elemento
 * \return int Retorna  (-1) Error: si el puntero a la lista es NULL
                        (indice del elemento) Si funciono correctamente
 *
 */
int ll_indexOf(LinkedList* this, void* pElement)
{
    int returnAux = -1;
    int i;
    //Node* nodo;
    int len;
    if(this != NULL)
    {
        len = ll_len(this);
        for(i=0; i<len; i++)
        {
            //nodo = getNode(this, i);
            if(ll_get(this, i) == pElement)
            {
                returnAux=i;
                break;
            }
        }
    }



    return returnAux;
}

/** \brief Indica si la lista esta o no vacia
 *
 * \param this LinkedList* Puntero a la lista
 * \return int Retorna  (-1) Error: si el puntero a la lista es NULL
                        ( 0) Si la lista NO esta vacia
                        ( 1) Si la lista esta vacia
 *
 */
int ll_isEmpty(LinkedList* this)
{
    int returnAux = -1;

    if(this != NULL)
    {
        if( ll_len(this))
        {
            returnAux = 0;
        }
        else
        {
            returnAux = 1;
        }
    }
    return returnAux;
}

/** \brief Inserta un nuevo elemento en la lista en la posicion indicada
 *
 * \param this LinkedList* Puntero a la lista
 * \param nodeIndex int Ubicacion donde se agregara el nuevo elemento
 * \param pElement void* Puntero al nuevo elemento
 * \return int Retorna  (-1) Error: si el puntero a la lista es NULL o (si el indice es menor a 0 o mayor al len de la lista)
                        ( 0) Si funciono correctamente
 *
 */
int ll_push(LinkedList* this, int index, void* pElement)
{
    int returnAux = -1;

    if(this != NULL && index >= 0 && index <= ll_len(this))
    {
        returnAux = addNode(this, index, pElement);
        //printf("push\n");
    }

    return returnAux;
}


/** \brief Elimina el elemento de la posicion indicada y retorna su puntero
 *
 * \param this LinkedList* Puntero a la lista
 * \param nodeIndex int Ubicacion del elemento eliminar
 * \return void* Retorna    (NULL) Error: si el puntero a la lista es NULL o (si el indice es menor a 0 o mayor al len de la lista)
                            (pElement) Si funciono correctamente
 *
 */
void* ll_pop(LinkedList* this,int index)
{
    void* returnAux = NULL;
    //Node* nodo;
    if(this != NULL && index >= 0 && index < ll_len(this))
    {
        //nodo = getNode(this, index);
        returnAux = ll_get(this, index);
        ll_remove(this, index);
    }


    return returnAux;
}


/** \brief  Determina si la lista contiene o no el elemento pasado como parametro
 *
 * \param this LinkedList* Puntero a la lista
 * \param pElement void* Puntero del elemento a verificar
 * \return int Retorna  (-1) Error: si el puntero a la lista es NULL
                        ( 1) Si contiene el elemento
                        ( 0) si No contiene el elemento
*/
int ll_contains(LinkedList* this, void* pElement)
{
    int returnAux = -1;

    if(this != NULL)
    {
        if(ll_indexOf(this, pElement) != -1)
        {
            returnAux=1;
        }
        else
        {
            returnAux=0;
        }
    }
    return returnAux;
}

/** \brief  Determina si todos los elementos de la lista (this2)
            estan contenidos en la lista (this)
 *
 * \param this LinkedList* Puntero a la lista
 * \param this2 LinkedList* Puntero a la lista
 * \return int Retorna  (-1) Error: si alguno de los punteros a las listas son NULL
                        ( 1) Si los elementos de (this2) estan contenidos en la lista (this)
                        ( 0) si los elementos de (this2) NO estan contenidos en la lista (this)
*/
int ll_containsAll(LinkedList* this,LinkedList* this2)
{
    int returnAux = -1;
    int i;
    int len2;
    Node* nodo;
    if(this != NULL && this2 != NULL)
    {
        returnAux=1;
        len2=ll_len(this2);
        for(i=0; i<len2; i++)
        {
            nodo=getNode(this2, i);
            if(!ll_contains(this, nodo->pElement))
            {
                returnAux=0;
                break;
            }
        }
    }


    return returnAux;
}

/** \brief Crea y retorna una nueva lista con los elementos indicados
 *
 * \param pList LinkedList* Puntero a la lista
 * \param from int Indice desde el cual se copian los elementos en la nueva lista
 * \param to int Indice hasta el cual se copian los elementos en la nueva lista (no incluido)
 * \return LinkedList* Retorna  (NULL) Error: si el puntero a la listas es NULL
                                o (si el indice from es menor a 0 o mayor al len de la lista)
                                o (si el indice to es menor o igual a from o mayor al len de la lista)
                         (puntero a la nueva lista) Si ok
*/
LinkedList* ll_subList(LinkedList* this,int from,int to)
{
    LinkedList* cloneArray = NULL;
    int i;
    void* pElement;
    if(this != NULL && from >= 0 && from < ll_len(this) && to >= 0 && to <= ll_len(this))
    {
        //printf("ll_sublist\n");
        cloneArray = ll_newLinkedList();
        for(i=from; i<to; i++)
        {
            pElement = ll_get(this, i);
            ll_add(cloneArray, pElement);
        }
    }


    return cloneArray;
}



/** \brief Crea y retorna una nueva lista con los elementos de la lista pasada como parametro
 *
 * \param pList LinkedList* Puntero a la lista
 * \return LinkedList* Retorna  (NULL) Error: si el puntero a la listas es NULL
                                (puntero a la nueva lista) Si ok
*/
LinkedList* ll_clone(LinkedList* this)
{
    LinkedList* cloneArray = NULL;
    if(this != NULL)
    {
        cloneArray = ll_subList(this, 0, ll_len(this));
    }


    return cloneArray;
}


/** \brief Ordena los elementos de la lista utilizando la funcion criterio recibida como parametro
 * \param pList LinkedList* Puntero a la lista
 * \param pFunc (*pFunc) Puntero a la funcion criterio
 * \param order int  [1] Indica orden ascendente - [0] Indica orden descendente
 * \return int Retorna  (-1) Error: si el puntero a la listas es NULL
                                ( 0) Si ok
 */
int ll_sort(LinkedList* this, int (*pFunc)(void*,void*), int order)
{
    int returnAux =-1;
    int len;
    int i;
    int j;
    void* pAux;
    //printf("ll_sort\n");
    if(this != NULL && pFunc != NULL && order <= 1 && order >= 0)
    {
        //printf("ll_sort entra al if\n");
        len = ll_len(this);
        if(order ==0)
        {
            //printf("ll_sort entra al primer tipo de ordenamiento\n");
            for(i=0; i-1<len; i++)
            {
                //printf(" iteracion i :%d\n", i);
                for(j=i+1; j<len; j++)
                {
                    //printf("\titeracion j :%d\n", j);
                    if(pFunc(ll_get(this, i), ll_get(this, j)) < 0)
                    {
                        //printf("\tswap\n");
                        pAux = ll_get(this, i);
                        ll_set(this, i, ll_get(this, j));
                        ll_set(this, j, pAux);
                    }
                }
            }
        }
        else
        {
            //printf("ll_sort entra al segundo tipo de ordenamiento\n");
            for(i=0; i-1<len; i++)
            {
                //printf(" iteracion i :%d\n", i);
                for(j=i+1; j<len; j++)
                {
                    //printf("\titeracion j :%d\n", j);
                    if(pFunc(ll_get(this, i), ll_get(this, j)) > 0)
                    {
                        //printf("\tswap\n");
                        pAux = ll_get(this, i);
                        ll_set(this, i, ll_get(this, j));
                        ll_set(this, j, pAux);
                    }
                }
            }
        }
        returnAux=0;
    }


    return returnAux;
}

int ll_count(LinkedList* this, int (*fn)(void* element))
{
    int count=0;
    int i;
    int len;
    if(this != NULL && fn != NULL)
    {
        len=ll_len(this);
        for(i=0; i<len; i++)
        {
            count+= fn(ll_get(this, i));
        }
    }
    return count;
}

LinkedList* ll_filter(LinkedList* this, int (*fn)(void* element))
{
    LinkedList* filterList=NULL;
    int i;
    int len;
    void* auxElement;

    if(this != NULL && fn != NULL)
    {
        len=ll_len(this);
        filterList=ll_newLinkedList();
        for(i=0; i<len; i++)
        {
            auxElement=ll_get(this, i);
            if(fn(auxElement))
            {
                ll_add(filterList, auxElement);
            }
        }
    }

    return filterList;
}

LinkedList* ll_filterParametros(LinkedList* this, int (*fn)(void* element, char* cadena), char* parmCadena)
{
    LinkedList* filterList=NULL;
    int i;
    int len;
    void* auxElement;

    if(this != NULL && fn != NULL && parmCadena != NULL)
    {
        len=ll_len(this);
        filterList=ll_newLinkedList();
        for(i=0; i<len; i++)
        {
            auxElement=ll_get(this, i);
            if(fn(auxElement, parmCadena))
            {
                ll_add(filterList, auxElement);
            }
        }
    }
    return filterList;
}