Listas Dobles con Funciones

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

/***************************** PARTE SOLO PARA LAS FICHAS QUE SE METERÁN EN LA LISTA *****************fichas.h*****************/
#define TAM_NOMBRE 50
typedef struct datos_de_ficha       // Renombra el tipo de dato compuesto "struct datos_de_ficha" a "FICHA"
{                                   // FICHA es un tipo de dato ahora, como int, float o char
    int edad;                       // se usará para declarar variables de tipo compuesto FICHA
    float peso;
    char nombre[TAM_NOMBRE];
}FICHA;

void llenar_ficha(FICHA *n_ficha)   // Llena los datos de la ficha, recibe un apuntador a la dirección de la variable
{
    int i;

    n_ficha->edad = rand() % 101;   // Como es un apuntador, se usa el operador flecha -> para acceder a un dato
    n_ficha->peso = rand() % 300;

    for (i = 0; i < rand() % TAM_NOMBRE - 1; i++)   // Si i es menor a un numero aleatorio menor que TAM_NOMBRE-1
        n_ficha->nombre[i] = 'a' + rand() % ('z' - 'a' + 1);    // Llena caracter por caracter de un rango de a hasta z
    n_ficha->nombre[i] = '\0';  //i termina con el valor aleatorio máximo y en esa ultima posición pone fin a la cadena
}

void imprimir_ficha(FICHA ficha)
{
    puts("Datos de la ficha");
    printf("NOMBRE: \t"); puts(ficha.nombre);
    printf("EDAD:   \t%d \n", ficha.edad);
    printf("PESO:   \t%.2f \n\n", ficha.peso);
}

/******************************** PARTE SOLO PARA LISTA  Y SUS FUNCIONES **********************************lista.h*************/

//listas.h
/* CODIGOS DE ERROR
*   -1 : No se pudo obtener la memoria para crear un nuevo nodo
*   -2 : Posición inválida, la posición dada es menor que cero o mayor que el tamaño de la lista
*   -3 : Posiciones iguales, no se puede hacer intercambio de nodos con la misma posición
*   -4 : La lista no se elimina porque está vacía o no existe
*   -5 : Error: opción no válida, al seleccionar comparación
**/
//#pragma once
//#include "fichas.h"



typedef struct elemento_de_lista        // Declara un tipo de dato compuesto para que sea un elemento de una lista
{                                   // y lo renombra como NODO
    FICHA datos;        // Es una variable de tipo FICHA, por lo que puede guardar edad, peso, etc.
    elemento_de_lista *ANT, *SIG;   // Son apuntadores al tipo de dato NODO, por lo que pueden guardar la
    int pos;                                // dirección de un NODO de la lista, en este caso el NODO anterior y siguiente.
}NODO;

struct LISTA {      // Esta estructura que llamaremos LISTA apuntará a 2 direcciones de variables NODO
    NODO *inicio;   // para poder tener mas control y saber donde empieza o acaba la lista así como su tamaño
    NODO *fin;
    int tam;
};

void inicializar_lista(LISTA *lista)        // Función para preparar la lista antes de usarla
{
    lista->tam = 0; // Indica que la lista no tiene elementos
    lista->inicio = NULL;   // Como no tiene elementos no tiene inicio ni fin, ambos son nulos
    lista->fin = NULL;

}

NODO* crear_nodo()      // Función que genera un elemento de lista que se unirá después
{
    /* Declara una variable que apunta a un tipo NODO, como no sabemos que tamaño tendrá "pide" -malloc()- espacio    *
     * y el tamaño que pide es el que ocupa una variable NODO -sizeof(NODO)- y ese espacio que se asigna se            *
     * convierte en espacio para variables del tipo apuntador a NODO -(NODO*)-                                      */
    NODO *nuevo_nodo = (NODO*)malloc(sizeof(NODO));
    FICHA nueva_ficha;      // Genera una variable tipo ficha

    llenar_ficha(&nueva_ficha); // llenamos los datos de la ficha
    nuevo_nodo->datos = nueva_ficha;        // copiamos los datos de la variable al elemento de la lista que creamos
    return nuevo_nodo;  // regresa la dirección del elemento de la lista, para poder manipularlo después
}

/* Esta función enumera cada elemento de la lista, desde 1 hasta el tamaño actual de la lista (lista->tam)        */
void asignar_pos(LISTA *lista)
{
    NODO *nodo = crear_nodo();  // creamos un apuntador a NODO, que nos ayudará a recorrer la lista
    int i = 1;
    nodo = lista->inicio;   // apuntamos el nodo al primer elemento de la lista para recorrerla

    /*recorre la lista hasta el ultimo elemento (que es el que su SIG apunta a NULL)*/
    while (nodo != NULL)
    {
        nodo->pos = i;  // asigna el valor de posición, desde 1
        nodo = nodo->SIG;
        i++;
    }
}

