Tema: Recopilacion Programas C/C++
Ver Mensaje Individual
  #2 (permalink)  
Antiguo 07/06/2012, 00:40
cesar_casla
 
Fecha de Ingreso: diciembre-2011
Ubicación: CABA
Mensajes: 433
Antigüedad: 12 años, 4 meses
Puntos: 94
Respuesta: Recopilacion Programas C/C++
Hola! creo q vas a aprender mas rapido haciendo tus propios codigos que analizando el de los demas, ya que cada una tiene distintas formas de programar. En fin te dejo uno de listas en C que hice el año pasado(esto fue un parcial)
Código C: 
Ver original
  1. /******** includes **********/
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6.  
  7. #define NOMBRE 10
  8.  
  9. /* definicion de una estructura autoreferenciada */
  10. struct nodo {
  11.   char nombre[NOMBRE];
  12.   int inventario;
  13.   int stock;
  14.   //float costo;
  15.   //int ganancia;
  16.   //float precio;
  17.   struct nodo *siguiente;
  18. };
  19.  
  20. /*********** Prototipos de funciones ************/
  21.  
  22. void agregar_nodo(struct nodo **);
  23. void mostrar_lista(struct nodo *);
  24. void buscar_nodo(struct nodo *);
  25. void modificar_nodo(struct nodo *);
  26. void insertar_nodo(struct nodo *);
  27. void borrar_nodo(struct nodo **);
  28. void menu();
  29. struct nodo *crear_nodo();
  30.  
  31. /**********         Main        ***********/
  32.  
  33. int main(void)
  34. {
  35.   int opcion;
  36.   /* creo un puntero, a struct nodo, que siempre va a ser la cabeza de la lista */
  37.   struct nodo *ptr_cabeza=NULL; /* inicialmente la lista se encuentra vacia */
  38.   
  39.   menu();
  40.   
  41.   do
  42.   {
  43.     printf("opcion: ");scanf("%d",&opcion);
  44.     
  45.     switch(opcion)
  46.     {
  47.       case 1:
  48.     agregar_nodo(&ptr_cabeza);
  49.     break;
  50.       case 2:
  51.     mostrar_lista(ptr_cabeza);
  52.     break;
  53.       case 3:
  54.     buscar_nodo(ptr_cabeza);
  55.     break;
  56.       case 4:
  57.     modificar_nodo(ptr_cabeza);
  58.     break;
  59.       case 5:
  60.     insertar_nodo(ptr_cabeza);
  61.     break;
  62.       case 6:
  63.     borrar_nodo(&ptr_cabeza);
  64.     break;
  65.       case 7:
  66.     printf("\n\t\t********** FIN DEL PROGRAMA **********\n\n");
  67.     break;
  68.       default:
  69.     system("clear");
  70.     printf("OPCION NO VALIDA\n");
  71.     menu();
  72.     break;
  73.     } /* fin del switch */
  74.   } /* fin del do */
  75.   while(opcion!=7);
  76.   
  77.   return 0;
  78.   
  79. }
  80.  
  81. void menu(void)
  82. {
  83.   printf("\n\t\t******** Menu principal ********\n");
  84.   printf("1 - Agregar nodo\n");
  85.   printf("2 - Mostrar lista\n");
  86.   printf("3 - Buscar nodo\n");
  87.   printf("4 - Modificar nodo\n");
  88.   printf("5 - Insertar nodo\n");
  89.   printf("6 - Borrar nodo\n");
  90.   printf("7 - Salir\n");
  91. }
  92.  
  93.  
  94. /************** Funcion: agregar_nodo ***************/
  95.  
  96. /* cada vez que se crea un nodo este se crea a la izquierda del que ya se encuentra en la lista,
  97. es decir el primer nodo ingresado va a ser la cola de la lista y el ultimo a ingresar va a ser
  98. el primero(cabeza) de la lista */
  99.  
  100. void agregar_nodo(struct nodo **enlace) /* preguntar por que se pasa puntero a puntero ??? se pasa xq recibe un puntero al cual 
  101. se le cambia la direccion a donde apunta  */
  102. {
  103.   struct nodo *ptr_nuevo; /* creo un puntero a la estructura nodo */
  104.   ptr_nuevo=crear_nodo();
  105.  
  106.   if(ptr_nuevo==NULL) /* no se reservo memoria */
  107.   { 
  108.     printf("No se pudo asignar memoria\n");
  109.     return;
  110.   }
  111.   ptr_nuevo->siguiente=*enlace;//el nodo creado ahora apunta al nodo que se encuentra a su derecha (cuando la lista se encuentra vacia el primenr nodo creado apunta a NULL)
  112.   *enlace=ptr_nuevo;//el puntero enlace(cabeza) ahora apunta al nodo creado
  113. }
  114.  
  115.  
  116.  
  117. /*************** Funcion mostrar_lista ********************/
  118.  
  119. /* Imprime en pantalla los nodos de la lista, si esta se encuentra vacia informa que no hay nodos creados */
  120.  
  121. void mostrar_lista(struct nodo *p_actual)
  122.  
  123. {
  124.   if(p_actual==NULL) /* la lista se encuentra vacia */
  125.   {
  126.     printf("Lista vacia\n");
  127.     return;
  128.   }
  129.   /* existe la lista */
  130.   printf("\n\t\t********* LISTA *********\n");
  131.   while(p_actual!=NULL){/* imprime los miembros de cada nodo hasta que el ultimo nodo apunte a NULL */
  132.     printf("Nombre: %s  ",p_actual->nombre);
  133.     printf("Inventario: %d  ",p_actual->inventario);
  134.     printf("Stock: %d  -->  ",p_actual->stock);
  135.     p_actual=p_actual->siguiente;
  136.   } /* fin del while */
  137.   printf("NULL\n\n");
  138. }
  139.  
  140. void buscar_nodo(struct nodo *p)
  141. {
  142.   if(p==NULL)//la lista se encuentra vacia
  143.   {
  144.     printf("Lista vacia\n");
  145.     return;
  146.   }
  147.   
  148.   int opcion,inven;
  149.   char name[NOMBRE];
  150.  
  151.   printf("0 - Para busqueda por nombre\n");
  152.   printf("1 - Para busqueda por inventario\n");
  153.   printf("?: ");scanf("%d",&opcion);
  154.   while(opcion!=0&&opcion!=1)
  155.   {
  156.     printf("Opcion no valida\n");
  157.     printf("?: ");scanf("%d",&opcion);
  158.   }
  159.   switch(opcion)
  160.   {
  161.     /* la busqueda se realiza por nombre */
  162.     case 0:
  163.       printf("Ingrese nombre a buscar: ");
  164.       scanf("%s",name);
  165.       while((p!=NULL)&&strcmp(name,p->nombre)!=0)//preguntar por el orden ???
  166.     p=p->siguiente; /* cambia al nodo a su derecha */
  167.       if(p==NULL) /* no se encontro el nodo */
  168.     printf("Nodo no encontrado\n");
  169.       else /* se encontro el nodo */
  170.       {
  171.     printf("Nodo encontrado\n");
  172.     printf("Nombre: %s\n",p->nombre);
  173.     printf("Inventario: %d\n",p->inventario);
  174.     printf("Stock: %d\n",p->stock);
  175.       }
  176.       break;
  177.       /* la busqueda se realiza por inventario */
  178.       case 1:
  179.     printf("Ingrese numero de inventario: ");
  180.     scanf("%d",&inven);
  181.     while(p!=NULL&&(p->inventario!=inven))
  182.       p=p->siguiente;
  183.     if(p==NULL) /* nose encontro nodo */
  184.       printf("Nodo no encontrado\n");
  185.     else /* se encontro el nodo */
  186.     {
  187.       printf("Nodo encontrado\n");
  188.       printf("Nombre: %s\n",p->nombre);
  189.       printf("Inventario: %d\n",p->inventario);
  190.       printf("Stock: %d\n",p->stock);
  191.     }
  192.   }/* fin del switch */
  193. }
  194.  
  195. void modificar_nodo(struct nodo *p)
  196. {
  197.   if(p==NULL) /* la lista se encuentra vacia */
  198.   {
  199.     printf("Lista vacia. No hay nodos para modificar\n");
  200.     return;
  201.   }
  202.   char name[NOMBRE];
  203.   
  204.   printf("Inserte un nombre para modificar su nodo\n");
  205.   printf("name: ");scanf("%s",name);
  206.   
  207.   while(p!=NULL&&strcmp(name,p->nombre)!=0)
  208.     p=p->siguiente;
  209.   
  210.   if(p==NULL)
  211.     printf("El nombre no se encuentra en la lista\n");
  212.   else
  213.   {
  214.     printf("Modifique los campos del nodo\n");
  215.     printf("Stock: ");scanf("%d",&p->stock); 
  216.   }
  217. }
  218.  
  219. void insertar_nodo(struct nodo *p)
  220.  
  221. {
  222.   if(p==NULL) /* la lista se encuentra vacia */
  223.   {
  224.     printf("Lista vacia\n");
  225.     return;
  226.   }
  227.   char name[NOMBRE];
  228.  
  229.   printf("Especifique delante de que elemento desea insertar un nodo:\n");
  230.   printf("name: ");scanf("%s",name);
  231.   
  232.   /* bucle de  busqueda, del elemento indicado, en la lista */
  233.   while(p!=NULL&&strcmp(name,p->nombre)!=0)
  234.     p=p->siguiente;
  235.   
  236.   if(p==NULL)
  237.     printf("El elemento no se encuentra en la lista\n");
  238.   else{
  239.     struct nodo *ptr_nuevo;
  240.     ptr_nuevo=crear_nodo();
  241.  
  242.     if(ptr_nuevo==NULL)/* no se reservo memoria */
  243.       printf("No se pudo asignar memoria\n");
  244.     else{ /* se creo el nuevo nodo; se enlazan los punteros */
  245.       ptr_nuevo->siguiente=p->siguiente; /* el nuevo nodo apunta a su derecha. Si es el ultimo nodo donde se inserto apunta a NULL */
  246.       p->siguiente=ptr_nuevo; /* el nodo izquierdo del nuevo nodo ahora apunta al nuevo nodo */
  247.     } /* fin del else interno */
  248.   } /* fin del else externo */
  249. }
  250.  
  251. void borrar_nodo(struct nodo **cabeza)
  252. {
  253.   if(*cabeza==NULL) /* la lista se encuentra vacia */
  254.   {
  255.     printf("Lista vacia. No hay nodos para borrar\n");
  256.     return;
  257.   }
  258.   struct nodo *actual,*anterior;
  259.   char name[NOMBRE];
  260.   
  261.   actual=*cabeza;
  262.   
  263.   printf("Especifique un nombre para borrar su nodo:\n");
  264.   printf("name: ");scanf("%s",name);
  265.   
  266.   /* bucle de busqueda, del elemento indicado, en la lista */
  267.   while(actual!=NULL&&strcmp(name,actual->nombre)!=0)
  268.   {
  269.     anterior=actual;
  270.     actual=actual->siguiente;
  271.   }
  272.   
  273.   if(actual==NULL)
  274.     printf("El elemento no se encuentra en la lista\n");
  275.   else
  276.   {/* se distingue entre si el nodo a borrar es la cabeza de la lista o no */
  277.     if(actual==*cabeza) /* si el nodo a borrar es la cabeza */
  278.       *cabeza=actual->siguiente;/* ahora la *cabeza es el nodo que se encuentra a su derecha */ 
  279.     else /*el nodo a borrar no es la cabeza */
  280.       anterior->siguiente=actual->siguiente;/*el nodo anterior al nodo a borrar ahora apunta al nodo que esta a la derecha del nodo a borrar */
  281.       
  282.     free(actual);//libero el espacio de memoria del nodo borrado  
  283.     printf("Nodo borrado\n");
  284.   }
  285. }
  286.  
  287. struct nodo *crear_nodo(void)
  288. {
  289.   struct nodo *p_crear;
  290.   p_crear=(struct nodo*)malloc(sizeof(struct nodo));
  291.   
  292.   if(p_crear==NULL)/* no se pudo almacenar memoria para el nuevo nodo */
  293.     return NULL;
  294.   
  295.   /* se creo y se ingresan los campos del nodo */
  296.   printf("Ingrese nombre: ");
  297.   scanf("%s",p_crear->nombre);
  298.   printf("Ingrese numero de inventario: ");
  299.   scanf("%d",&p_crear->inventario);
  300.   printf("Ingrese Stock: ");scanf("%d",&p_crear->stock);
  301.   p_crear->siguiente=NULL;
  302.   
  303.   return p_crear;
  304. }

Saludos