1. #include <stdio.h> 2. #include <conio.h> 3. #include <stdlib.h> 4. #include <string.h> 5. 6. struct agenda 7. { 8. char nombre[50]; 9. char telefono[25]; 10.

char mail[50]; 11. }; 12. 13. struct nodo 14. { 15. struct agenda dato; 16. struct nodo *proximo; 17. }; 18. 19. struct nodo *nuevonodo(); 20. int colavacia(struct nodo *); 21. struct nodo *creacola(struct nodo *, struct agenda); 22. void mostrar(struct nodo *); 23. 24. void main() 25. { 26. struct nodo *pri=NULL, *ult=NULL; 27. struct agenda x; 28. printf("Ingrese nombre: "); 29. gets(x.nombre); 30. while(strcmpi(x.nombre,"fin")) 31. { 32. printf("Ingrese telefono: "); 33. gets(x.telefono); 34. printf("Ingrese mail: "); 35. gets(x.mail); 36. ult=creacola(ult,x); 37. if(pri==NULL) pri=ult; // Si es la 1 pasada pongo en pri el valor del primer nodo 38. printf("Ingrese nombre: "); 39. gets(x.nombre); 40. } 41. if(colavacia(pri)==1) { printf("No se ingresaron registros"); getch(); } 42. else mostrar(pri); 43. } 44.

45. struct nodo *nuevonodo() 46. { 47. struct nodo *p; 48. p=(struct nodo *)malloc(sizeof(struct nodo)); 49. if(p==NULL) 50. { 51. printf("Memoria RAM Llena"); 52. getch(); 53. exit(0); 54. } 55. return p; 56. } 57. 58. struct nodo *creacola(struct nodo *ult, struct agenda x) 59. { 60. struct nodo *p; 61. p=nuevonodo(); 62. (*p).dato=x; 63. (*p).proximo=NULL; 64. if(ult!=NULL) (*ult).proximo=p; // Si hay nodo anterior en prox pongo la direccion del nodo actual 65. return p; 66. } 67. 68. int colavacia(struct nodo *pri) 69. { 70. if(pri==NULL) return 1; 71. else return 0; 72. } 73. 74. void mostrar(struct nodo *pri) 75. { 76. struct nodo *aux; 77. while(pri!=NULL) 78. { 79. printf("Nombre: %s - Telefono: %s - Mail: %s \n",pri->dato.nombre,pri->dato.telefono,pri>dato.mail); 80. aux=pri; 81. pri=(*pri).proximo; 82. free(aux); 83. } 84. getch(); 85. }

Pilaaa

1. #include <conio.h> 2. #include <stdio.h> 3. #include <stdlib.h> 4. #include <ctype.h> 5. 6. struct productos 7. { 8. int codigo; 9. char nombre[50]; 10. int existencia; 11. float precio; 12. }; 13. 14. struct nodo 15. { 16. struct productos dato; 17. struct nodo *proximo; 18. }; 19. 20. /* Declaracion de funciones */ 21. void archivo(FILE *fp); 22. struct nodo *nuevonodo(); 23. struct nodo *creapila(struct nodo *pri, struct productos x); 24. void muestra(struct nodo *pri, FILE *fp); 25. /* Fin de Declaracion */ 26. 27. void main() 28. { 29. struct productos x; 30. struct nodo *pri=NULL; 31. FILE *fp; 32. char opcion; float auxiliar=0; 33. if((fp=fopen("C:\\Datos.txt","wb"))==NULL) 34. { 35. getch(); 36. } 37. fseek(fp,0,2); 38. do 39. { 40. fflush(stdin); 41. printf("Ingrese el Codigo de Producto "); 42. scanf("%d",&x.codigo);

43. fflush(stdin); 44. printf("Ingrese Nombre de Producto "); 45. gets(x.nombre); 46. fflush(stdin); 47. printf("Ingrese la Existencia "); 48. scanf("%d",&x.existencia); 49. fflush(stdin); 50. printf("Ingrese el Precio "); 51. scanf("%f",&auxiliar); x.precio=auxiliar; 52. pri=creapila(pri,x); 53. fflush(stdin); 54. printf("Desea Ingresar otro Registro? (S/N) "); 55. scanf("%c",&opcion); opcion=toupper(opcion); 56. } while(opcion=='S'); 57. muestra(pri,fp); 58. fflush(stdin); 59. printf("El contenido de la Pila se ha Guardado. Desea Visualizarlo? (S/N)"); 60. scanf("%c",&opcion); opcion=toupper(opcion); 61. if(opcion=='S') archivo(fp); 62. getch(); 63. fclose(fp); 64. } 65. 66. struct nodo *creapila(struct nodo *pri, struct productos x) 67. { 68. struct nodo *p; 69. p=nuevonodo(); 70. (*p).dato=x; 71. (*p).proximo=pri; 72. return p; 73. } 74. 75. struct nodo *nuevonodo() 76. { 77. struct nodo *p; 78. p=(struct nodo *)malloc(sizeof(struct nodo)); 79. if(p==NULL) 80. { 81. printf("Memoria RAM Llena"); 82. getch(); 83. exit(0); 84. } 85. return p;

86. } 87. 88. void muestra(struct nodo *pri, FILE *fp) 89. { 90. clrscr(); 91. struct nodo *aux; 92. while(pri!=NULL) 93. { 94. printf("Codigo: %d \n",(*pri).dato.codigo); 95. printf("Nombre: %s \n",(*pri).dato.nombre); 96. printf("Existencia: %d \n",(*pri).dato.existencia); 97. printf("Precio: %0.2f \n\n",(*pri).dato.precio); 98. fwrite(&pri->dato,sizeof(struct productos),1,fp); 99. aux=pri; 100. pri=(*pri).proximo; 101. free(aux); 102. } 103. } 104. 105. void archivo(FILE *fp) 106. { 107. struct productos x; 108. clrscr(); 109. printf("Datos del Archivo:\n\n"); 110. fread(&x,sizeof(struct productos),1,fp); 111. while(!feof(fp)) 112. { 113. printf("Codigo: %d \n",x.codigo); 114. printf("Nombre: %s \n",x.nombre); 115. printf("Existencia: %d \n",x.existencia); 116. printf("Precio: %0.2f \n\n",x.precio); 117. fread(&x,sizeof(struct productos),1,fp); 118. } 119. printf("Fin de Archivo"); 120. }
Pilaa
#include<stdio.h> #include<stdlib.h> #include<string.h> #include "pila.h" #include "pila_function.h" int main () {

Pila *tas; char *nom; if ((tas = (Pila *) malloc (sizeof (Pila))) == NULL) return -1; if ((nom = (char *) malloc (50 * sizeof (char))) == NULL) return -1; inicializacin (tas); printf ("Ingrese una palabra: "); scanf ("%s", nom); apilar (tas, nom); printf ("La pila (%de elementos): \n",tas->tamao); printf("\n********** Cabeza de la PILA **********\n"); muestra(tas); printf("__________ Bajo de la PILA __________\n\n"); printf ("Ingrese una palabra: "); scanf ("%s", nom); apilar (tas, nom); printf ("La pila (%de elementos): \n",tas->tamao); printf("\n********** Cabeza de la PILA **********\n"); muestra(tas); printf("__________ Bajo de la PILA __________\n\n"); printf ("Ingrese una palabra: "); scanf ("%s", nom); apilar (tas, nom); printf ("La pila (%de elementos): \n",tas->tamao); printf("\n********** Cabeza de la PILA **********\n"); muestra(tas); printf("__________ Bajo de la PILA __________\n\n"); printf ("\nLa ultima entrada (LastInFirstOut) [ %s ] sera eliminada", pile_dato(tas)); printf ("\nLa ultima entrada es eliminada\n"); desapilar (tas); /* eliminacin del ultimo elemento ingresado */ printf ("La pila (%de elementos): \n",tas->tamao); printf("\n********** Cabeza de la PILA **********\n"); muestra(tas); printf("__________ Bajo de la PILA __________\n\n"); return 0; }