int insertar_en_lista_vacia(LISTA *lista)
{
    NODO *nuevo_nodo;
    nuevo_nodo = crear_nodo(); // creamos un nuevo nodo, con los datos ya guardados
    if (nuevo_nodo == NULL) // si al crear el nodo, este vale NULL significa que hubo un error y no pudo
        return -1;          // obtener la memoria que "pidió"

    nuevo_nodo->SIG = NULL; // como será el unico elemento en la lista, no apunta a ningun elemento antes o después
    nuevo_nodo->ANT = NULL;
    nuevo_nodo->pos = 1;

    lista->inicio = nuevo_nodo; // decimos que la lista empieza con el nuevo_nodo y termina en nuevo_nodo
    lista->fin = nuevo_nodo;        // es decir, solo tiene un elemento. Aumentamos el tamaño de la lista
    lista->tam++;

    return 0;
}

int insertar_inicio(LISTA *lista)   // caso donde agregamos un elemento al inicio de la lista
{
    NODO *nuevo_nodo;
    int i = 1;
    nuevo_nodo = crear_nodo();
    if (nuevo_nodo == NULL)
        return -1;

    /* Como este nuevo nodo estará al principio, no apuntará a ninguno anterior pero si apuntará a uno siguiente.    *
     * El elemento que le siguie al nuevo nodo es el que antes estaba al principio, por eso nuevo->SIG=lista->inicio */
    nuevo_nodo->ANT = NULL;
    nuevo_nodo->SIG = lista->inicio;

    /* El que antes estaba al inicio (lista->inicio) ahora tiene un elemento antes de el, que es el nuevo nodo,  *
     * entonces decimos que el que antes estaba al inicio apunte al nuevo nodo*/
    lista->inicio->ANT = nuevo_nodo;

    lista->inicio = nuevo_nodo; // El que está al inicio ahora es el nuevo nodo y el tamaño de la lista aumenta en 1
    lista->tam++;

    asignar_pos(lista); // se le asigna una posición a cada elemento de la lista
    return 0;
}

int insertar_final(LISTA *lista)
{
    NODO *nuevo_nodo;
    int i = 1;

    nuevo_nodo = crear_nodo();
    if (nuevo_nodo == NULL)
        return -1;

    /* En el caso de insertar al final, el nuevo nodo será el ultimo elemento en la lista, entonces no apuntará  *
     * a ningun elemento siguiente*/
    nuevo_nodo->SIG = NULL;
    nuevo_nodo->ANT = lista->fin; // el nuevo nodo tiene ahora uno antes, que es el que antes estaba al final
    lista->fin->SIG = nuevo_nodo; // El elemento que estaba antes al final ahora tiene un elemento después



    lista->fin = nuevo_nodo; // decimos que ahora el ultimo elemento es el nuevo nodo y aumentamos el tamaño de la lista
    lista->tam++;

    asignar_pos(lista); // numeramos los elementos

    return 0;
}

int insertar_en_posicion(LISTA *lista, int pos) // Inserta un elemento en la posición que se le pida
{
    if (pos < 1 || pos > lista->tam + 1)
        return -2;//inserta siempre y cuando la posición sea mayor que 0 y menor que el tamaño de la lista
    if (pos == 1) // si la posición pedida es 1, significa que inserta al inicio
    {
        insertar_inicio(lista);
        return 0;
    }
    if (pos == lista->tam + 1) // si la posición es el tamaño de la lista + 1 significia que inserta al final
    {
        insertar_final(lista);
        return 0;
    }

    NODO *nuevo, *otro;     // crea un nuevo nodo para insertar y otro para recorrer la lista

    nuevo = crear_nodo();
    if (nuevo == NULL)
        return -1;

    otro = lista->inicio;   // el otro apunta al inicio y recorre la lista hasta la posición deseada
    while (otro->pos != pos)
        otro = otro->SIG;

    /* Ya teniendo la posición donde se insertará, el nuevo nodo apuntará a donde antes apuntaba el otro nodo *
     * ya que este nuevo ocupara su lugar */
    nuevo->ANT = otro->ANT;
    nuevo->SIG = otro;
    otro->ANT->SIG = nuevo; // aqui se le dice al elemento anterior al otro, que ahora tiene un nodo al frente
    otro->ANT = nuevo;      // ese nodo es el nuevo, luego le dice al otro nodo que el que esta antes de el es
    lista->tam++;           // el nuevo nodo. la lista aumenta de tamaño

    asignar_pos(lista);



    return 0;
}

int eliminar_nodo(LISTA *lista, int pos)
{
    NODO *byebye;
    if (pos <1 || pos > lista->tam)
        return -2;

    byebye = lista->inicio;
    if (lista->tam == 1)
    {
        inicializar_lista(lista);
        free(byebye);
        return 0;
    }
    while (byebye->pos != pos)
        byebye = byebye->SIG;

    if (pos == 1)
    {
        lista->inicio = byebye->SIG;
        byebye->SIG->ANT = NULL;
    }

    else if (pos == lista->tam)
    {
        lista->fin = byebye->ANT;
        byebye->ANT->SIG = NULL;
    }

    else
    {
        byebye->ANT->SIG = byebye->SIG;
        byebye->SIG->ANT = byebye->ANT;
    }
    //free(&byebye->datos);
    free(byebye);
    lista->tam--;
    asignar_pos(lista);

    return 0;
}

