Foros del Web » Programación para mayores de 30 ;) » C/C++ »

estructura en listas simples

Estas en el tema de estructura en listas simples en el foro de C/C++ en Foros del Web. 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 ...
  #1 (permalink)  
Antiguo 23/10/2011, 12:04
 
Fecha de Ingreso: octubre-2011
Ubicación: colombia
Mensajes: 5
Antigüedad: 7 años, 10 meses
Puntos: 0
estructura en listas simples

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;
       }

}
  #2 (permalink)  
Antiguo 23/10/2011, 20:43
 
Fecha de Ingreso: septiembre-2011
Mensajes: 16
Antigüedad: 7 años, 10 meses
Puntos: 7
Respuesta: estructura en listas simples

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
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. /*Definicion de Tipo para elementos*/
  5. typedef struct nodo_estudiante {
  6.     char nombre[50];
  7.     char apellido[50];
  8.     char telefono[50];
  9.     int edad;
  10. } tipo_info;
  11.  
  12. /*Definicion de Tipo para una Lista*/
  13. typedef struct nodo_Lista {
  14.     tipo_info info;
  15.     struct    nodo_Lista *next;
  16. } tipo_Nodo;
  17.  
  18. void nuevaLista (tipo_Nodo **lista);
  19. tipo_Nodo *getNode (tipo_info elemento);
  20. int listaVacia (tipo_Nodo *lista);
  21. tipo_Nodo *insertarPrimero (tipo_Nodo **lista, tipo_info elemento);
  22. void mostrarLista (tipo_Nodo *lista);
  23. int eliminarNodo (tipo_Nodo **lista, tipo_Nodo *nodo);
  24. tipo_Nodo *buscar (tipo_Nodo *lista, tipo_info elemento);
  25.  
  26. int main(){
  27.    tipo_Nodo *lista, *p, *nodo;
  28.    int opcion, eliminado;
  29.    tipo_info elemento;
  30.    
  31.    nuevaLista (&lista);       /*Inicializar lista*/
  32.    do
  33.    {
  34.      printf("Menu de Opciones:\n");
  35.      printf("1-Insertar un elemento Primero en la lista.\n");
  36.      printf("2-Ver elementos en la lista.\n");
  37.      printf("3-Eliminar un elemento de la lista.\n");
  38.      printf("4-Salir.\n");
  39.      printf("\nIntroduzca su opcion: ");
  40.      scanf("%d", &opcion);
  41.      if (opcion == 1)     /*opcion 1: Insertar Primero en lista*/
  42.         {
  43.          printf("Ingrese el nombre: ");
  44.          scanf ("%s", &elemento.nombre);
  45.          printf("Ingrese el apellido: ");
  46.          scanf ("%s", &elemento.apellido);
  47.          printf("Ingrese el telefono: ");
  48.          scanf ("%s", &elemento.telefono);
  49.          printf("Ingrese la edad: ");
  50.          scanf ("%d", &elemento.edad);
  51.          /*Insertar elemento de Primero*/
  52.          p = insertarPrimero (&lista, elemento);
  53.          if (p == NULL)
  54.             printf("\nNO se puede insertar (NO hay memoria disponible).\n");
  55.          else
  56.             printf("\nElemento insertado de Primero...\n");
  57.          system("pause");
  58.         }
  59.      if (opcion == 2)     /*opcion 2: Ver elementos en lista*/
  60.         {
  61.          printf("Reporte de elementos en la lista:\n");
  62.          if (listaVacia (lista))
  63.             printf("NO hay elementos en la lista.\n");
  64.          else
  65.             mostrarLista (lista);
  66.          system("pause");
  67.         }
  68.      if (opcion == 3)     /*opcion 3: Eliminar un elemento de lista*/
  69.         {
  70.          printf("Ingrese el nombre a eliminar: \n");
  71.          scanf ("%s", &elemento.nombre);
  72.          /*Buscar elemento*/
  73.          nodo = buscar (lista, elemento);
  74.          /*Eliminar nodo*/
  75.          eliminado = eliminarNodo (&lista, nodo);
  76.          if (eliminado == -1)
  77.             {
  78.              printf("\nElemento %s NO se encuentra en la lista.", elemento.nombre);
  79.              printf("\nNO se puede eliminar.\n");
  80.             }
  81.          else
  82.             printf("\nElemento %s eliminado...\n", elemento.nombre);
  83.          system("pause");
  84.         }
  85.    }while (opcion != 4);
  86.    return 0;
  87. }
  88.  
  89. void nuevaLista (tipo_Nodo **lista){
  90.    *lista = NULL;
  91. }
  92.  
  93. tipo_Nodo *getNode (tipo_info elemento){
  94.    tipo_Nodo *p;
  95.    /*Asigna memoria dinamicamente para un solo nodo*/
  96.    p = (tipo_Nodo *) malloc(sizeof(tipo_Nodo));
  97.    if (p != NULL)         /*Si obtuvo un nodo (p) de la memoria...*/
  98.       {
  99.        p->info = elemento;     /*guarda elemento en info*/
  100.        p->next = NULL;         /*next apunta a NULL*/
  101.       }
  102.    return p;
  103. }
  104.  
  105. int listaVacia (tipo_Nodo *lista){
  106.    if (lista == NULL)
  107.       return (1);          /*retorna 1 (Exito). Lista vacia*/
  108.    else
  109.       return (0);          /*retorna 0 (Error). Lista no vacia*/
  110. }
  111.  
  112. tipo_Nodo *insertarPrimero (tipo_Nodo **lista, tipo_info elemento){
  113.    tipo_Nodo *p;
  114.    p = getNode(elemento);         /*obtiene un nuevo nodo*/
  115.    if (p != NULL)                 /*Si obtuvo un nodo (p)...*/
  116.       {
  117.        if (listaVacia (*lista))  /*Si lista vacia...*/
  118.           *lista = p;            /*actualiza "lista" con p*/
  119.        else                      /*sino*/
  120.           {
  121.            /*Enlaza p antes del primero ("lista")*/
  122.            p->next = *lista;    /*p apunta a "lista"*/
  123.            *lista = p;          /*actualiza "lista" con p*/
  124.           }
  125.       }
  126.    return p;     /*retorna el nuevo nodo creado*/
  127. }
  128.  
  129. void mostrarLista (tipo_Nodo *lista){
  130.    tipo_Nodo *p;
  131.    p = lista;               /*guarda primer nodo en p*/
  132.    while (p != NULL)        /*recorre la lista*/
  133.    {
  134.       printf("%s,%s,%s,%d\n", p->info.nombre, p->info.apellido,
  135.              p->info.telefono, p->info.edad);
  136.       p = p->next;               /*avanza nodo p*/
  137.    }
  138.    printf("\n");
  139. }
  140.  
  141. int eliminarNodo (tipo_Nodo **lista, tipo_Nodo *nodo){
  142.    tipo_Nodo *q;
  143.    if (nodo == NULL)              /*Si el nodo de entrada es NULL...*/
  144.       return (-1);                /*no puede eliminar*/
  145.    if (listaVacia (*lista))       /*Si lista vacia...*/
  146.       return (-1);                /*(underflow) retorna -1*/
  147.    else                           /*sino*/
  148.       {
  149.        if (nodo == *lista)       /*Si el nodo de entrada es el primero...*/
  150.           *lista = nodo->next;   /*actualiza "lista" con siguiente de nodo*/
  151.        else                      /*sino*/
  152.           {
  153.            q = *lista;             /*Buscar nodo (q) anterior a nodo*/
  154.            while (q->next != nodo)
  155.              q = q->next;
  156.            /*Enlaza (q) anterior a nodo con siguiente de nodo*/
  157.            q->next = nodo->next;   /*q apunta a siguiente de nodo*/
  158.           }
  159.        free (nodo);              /*libera nodo (memoria dinamica)*/
  160.        return (1);           /*retorna elemento eliminado*/
  161.       }
  162. }
  163.  
  164. tipo_Nodo *buscar (tipo_Nodo *lista, tipo_info elemento){
  165.    tipo_Nodo *p;
  166.    p = lista;                     /*guarda primer nodo en p*/
  167.    while (p != NULL)              /*recorre la lista*/
  168.    {
  169.      if (strcmp(p->info.nombre, elemento.nombre)==0)  /*Si elemento encontrado*/
  170.         return p;                /*retorna nodo p*/
  171.      else
  172.         p = p->next;             /*avanza nodo p*/
  173.    }
  174.    return NULL;                   /*Si no encontrado, retorna NULL*/
  175. }

Etiquetas: estructura, listas, simples, struct
Atención: Estás leyendo un tema que no tiene actividad desde hace más de 6 MESES, te recomendamos abrir un Nuevo tema en lugar de responder al actual.
Respuesta

SíEste tema le ha gustado a 2 personas




La zona horaria es GMT -6. Ahora son las 14:01.