Untitled

#include "slist.h"
#include <stdlib.h>

SList slist_crear() {
  return NULL;
}

void slist_destruir(SList lista) {
  SNodo *nodoAEliminar;
  while (lista != NULL) {
    nodoAEliminar = lista;
    lista = lista->sig;
    free(nodoAEliminar);
  }
}

int slist_vacia(SList lista) {
  return lista == NULL;
}

SList slist_agregar_final(SList lista, int dato) {
  SNodo *nuevoNodo = malloc(sizeof(SNodo));
  nuevoNodo->dato = dato;
  nuevoNodo->sig = NULL;

  if (lista == NULL)
    return nuevoNodo;

  SList nodo = lista;
  for (;nodo->sig != NULL;nodo = nodo->sig);
  /* ahora 'nodo' apunta al ultimo elemento en la lista */

  nodo->sig = nuevoNodo;
  return lista;
}

SList slist_agregar_inicio(SList lista, int dato) {
  SNodo *nuevoNodo = malloc(sizeof(SNodo));
  nuevoNodo->dato = dato;
  nuevoNodo->sig = lista;
  return nuevoNodo;
}

void slist_recorrer(SList lista, FuncionVisitante visit) {
  for (SNodo *nodo = lista; nodo != NULL; nodo = nodo->sig)
    visit(nodo->dato);
}

size_t slist_longitud(SList lista){
  if (lista==NULL){
    return 0;
  }

  int longitud = 0;
  for(; lista->sig != NULL; lista = lista->sig, longitud++);

  return longitud;
}

SList* slist_concatenar(SList* lista1, SList* lista2){
  SNodo *nodoAux; //SList *nodoAux;

  if(lista1==NULL){
    lista1 = lista2;
  }
  else {
    if (lista2 != NULL){
      nodoAux = *lista1;
      for(;nodoAux->sig != NULL; nodoAux=nodoAux->sig); 
      nodoAux->sig = *lista2;
    }

  }

  return lista1;

}

void slist_insertar(SList* lista, int dato, int pos){
  int longitudLista = slist_longitud(*lista);
  if (pos>longitudLista){
    return;
  }

  SNodo *nodoAux;
  int posActual = 0;
  int nuevaLongitud = longitudLista + 1;
  lista = realloc(lista,sizeof(SNodo) * nuevaLongitud);

  nodoAux = *lista;
  for(; posActual <= pos; nodoAux=nodoAux->sig);
  
  int datoAux = nodoAux->dato;
  nodoAux->dato = dato;

  for(nodoAux=nodoAux->sig; nodoAux->sig->sig!= NULL; nodoAux=nodoAux->sig){
    nodoAux->sig=nodoAux;
  }

}

void slist_eliminar(SList* lista, int pos){
  SNodo *nodoAnterior = *lista;

  for(int posLista = 1; posLista < pos -1; posLista++,nodoAnterior=nodoAnterior->sig);

  SNodo *nodoEnPos = nodoAnterior->sig;
  SNodo *nodoSiguiente = nodoEnPos->sig;

  nodoAnterior->sig = nodoSiguiente;

  free(nodoEnPos);
}


int slist_contiene(SList lista, int elemento){
  if(lista == NULL){
    return 0;                               
  }
  
  SNodo *nodoAnalizar = lista;

  for(;nodoAnalizar->sig!=NULL && nodoAnalizar->dato!=elemento ;nodoAnalizar=nodoAnalizar->sig);
  return (nodoAnalizar->dato == elemento);

}

int slist_indice(SList lista, int elemento){
  int posicion;
  for(posicion = 1;lista->sig!=NULL && lista->dato!= elemento; posicion++, lista=lista->sig);

  if(lista->dato!=elemento){
    return -1;
  }

  return posicion;

}




SList slist_intersecar(SList lista1,SList lista2){
  if(lista1==NULL || lista2 == NULL){
    return lista1;
  }

  SList listaElementos = slist_crear();



  for(;lista1!=NULL;lista1=lista1->sig){

    if(slist_contiene(lista2,lista1->dato) && !slist_contiene(listaElementos,lista1->dato)){
      listaElementos = slist_agregar_inicio(listaElementos,lista1->dato);    //¿Qué pasa si se repiten los elementos? 
    }

  }

  return listaElementos;

}



int slist_contiene_custom(SList lista, int elemento,FuncionComparacion fComparacion){
  if(lista == NULL){
    return 0;                               
  }
  
  SNodo *nodoAnalizar = lista;
  
  for(;nodoAnalizar->sig!=NULL && fComparacion(&(nodoAnalizar->dato),&elemento)!=0;nodoAnalizar=nodoAnalizar->sig);
  return (fComparacion(&(nodoAnalizar->dato),&elemento)==0);

}



/* 
fComparación devuelve
1: dato1>dato2
0: dato1==dato2
-1: dato1<dato2 
*/

SList slist_intersecar_custom(SList lista1, SList lista2, FuncionComparacion fComparacion){

  if(lista1==NULL || lista2 == NULL){
    return lista1;
  }

  SList listaElementos = slist_crear();

  for(;lista1!=NULL;lista1=lista1->sig){
    if(slist_contiene_custom(lista2,lista1->dato,(*fComparacion)) && !slist_contiene_custom(listaElementos,lista1->dato,(*fComparacion))){
      listaElementos = slist_agregar_inicio(listaElementos,lista1->dato);    //¿Qué pasa si se repiten los elementos? 
    }

  }

  return listaElementos;

}


void slist_ordenar(SList* lista, FuncionComparacion fComparacion){
  
  if(*lista==NULL){
    return;
  }

  int longitudLista = slist_longitud(lista), posFinalOrdenado;
  SNodo* nodoAux = *lista;
  SNodo* siguienteNodo = NULL;
  void *temp = NULL;

  for(int iterExternas = 1;nodoAux!=NULL;nodoAux=nodoAux->sig,iterExternas++){
    posFinalOrdenado = longitudLista - iterExternas;
    siguienteNodo = nodoAux->sig;
    for(int iterInternas = 1; iterInternas < posFinalOrdenado;siguienteNodo=siguienteNodo->sig,iterInternas++){

      if(fComparacion(&(nodoAux->dato),&(siguienteNodo->dato)) == 1){ //es decir, si el dato en pos n es mayor al dato en pos n+1
        temp = &(nodoAux->dato);
        nodoAux->dato=siguienteNodo->dato;
        siguienteNodo->dato = temp;
      }

    }
  }

}



/*


SList slist_reverso(SList lista);

SList slist_intercalar(SList lista1, SList lista2);

SList slist_partir(SList lista);
 */