COLASSS

#include <iostream> using namespace std;

class nodo \{ public: nodo(int v, nodo *sig = NULL) \{ valor = v; siguiente = sig; } private: int valor; nodo *siguiente; friend class cola; }; typedef nodo *pnodo; class cola \{ public: cola() : ultimo(NULL), primero(NULL) \{} ~cola(); void Push(int v); int Pop(); private: pnodo ultimo; }; cola::~cola() \{ while(primero) Leer(); } void cola::Anadir(int v) \{ pnodo nuevo; /* Crear un nodo nuevo */ nuevo = new nodo(v); /* Si la cola no estaba vaca, aadimos el nuevo a continuacin de ultimo */ if(ultimo) ultimo->siguiente = nuevo; /* Ahora, el ltimo elemento de la cola es el nuevo nodo */ ultimo = nuevo; /* Si primero es NULL, la cola estaba vaca, ahora primero apuntar tambin al nuevo nodo */ if(!primero) primero = nuevo; } int cola::Leer() \{ pnodo nodo; /* variable auxiliar para manipular nodo */ int v; /* variable auxiliar para retorno */ /* Nodo apunta al primer elemento de la pila */ nodo = primero; if(!nodo) return 0; /* Si no hay nodos en la pila retornamos 0 */ /* Asignamos a primero la direccin del segundo nodo */

primero = nodo->siguiente; /* Guardamos el valor de retorno */ v = nodo->valor; /* Borrar el nodo */ delete nodo; /* Si la cola qued vaca, ultimo debe ser NULL tambin*/ if(!primero) ultimo = NULL; return v; } int main() \{ cola Cola; Cola.Anadir(20); cout << "Aadir(20)" << endl; Cola.Anadir(10); cout << "Aadir(10)" << endl; cout << "Leer: " << Cola.Leer() Cola.Anadir(40); cout << "Aadir(40)" << endl; Cola.Anadir(30); cout << "Aadir(30)" << endl; cout << "Leer: " << Cola.Leer() cout << "Leer: " << Cola.Leer() Cola.Anadir(90); cout << "Aadir(90)" << endl; cout << "Leer: " << Cola.Leer() cout << "Leer: " << Cola.Leer() cin.get(); return 0; }

