estructura en listas simples

javier2101 · #1 (**permalink**) 23/10/2011, 12:04

Cordial saludo venia a molestarlos por acá, ya que he investigado y no he podido dar con este problema: tengo una lista simple que recibe un valor int, lo muestra y lo puede eliminar, pero me piden que muestre cuatro valores osea una estructura. he declarado la estructura, lo que no se es como hago para poder mostrar los datos de la estructura en la lista. A continuación pongo el código

Código:

#include <iostream.h>
#include <conio.h>
#include <stdlib.h>

typedef int tipo;

                 struct estudiante
                         {   char nombre[50];
                             char apellido[50];
                             char telefono[50];
                             char edad[50];
                         } ;
                         
                 struct nodo{              //esta es la estructura del nodo
                 tipo s_dato;
                 nodo* s_sig;
                 };

void crear(nodo**);
void insertar(nodo**, tipo);
void quitar(nodo**, tipo);
void recorrer(nodo**);
int buscar();

int  main()
{
nodo* cabeza;
int dat;
int dato;
char op;

struct estudiante x; 
crear(&cabeza);
system("pause");

df:                               //tambien se puede hacer con do while
cout << "1.-INSERTAR" << endl;
cout << "2.-VER" << endl;
cout << "3.-QUITAR" << endl;
op = getch();
switch(op)
{
case '1':
cout << "introduce un nombre: ";
scanf("%d",&x->nombre);
cout << "introduce un apellido: ";
scanf("%d",&x->apellido);
cout << "introduce un telefono: ";
scanf("%d",&x->telefono);
cout << "introduce un edad: ";
scanf("%d",&x->edad);


insertar(&cabeza, dat);

system("pause");
goto df;

case '2':
recorrer(&cabeza);
system("pause");
goto df;

case '3':
cout << "introduzca dato a quitar";
cin >> dato;
quitar(&cabeza,dato);
goto df;

}
}

        void crear(nodo** siguiente)
        {
        *siguiente = NULL;
        }

           void insertar(nodo**siguiente, tipo dato)
           {
           struct estudiante *x; 
           nodo* aux;
           x=s_sig= NUll;
           aux = estudiante;
           aux->s_dato = dato;
           aux->s_sig = (*siguiente);
           *siguiente = aux;
           }

           void quitar(nodo**siguiente, tipo dato)
           {
           nodo* ptr,*ant;
           ptr = *siguiente;
           ant = NULL;
           while (ptr!= NULL && ptr->s_dato!=dato)
           {
           ant = ptr;
           ptr = ptr->s_sig;

           }
           if ( ptr->s_dato!=dato)
           {
           cout << "dato no existe";
           }

           else
           ant->s_sig = ptr->s_sig;
           delete ptr;
           }


       void recorrer(nodo**siguiente)
       {
       nodo* ptr;
       ptr = *siguiente;
       while (ptr!= NULL)
       {
       cout << ptr->s_dato << endl;       // aqui es donde necesito mostrar la estructura

       ptr=ptr->s_sig;
       }

}

vladimirgude · #2 (**permalink**) 23/10/2011, 20:43

Saludos javier, a continuación el código completo de tu programa de lista simple dinamica, con la estructutura. El código está en C realizado en Dev-C++

Código C:

Ver original#include <stdio.h>
#include <stdlib.h>
 
/*Definicion de Tipo para elementos*/
typedef struct nodo_estudiante {
    char nombre[50];
    char apellido[50];
    char telefono[50];
    int edad;
} tipo_info;
 
/*Definicion de Tipo para una Lista*/
typedef struct nodo_Lista {
    tipo_info info;
    struct    nodo_Lista *next;
} tipo_Nodo;
 
void nuevaLista (tipo_Nodo **lista);
tipo_Nodo *getNode (tipo_info elemento);
int listaVacia (tipo_Nodo *lista);
tipo_Nodo *insertarPrimero (tipo_Nodo **lista, tipo_info elemento);
void mostrarLista (tipo_Nodo *lista);
int eliminarNodo (tipo_Nodo **lista, tipo_Nodo *nodo);
tipo_Nodo *buscar (tipo_Nodo *lista, tipo_info elemento);
 