int intercambio(LISTA *lista, int pos1, int pos2)
{
    NODO *a, *b;
    int x = 0;

    if (pos1 == pos2)
        return -3;
    else if (pos1<1 || pos2<1 || pos1>lista->tam || pos2>lista->tam)
        return -2;

    else if (pos1 > pos2)
    {
        x = pos1;
        pos1 = pos2;
        pos2 = x;
    }

    a = lista->inicio;
    b = lista->inicio;
    while (a->pos != pos1)
        a = a->SIG;
    while (b->pos != pos2)
        b = b->SIG;

    if (pos1 == 1)
    {
        b->ANT = NULL;
        a->ANT = b;
        a->SIG = b->SIG;
        b->SIG->ANT = a;
        b->SIG = a;
        lista->inicio = b;
    }

    else if (pos2 == lista->tam)
    {
        b->ANT = a->ANT;
        a->ANT = b;
        a->SIG = NULL;
        b->ANT->SIG = b;
        b->SIG = a;
        lista->fin = a;
    }

    else
    {
        b->ANT = a->ANT;
        a->ANT = b;
        a->SIG = b->SIG;
        b->SIG->ANT = a;
        b->SIG = a;
        b->ANT->SIG = b;
    }
    asignar_pos(lista);
    return 0;
}
void imprimir_lista(LISTA *lista)
{
    NODO *actual = lista->inicio; // crea un nodo que recorrerá la lista, comienza desde el inicio de la lista
    while (actual != NULL)
    {
        printf("FICHA # %d\n", actual->pos);
        imprimir_ficha(actual->datos);
        actual = actual->SIG;
    }
}

int comparar_dato(int opc, FICHA *ficha1, FICHA *ficha2)
{
    switch (opc)
    {
    case 1: // Comparar edad
        if (ficha1->edad > ficha2->edad)
            return 1;
        else if (ficha1->edad < ficha2->edad)
            return -1;
        else return 0;
        break;
    case 2: // Comparar peso
        if (ficha1->peso > ficha2->peso)
            return 1;
        else if (ficha1->peso < ficha2->peso)
            return -1;
        else return 0;
        break;
    case 3: // Comparar nombre
    {
        char *pcad1 = ficha1->nombre, *pcad2 = ficha2->nombre;
        while (*pcad1 != '\0' && *pcad2 != '\0')
        {
            if (*pcad1 < *pcad2)return -1;
            if (*pcad1 > *pcad2)return  1;
            pcad1++; pcad2++;
        }
        if (*pcad1 < *pcad2)return -1;
        if (*pcad1 > *pcad2)return  1;
        return 0;
    break;
    }
    default:
        return -5; // Error: opción no válida para comparar
        break;
}
}

int ordenar_lista_nombre(LISTA *lista)
{
    bool desorden = false;
    NODO *nodo;

    do
    {
        desorden = false;
        nodo = lista->inicio;
        while (nodo != NULL && nodo->SIG != NULL)
        {
            if (1 == comparar_dato(3, &nodo->datos,&nodo->SIG->datos))
            {
                desorden = true;
                //intercambio
                intercambio(lista, nodo->pos, nodo->SIG->pos);
            }
            else nodo = nodo->SIG;

        }
    } while (desorden);
    return 0;
}

int eliminar_lista(LISTA *lista)
{
    if (lista == NULL)
        return -4;
    while (lista->tam != 0)
        eliminar_nodo(lista, 1);
    return 0;
}

/*************************************** PROGRAMA PRINCIPAL MAIN ************************************************************/


int main()
{
    LISTA lista;
    int error = 0;

    inicializar_lista(&lista);
    error = insertar_en_lista_vacia(&lista);
    imprimir_lista(&lista);
    printf("\nLISTA CON INSERCION AL INICIO\n");
    error = insertar_inicio(&lista);
    imprimir_lista(&lista);
    printf("\nLISTA CON INSERCION AL FINAL\n");
    error = insertar_final(&lista);
    imprimir_lista(&lista);
    printf("\nLISTA INSERTANDO EN POSICION 2\n");
    error = insertar_en_posicion(&lista, 2);
    imprimir_lista(&lista);
    printf("\nLISTA INSERTANDO EN POSICION 5\n");
    error = insertar_en_posicion(&lista, 5);
    imprimir_lista(&lista);
    printf("\nINTERCAMBIAR ELEMENTOS 2 Y 3\n");
    error = intercambio(&lista, 2, 3);
    imprimir_lista(&lista);
    printf("\nLISTA ELIMINANDO EN POSICION 3\n");
    error = eliminar_nodo(&lista, 3);
    imprimir_lista(&lista);
    puts("EN ORDEN");
    ordenar_lista_nombre(&lista);
    imprimir_lista(&lista);
    eliminar_lista(&lista);
    return 0;
}