<< endl;

<< endl; << endl; << endl; << endl;

PILA
#include <stdlib.h> #include <stdio.h> typedef struct _nodo \{ int valor; struct _nodo *siguiente; } tipoNodo; typedef tipoNodo *pNodo; typedef tipoNodo *Pila; /* Funciones con pilas: */ void Push(Pila *l, int v); int Pop(Pila *l); int main() \{ Pila pila = NULL;

Push(&pila, Push(&pila, printf("%d, Push(&pila, Push(&pila,

20); 10); ", Pop(&pila)); 40); 30);

printf("%d, ", Pop(&pila)); printf("%d, ", Pop(&pila)); Push(&pila, 90); printf("%d, ", Pop(&pila)); printf("%d\n", Pop(&pila)); getchar(); return 0; } void Push(Pila *pila, int v) \{ pNodo nuevo; /* Crear un nodo nuevo */ nuevo = (pNodo)malloc(sizeof(tipoNodo)); nuevo->valor = v; /* Aadimos la pila a continuacin del nuevo nodo */ nuevo->siguiente = *pila; /* Ahora, el comienzo de nuestra pila es en nuevo nodo */ *pila = nuevo; } int Pop(Pila *pila) \{ pNodo nodo; /* variable auxiliar para manipular nodo */ int v; /* variable auxiliar para retorno */ /* Nodo apunta al primer elemento de la pila */ nodo = *pila; if(!nodo) return 0; /* Si no hay nodos en la pila retornamos 0 */ /* Asignamos a pila toda la pila menos el primer elemento */ *pila = nodo->siguiente; /* Guardamos el valor de retorno */ v = nodo->valor; /* Borrar el nodo */ free(nodo); return v; }

LISTASSS
#include <iostream> using namespace std; class nodo \{ public: nodo(int v, nodo *sig = NULL) \{ valor = v; siguiente = sig; }