int main(){
   tipo_Nodo *lista, *p, *nodo;
   int opcion, eliminado;
   tipo_info elemento;
   
   nuevaLista (&lista);       /*Inicializar lista*/
   do
   {
     printf("Menu de Opciones:\n");
     printf("1-Insertar un elemento Primero en la lista.\n");
     printf("2-Ver elementos en la lista.\n");
     printf("3-Eliminar un elemento de la lista.\n");
     printf("4-Salir.\n");
     printf("\nIntroduzca su opcion: ");
     scanf("%d", &opcion);
     if (opcion == 1)     /*opcion 1: Insertar Primero en lista*/
        {
         printf("Ingrese el nombre: ");
         scanf ("%s", &elemento.nombre);
         printf("Ingrese el apellido: ");
         scanf ("%s", &elemento.apellido);
         printf("Ingrese el telefono: ");
         scanf ("%s", &elemento.telefono);
         printf("Ingrese la edad: ");
         scanf ("%d", &elemento.edad);
         /*Insertar elemento de Primero*/
         p = insertarPrimero (&lista, elemento);
         if (p == NULL)
            printf("\nNO se puede insertar (NO hay memoria disponible).\n");
         else
            printf("\nElemento insertado de Primero...\n");
         system("pause");
        }
     if (opcion == 2)     /*opcion 2: Ver elementos en lista*/
        {
         printf("Reporte de elementos en la lista:\n");
         if (listaVacia (lista))
            printf("NO hay elementos en la lista.\n");
         else
            mostrarLista (lista);
         system("pause");
        }
     if (opcion == 3)     /*opcion 3: Eliminar un elemento de lista*/
        {
         printf("Ingrese el nombre a eliminar: \n");
         scanf ("%s", &elemento.nombre);
         /*Buscar elemento*/
         nodo = buscar (lista, elemento);
         /*Eliminar nodo*/
         eliminado = eliminarNodo (&lista, nodo);
         if (eliminado == -1)
            {
             printf("\nElemento %s NO se encuentra en la lista.", elemento.nombre);
             printf("\nNO se puede eliminar.\n");
            }
         else
            printf("\nElemento %s eliminado...\n", elemento.nombre);
         system("pause");
        }
   }while (opcion != 4);
   return 0;
}
 
void nuevaLista (tipo_Nodo **lista){
   *lista = NULL;
}
 
tipo_Nodo *getNode (tipo_info elemento){
   tipo_Nodo *p;
   /*Asigna memoria dinamicamente para un solo nodo*/
   p = (tipo_Nodo *) malloc(sizeof(tipo_Nodo));
   if (p != NULL)         /*Si obtuvo un nodo (p) de la memoria...*/
      {
       p->info = elemento;     /*guarda elemento en info*/
       p->next = NULL;         /*next apunta a NULL*/
      }
   return p;
}
 
int listaVacia (tipo_Nodo *lista){
   if (lista == NULL)
      return (1);          /*retorna 1 (Exito). Lista vacia*/
   else
      return (0);          /*retorna 0 (Error). Lista no vacia*/
}
 
tipo_Nodo *insertarPrimero (tipo_Nodo **lista, tipo_info elemento){
   tipo_Nodo *p;
   p = getNode(elemento);         /*obtiene un nuevo nodo*/
   if (p != NULL)                 /*Si obtuvo un nodo (p)...*/
      {
       if (listaVacia (*lista))  /*Si lista vacia...*/
          *lista = p;            /*actualiza "lista" con p*/
       else                      /*sino*/
          {
           /*Enlaza p antes del primero ("lista")*/
           p->next = *lista;    /*p apunta a "lista"*/
           *lista = p;          /*actualiza "lista" con p*/
          }
      }
   return p;     /*retorna el nuevo nodo creado*/
}
 
void mostrarLista (tipo_Nodo *lista){
   tipo_Nodo *p;
   p = lista;               /*guarda primer nodo en p*/
   while (p != NULL)        /*recorre la lista*/
   {
      printf("%s,%s,%s,%d\n", p->info.nombre, p->info.apellido, 
             p->info.telefono, p->info.edad);
      p = p->next;               /*avanza nodo p*/
   }
   printf("\n");
}
 
int eliminarNodo (tipo_Nodo **lista, tipo_Nodo *nodo){
   tipo_Nodo *q;
   if (nodo == NULL)              /*Si el nodo de entrada es NULL...*/
      return (-1);                /*no puede eliminar*/
   if (listaVacia (*lista))       /*Si lista vacia...*/
      return (-1);                /*(underflow) retorna -1*/
   else                           /*sino*/
      {
       if (nodo == *lista)       /*Si el nodo de entrada es el primero...*/
          *lista = nodo->next;   /*actualiza "lista" con siguiente de nodo*/
       else                      /*sino*/
          {
           q = *lista;             /*Buscar nodo (q) anterior a nodo*/
           while (q->next != nodo)
             q = q->next;
           /*Enlaza (q) anterior a nodo con siguiente de nodo*/
           q->next = nodo->next;   /*q apunta a siguiente de nodo*/
          }
       free (nodo);              /*libera nodo (memoria dinamica)*/
       return (1);           /*retorna elemento eliminado*/
      }
}
 
tipo_Nodo *buscar (tipo_Nodo *lista, tipo_info elemento){
   tipo_Nodo *p;
   p = lista;                     /*guarda primer nodo en p*/
   while (p != NULL)              /*recorre la lista*/
   {
     if (strcmp(p->info.nombre, elemento.nombre)==0)  /*Si elemento encontrado*/
        return p;                /*retorna nodo p*/
     else
        p = p->next;             /*avanza nodo p*/
   }
   return NULL;                   /*Si no encontrado, retorna NULL*/
}