Issuu on Google+


Pilas y Colas


PILAS

Una pila representa una estructura lineal de datos en la que se puede agregar o quitar elementos Ăşnicamente por uno de los dos extremos.

COLAS

Es una lista lineal de elementos en la que las operaciones de insertar y eliminar se realizan en diferentes extremos de la cola


-PUSH (insertar).- Agrega un elementos a la pila en el extremo llamado tope. -POP (remover).- Remueve el elemento de la pila que se encuentra en el extremo llamado tope. -VACIA.- Indica si la pila contiene o no contiene elementos. -LLENA.- Indica si es posible o no agregar nuevos elementos a la pila.


Las pilas son otro tipo de estructura de datos lineales, las cuales presentan restricciones en cuanto a la posición en la cual pueden realizarse las inserciones y las extracciones de elementos. Una pila se pueden insertar y eliminar elementos sólo por uno de los extremos. Como consecuencia, los elementos de una pila serán eliminados en orden inverso al que se insertaron Es decir, el último elemento que se metió a la pila será el primero en salir de ella. Trabajan con filosofía LIFO (Last In- First Out ).

En la vida cotidiana existen muchos ejemplos de pilas, una pila de platos en una alacena, una pila de latas en un supermercado, una pila de papeles y libros sobre un escritorio, etc.


Creando una nueva pila.

GQueue* pila; pila = g_queue_new (); Función que comprueba si una pila está vacía gboolean pila_vacia (GQueue* pila) { return g_queue_is_empty (pila); } Función que consulta la cima de la pila.

gpointer consultar_pila (GQueue* pila) { return g_queue_peek_head (pila); } Introducir un nuevo elemento en la pila.

GQueue* meter_pila (GQueue* pila, gpointer dato) { g_queue_push_head (pila, dato); return pila; } Vacía la pila g_queue_free (pila);


fseek(fp,0,2); do { fflush(stdin); printf("Ingrese el Codigo de Producto "); scanf("%d",&x.codigo); fflush(stdin); printf("Ingrese Nombre de Producto "); gets(x.nombre); fflush(stdin); printf("Ingrese la Existencia "); scanf("%d",&x.existencia); fflush(stdin); printf("Ingrese el Precio "); scanf("%f",&auxiliar); x.precio=auxiliar; pri=creapila(pri,x); fflush(stdin); printf("Desea Ingresar otro Registro? (S/N) "); scanf("%c",&opcion); opcion=toupper(opcion); } while(opcion=='S'); muestra(pri,fp); fflush(stdin); printf("El contenido de la Pila se ha Guardado. Desea Visualizarlo? (S/N)"); scanf("%c",&opcion); opcion=toupper(opcion); if(opcion=='S') archivo(fp); getch(); fclose(fp); }


struct nodo *creapila(struct nodo *pri, struct productos x) { struct nodo *p; p=nuevonodo(); (*p).dato=x; (*p).proximo=pri; return p; } struct nodo *nuevonodo() { struct nodo *p; p=(struct nodo *)malloc(sizeof(struct nodo)); if(p==NULL) { printf("Memoria RAM Llena"); getch(); exit(0); } return p; }


void muestra(struct nodo *pri, FILE *fp) { clrscr(); struct nodo *aux; while(pri!=NULL) { printf("Codigo: %d \n",(*pri).dato.codigo); printf("Nombre: %s \n",(*pri).dato.nombre); printf("Existencia: %d \n",(*pri).dato.existencia); printf("Precio: %0.2f \n\n",(*pri).dato.precio); fwrite(&pri->dato,sizeof(struct productos),1,fp); aux=pri; pri=(*pri).proximo; free(aux); } } void archivo(FILE *fp) { struct productos x; clrscr(); printf("Datos del Archivo:\n\n"); fread(&x,sizeof(struct productos),1,fp); while(!feof(fp)) { printf("Codigo: %d \n",x.codigo); printf("Nombre: %s \n",x.nombre); printf("Existencia: %d \n",x.existencia); printf("Precio: %0.2f \n\n",x.precio); fread(&x,sizeof(struct productos),1,fp); } printf("Fin de Archivo"); }


Es una lista lineal de elementos en la que las operaciones de insertar y eliminar se realizan en diferentes extremos de la cola. Trabajan con filosof铆a FIFO ( First In - First out), el primer elemento en entrar es el primer elemento en salir.

Cola de autom贸viles esperando servicio en una gasolinera Cola de clientes en una ventanilla del banco para pagar un servicio Cola de programas en espera de ser ejecutados por una computadora


Cola simple: Estructura lineal donde los elementos salen en el mismo orden en que llegan.

Cola circular: Representaci贸n l贸gica de una cola simple en un arreglo.


Final Frente

B C D 0

1

2

E 3

F 4

Final B Frente

C

D

E

F


Creando una nueva cola GQueue* cola; cola = g_queue_new (); Funci贸n que comprueba si una cola est谩 vac铆a. gboolean cola_vacia (GQueue* cola) { return g_queue_is_empty (cola); }

Funci贸n que consulta el frente de la cola. gpointer consultar_frente (GQueue* cola) { return g_queue_peek_head (cola); }


Funci贸n que consulta el final de la cola. gpointer consultar_final (GQueue* cola) { return g_queue_peek_tail (cola); } Introducir un nuevo elemento en la cola

GQueue* meter_cola (GQueue* cola, gpointer dato) { g_queue_push_tail (cola, dato); return cola; Vac铆a la cola

g_queue_free (cola);


#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 vacía, añadimos el nuevo a continuación 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 vacía, ahora primero apuntará también 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 direcci贸n del segundo nodo */ primero = nodo->siguiente; /* Guardamos el valor de retorno */ v = nodo->valor; /* Borrar el nodo */ delete nodo; /* Si la cola qued贸 vac铆a, ultimo debe ser NULL tambi茅n*/ if(!primero) ultimo = NULL; return v; }


int main() { cola Cola; Cola.Anadir(20); cout << "Añadir(20)" << endl; Cola.Anadir(10); cout << "Añadir(10)" << endl; cout << "Leer: " << Cola.Leer() << endl; Cola.Anadir(40); cout << "Añadir(40)" << endl; Cola.Anadir(30); cout << "Añadir(30)" << endl; cout << "Leer: " << Cola.Leer() << endl; cout << "Leer: " << Cola.Leer() << endl; Cola.Anadir(90); cout << "Añadir(90)" << endl; cout << "Leer: " << Cola.Leer() << endl; cout << "Leer: " << Cola.Leer() << endl; cin.get(); return 0; }


Picolist