private: int valor; nodo *siguiente; friend class lista; }; typedef nodo *pnodo; class lista \{ public: lista() \; } ~lista(); void Insertar(int v); void Borrar(int v); bool ListaVacia() \; } void Mostrar(); void Siguiente() \ void Primero() \ void Ultimo() \ bool Actual() \; } int ValorActual() \ private: pnodo primero; pnodo actual; }; lista::~lista() \{ pnodo aux; while(primero) \{ aux = primero; primero = primero->siguiente; delete aux; } actual = NULL; } void lista::Insertar(int v) \{ pnodo anterior; // Si la lista est vaca if(ListaVacia() || primero->valor > v) \{ // Asignamos a lista un nuevo nodo de valor v y // cuyo siguiente elemento es la lista actual primero = new nodo(v, primero); } else \{ // Buscar el nodo de valor menor a v anterior = primero; // Avanzamos hasta el ltimo elemento o hasta que el siguiente tenga // un valor mayor que v while(anterior->siguiente && anterior->siguiente->valor <= v) anterior = anterior->siguiente;

// Creamos un nuevo nodo despus del nodo anterior, y cuyo siguiente // es el siguiente del anterior anterior->siguiente = new nodo(v, anterior->siguiente); } } void lista::Borrar(int v) \{ pnodo anterior, nodo; nodo = primero; anterior = NULL; while(nodo && nodo->valor < v) \{ anterior = nodo; nodo = nodo->siguiente; } if(!nodo || nodo->valor != v) return; else \{ // Borrar el nodo if(!anterior) // Primer elemento primero = nodo->siguiente; else // un elemento cualquiera anterior->siguiente = nodo->siguiente; delete nodo; } } void lista::Mostrar() \{ nodo *aux; aux = primero; while(aux) \{ cout << aux->valor << "-> "; aux = aux->siguiente; } cout << endl; } int main() \{ lista Lista; Lista.Insertar(20); Lista.Insertar(10); Lista.Insertar(40); Lista.Insertar(30); Lista.Mostrar(); cout << "Lista de elementos:" << endl; Lista.Primero(); while(Lista.Actual()) \{ cout << Lista.ValorActual() << endl; Lista.Siguiente(); } Lista.Primero(); cout << "Primero: " << Lista.ValorActual() << endl; Lista.Ultimo();

cout << "Ultimo: " << Lista.ValorActual() << endl; Lista.Borrar(10); Lista.Borrar(15); Lista.Borrar(45); Lista.Borrar(30); Lista.Borrar(40); Lista.Mostrar(); cin.get(); return 0; }

LISTAS

#include <stdlib.h> #include <stdio.h> typedef struct _nodo \{ int valor; struct _nodo *siguiente; } tipoNodo; typedef tipoNodo *pNodo; typedef tipoNodo *Lista; /* Funciones con listas: */ void Insertar(Lista *l, int v); void Borrar(Lista *l, int v); int ListaVacia(Lista l); void BorrarLista(Lista *); void MostrarLista(Lista l); int main() \{ Lista lista = NULL; pNodo p; Insertar(&lista, Insertar(&lista, Insertar(&lista, Insertar(&lista, 20); 10); 40); 30);

MostrarLista(lista); Borrar(&lista, Borrar(&lista, Borrar(&lista, Borrar(&lista, Borrar(&lista, 10); 15); 45); 30); 40);

MostrarLista(lista); BorrarLista(&lista); getchar(); return 0; } void Insertar(Lista *lista, int v) \{ pNodo nuevo, anterior; /* Crear un nodo nuevo */ nuevo = (pNodo)malloc(sizeof(tipoNodo)); nuevo->valor = v; /* Si la lista est vaca */ if(ListaVacia(*lista) || (*lista)->valor > v) \{ /* Aadimos la lista a continuacin del nuevo nodo */ nuevo->siguiente = *lista; /* Ahora, el comienzo de nuestra lista es en nuevo nodo */ *lista = nuevo; } else \{ /* Buscar el nodo de valor menor a v */ anterior = *lista; /* Avanzamos hasta el ltimo elemento o hasta que el siguiente tenga un valor mayor que v */ while(anterior->siguiente && anterior->siguiente->valor <= v) anterior = anterior->siguiente; /* Insertamos el nuevo nodo despus del nodo anterior */ nuevo->siguiente = anterior->siguiente; anterior->siguiente = nuevo; } } void Borrar(Lista *lista, int v) \{ pNodo anterior, nodo; nodo = *lista; anterior = NULL; while(nodo && nodo->valor < v) \{ anterior = nodo; nodo = nodo->siguiente; } if(!nodo || nodo->valor != v) return; else \{ /* Borrar el nodo */ if(!anterior) /* Primer elemento */ *lista = nodo->siguiente; else /* un elemento cualquiera */ anterior->siguiente = nodo->siguiente; free(nodo); } } int ListaVacia(Lista lista) \{ return (lista == NULL);

} void BorrarLista(Lista *lista) \{ pNodo nodo; while(*lista) \{ nodo = *lista; *lista = nodo->siguiente; free(nodo); } } void MostrarLista(Lista lista) \{ pNodo nodo = lista; if(ListaVacia(lista)) printf("Lista vaca\n"); else \{ while(nodo) \{ printf("%d -> ", nodo->valor); nodo = nodo->siguiente; } printf("\n"); } }