Gestión de Datos Estelares en C: Arrays y Listas Enlazadas

Introducción a la Gestión de Datos Estelares en C

Este documento presenta dos enfoques fundamentales para la gestión de datos de objetos estelares en el lenguaje de programación C: la utilización de arrays estáticos y la implementación mediante listas enlazadas. Ambos métodos permiten almacenar y manipular información sobre estrellas, como su nombre, galaxia, número de planetas y la posibilidad de vida.

A continuación, se detallan las estructuras de datos y las funciones básicas (mostrar e insertar) para cada una de estas implementaciones, proporcionando una visión práctica de cómo se pueden aplicar diferentes estructuras de datos para resolver problemas de almacenamiento y recuperación de información.

Implementación con Array Estático

Esta sección describe la gestión de datos estelares utilizando un array estático. Este método es sencillo de implementar para un número fijo de elementos, pero su tamaño es predefinido y no puede cambiar dinámicamente durante la ejecución del programa.

Estructura de Datos del Array

La estructura listado contiene un array de T_estrella (asumiendo que T_estrella es una estructura definida previamente con campos como nombre, galaxia, planetas y vida) y un cursor para llevar el control del número de elementos insertados.

struct listado {
    struct T_estrella vector[100];
    int cursor;
};
struct listado lista;

Función para Mostrar Estrellas (Array)

La función Mostrar_estrella() recorre el array y muestra la información de cada estrella registrada. Verifica si hay estrellas antes de intentar mostrarlas.

void Mostrar_estrella()
{
    system ("cls");
    if (lista.cursor==0)
    {
        printf("No hay estrellas registradas en la lista.\n");
    } else{
        for (int i=0; i < lista.cursor; i++)
        {
            printf("Nombre de la estrella: %s\n", lista.vector[i].nombre);
            printf("Posibilidad de vida: %s\n", lista.vector[i].vida ? "Si": "No");
        }
    }
    system ("pause");
}

Función para Insertar Estrellas (Array)

La función Insertar_estrella() permite al usuario introducir los datos de una nueva estrella y añadirla al array. Incluye validación para la entrada de la posibilidad de vida.

void Insertar_estrella()
{
    int opcion;
    system("cls");
    printf("Inserte el nombre de una estrella: ");
    fflush(stdin);
    gets(lista.vector[lista.cursor].nombre);
    printf("Inserte el nombre de la galaxia: ");
    fflush(stdin);
    gets(lista.vector[lista.cursor].galaxia);
    printf("Inserte el numero de planetas de la estrella: ");
    scanf("%d", &lista.vector[lista.cursor].planetas);
    do {
      printf("¿Hay posibilidad de vida? (1-SÍ o 0-NO): ");
      scanf("%d", &opcion);
      if (opcion == 1)
        {
            lista.vector[lista.cursor].vida = 1;  // vida si
        } else if (opcion == 0) {
            lista.vector[lista.cursor].vida = 0;  //  vida (no)
        } else {
            printf("Opción no válida.\n");
        }
      if (opcion !=0 && opcion !=1)
      {
          printf("Opción no válida, introduzca 1 para SÍ o 0 para NO.\n");
      }
    } while(opcion !=0 && opcion !=1);
    lista.cursor++;
    printf("La estrella se ha insertado.\n");
    system ("pause");
}

Implementación con Lista Enlazada

Esta sección explora la gestión de datos estelares utilizando una lista enlazada. A diferencia de los arrays, las listas enlazadas ofrecen una flexibilidad superior para el manejo dinámico de la memoria, permitiendo añadir o eliminar elementos sin restricciones de tamaño predefinido.

Estructura de Datos de la Lista Enlazada

La estructura nodo representa un elemento en la lista, conteniendo los datos de una estrella y un puntero al siguiente nodo. Se utilizan punteros para gestionar la cabecera, el auxiliar, el nuevo nodo y el final de la lista.

struct nodo {
    struct T_estrella datos;
    struct nodo *sig;
};
struct nodo *cabecera, *aux, *nuevo, *fin;

Función para Mostrar Estrellas (Lista Enlazada)

La función mostrar() recorre la lista enlazada desde la cabecera hasta el final, imprimiendo la información de cada estrella. Maneja el caso de una lista vacía.

void mostrar()
{
    system ("cls");
    if (cabecera == NULL)
    {
        printf("La lista está vacía.\n");
        system ("pause");
    } else {
        aux= cabecera;
        while (aux != NULL) {
        printf("Nombre de la estrella: %s\n", aux>datos.nombre);
        printf("Posibilidad de vida: %s\n\n", aux->datos.vida ? "Si" : "No");
        aux = aux -> sig;
        }
    }
    system ("pause");
};

Función para Insertar Estrellas (Lista Enlazada)

La función insertar() crea un nuevo nodo, asigna memoria dinámicamente y lo añade al final de la lista enlazada. También incluye validación para la entrada de datos.

void insertar()
{
    system ("cls");
    nuevo= malloc(sizeof(struct nodo));
    int opcion;
    nuevo->sig == NULL;
      if (cabecera == NULL)
    {
        cabecera = nuevo;
        fin= nuevo;
    }
    else{
        fin ->sig = nuevo;
        fin = nuevo;
    }
    if (nuevo == NULL) {
        printf("Error al asignar memoria.\n");
        return;
    } else {
        printf("Introduce el nombre de la estrella: ");
        fflush(stdin);
        gets(nuevo->datos.nombre);
        printf("Introduce el nombre de la galaxia: ");
        gets(nuevo->datos.galaxia);
        printf("Introduce el numero de planetas: ");
        scanf("%d", &nuevo -> datos.planetas);
        do {
            printf("¿Hay posibilidad de vida? (1-SÍ o 0-NO): ");
            scanf("%d", &opcion);
            if (opcion == 1) {
                nuevo->datos.vida = 1;  // vida si
            } else if (opcion == 0) {
                nuevo->datos.vida = 0;  //  vida no
            } else {
                printf("Opción no válida.\n");
            }
            if (opcion != 0 && opcion != 1) {
                printf("Opción no válida, introduzca 1 para SÍ o 0 para NO.\n");
            }
        } while (opcion != 0 && opcion != 1);
    }
}

Consideraciones Adicionales y Mejores Prácticas

Al trabajar con el código C proporcionado, es importante tener en cuenta algunas consideraciones para mejorar la seguridad, la robustez y la portabilidad:

• Uso de fflush(stdin) y gets(): Se recomienda evitar el uso de fflush(stdin), ya que su comportamiento es indefinido según el estándar C. De igual manera, la función gets() es altamente insegura debido a su incapacidad para prevenir desbordamientos de búfer. Para la entrada de cadenas, es preferible utilizar fgets(), que permite especificar un tamaño máximo de lectura, o scanf con especificadores de ancho.
• Funciones de Sistema Operativo: Las llamadas a system("cls") y system("pause") son específicas de sistemas operativos como Windows. Para desarrollar aplicaciones más portables, se pueden buscar alternativas que no dependan del sistema operativo o encapsular estas llamadas dentro de directivas de preprocesador (#ifdef _WIN32, #else).
• Manejo de Errores de Memoria: Aunque la función insertar() incluye una verificación básica de malloc, un manejo de errores más robusto implicaría notificar al usuario y posiblemente intentar recuperar la operación o salir de forma controlada.
• Consistencia en la Nomenclatura: Se observa una mezcla de nombres de funciones en camelCase (Mostrar_estrella, Insertar_estrella) y lowercase (mostrar, insertar). Mantener una convención de nomenclatura consistente mejora la legibilidad del código.