Unidad6: Pila y Cola

Biblio:AlgoritmosyEstructurasdedatosAguilaryMartinez.Unidad10y11 Autor:IngRolandoSimonTitiosky.

Pila
Esunaestructuradedatosde entradaordenaporlaCIMA
Sepuedeintroduciryeliminaren laCIMA. EntradaOrdenada:Nosignifica quesepuedancompararconel operador<(menorque).
Agregarun nuevoelemento Eliminarun elemento CIMA

e n . . . e 3 e 2 e 1
Fondo

LIFO:LastInput,FirstOutput. Operacionestpicas: Insertar(push),retirar(pop)

PushyPop
PUSHMAC
C A M Pila Vaca Push M M Push: A A M Push: C C A M PilaCon datos A M Pop:C M Pop:A Pop:M Pila Vaca

POP:SalidaCAM

SepuedeimplantarconArrays(estticos)oconListas (dinmicas). Sedebenevitarloserroresdeacceso:

UnderFlow:SacarunelementodeunaPilaVaca OverFlow:Meterunelementoenunapilallena(nohaymas espacioestticooparaasignar)

EstudiaremoslaPilaimplementadaenArrayycon Listasenlazadas.

TADPilaenArray:pilaarray.h
/*DatosdelTADpila*/
#defineTAMPILA100 TypedefintTipoDato Typedefstruct { TipoDatolistaPila[TAMPILA] intcima }Pila
n E CIMA

E n1 E i . E 0

/*Operacionessobrelapila*/

Fondo

voidcrearPila(Pila*pila) Voidinsertar(Pila*pila,TipoDatoelemento) TipoDatoquitar(Pila*pila) VoidlimpiarPila(Pila*pila) IntpilaVacia(Pila*pila) IntpilaLlena(Pila*pila) intcima(Pilapila)/*Entregaelelementodelacimadepilasinborrarlo*/

TADPila:pilaarray.c
#include<pilaarray.h> #include<stdlib.h> voidcrearPila(Pila*pila) {pila>cima=1}/*1indicaquelaPilaexisteyestvacia*/ voidinsertar(Pila*pila,TipoDatoelemento) { ifpilaLlena(*pila) { puts(OverFlow) exit(1) } pila>cima++ pila>listaPila[pila>cima]=elemento }
n E CIMA

E n1 E i . E 0
Fondo

TADPila:pilaarray.c
TipoDatoquitar(Pila*pila) { TipoDatotemp ifpilaVacia(*pila) { puts(UnderFlow) exit(1) } temp=pila>listaPila[pila>cima] pila>cima returntemp } IntpilaVacia(Pilapila) {return(pila.cima==1)} IntpilaLlena(Pilapila) {return(pila.cima==TAMPILA1)}
n E CIMA

E n1 E i . E 0
Fondo

TADPila:pilaarray.c
TipoDatocima(Pila*pila) { TipoDatotemp ifpilaVacia(*pila) { puts(PilaVacia) exit(1) } returnpila>listaPila[pila>cima] } VoidlimpiarPila(Pila*pila) { pila>cima=1}
n E CIMA

E n1 E i . E 0
Fondo

TADpilaenListadeSE
Ventajas:
Nosedesperdiciaposicionesdememoria Eltamaodelapilaseajustaexactamenteala cantidaddeelementos.
ElOverFlowestarligadoalacapacidaddeRAMydel direccionamientodelSistemaOperativo.

Desventajas:
MasLentoporlagestindememoria MayorComplejidadEspacial:senecesitamas memoriaporcadaelementodelapilaparaguardarel ptr

TADpilaenlistasimple:pila.h
/*readeDatos*/
#include<stdlib.h> TypedefintTipoDato TypedefestructNodo
{TipoDatoelemento structnodo*siguiente }

/*readeOperaciones*/
VoidcrearPila(Nodo**pila) Voidinsertar(Nodo**pila,TipoDatoelemento) Voidsuprimir(Nodo**pila)/*eliminalacima*/ TipoDatoquitar(Nodo**pila)/*hacepopydevuelveeldato*/ VoidlimpiarPila(Nodo**pila) TipoDatocima(Nodo*pila) IntpilaVacia(Nodo*pila)

TADPilaenlistasimple:pila.c
#include<pila.h> #include<stdlib.h>
Pila Ptro Ptro Ptro Ptro
Null

voidcrearPila(Nodo**pila) {*pila=NULL} voidinsertar(Nodo**pila,TipoDatoelemento) { Nodo*nuevo nuevo=(Nodo*)malloc(sizeof(Nodo)) nuevo>elemento=elemento nuevo>siguiente=*pila (*pila)=nuevo } intpilaVacia(Nodo*pila) {return(*pila==NULL)}

TADpilaenlistasimple:pila.c
Voidsuprimir(Nodo**pila) { if(!pilaVacia(*pila)) { Nodo*f=*pila (*pila)=(*pila)>siguiente free(f) } } TipoDatocima(Nodo*pila) { ifpilaVacia(*pila) { puts(PilaVacia) exit(1) } returnpila>elemento }
/*Quitareslasumadelas operacionesdecimaysuprimir*/ TipoDatoquitar(Nodo**pila) { TipoDatotemp=cima(*pila) suprimir(pila) returntemp }

COLA
Esunaestructuradedatosquealmacenaelementosen listayquepermiteaccederlosensuordendeaparicin. FIFO:FirstInput,FirstOutput. Insertar:introduceelementosporelfinaldelacola Quitar:sacaelementosdelFrentedelacola.

quitar
1ro Frente 2do i N Ultimo Final

Insertar

COLAconArrays
UnArraycondosndicesqueindiquen frenteyfinal. LuegodevariosInsertaryQuitar, quedarnhuecosdentrodelarrays.
Solucin1:Corrimientointerno Solucin2:ArrayCircular.
mtodoeficientedeimplementarcolaconarrays. Noquedanhuecos

Solucin3:ImplementarColaconListas.

ColaenArrayLineal:colalineal.h
/*DatosdelTADColalineal*/
#defineMAXTAMQ100 TypedefintTipoDato Typedefstruct { TipoDatolistaCola[MAXTAMQ] intfrente intfinal }Cola

/*OperacionessobrelaColaLineal*/
voidcrearCola(Cola*cola) Voidinsertar(Cola*cola,TipoDatoelemento) TipoDatoquitar(Cola*cola) IntcolaVacia(Cola*cola) IntcolaLlena(Cola*cola) intfrente(Colacola)/*Entregaelelementodelfrentedecolasinborrarlo*/

TADColaLineal:colalineal.c
#include<colalineal.h> #include<stdlib.h> voidcrearcola(cola*cola) {cola>frente=0 cola>final=1 } IntcolaLlena(colacola) {return(cola.final==MAXTAMQ1)} voidinsertar(Cola*cola,TipoDatoentrada) { ifcolaLlena(*cola){ puts(ColaLlena) exit(1) } cola>final++ cola>listacola[cola>final]=entrada }

TADcola:colalineal.c
TipoDatoquitar(Cola*cola) { TipoDatotemp ifcolaVacia(cola) { puts(Nohayelementosparasacar) exit(1) } temp=cola>listaCola[cola>frente] cola>frente++ returntemp } IntcolaVacia(colacola) {return(cola.final<cola.frente)}

TADcola:colalineal.c
TipoDatofrente(Colacola) { ifcolaVacia(cola) { puts(Errordeejecucion:ColaVacia) exit(1) } returncola.listacola[cola.frente] }

ColaenListaSimple:coladinamica.h
/*DatosdelTADColadinamica*/ TypedefintTipoDato TypedefStructnodo { TipoDatoelemento structnodo*siguiente }Nodo TypedefStruct { Nodo*frente Nodo*final }Cola /*Operacionessobrela ColaLineal*/ voidcrearCola(Cola*cola) TipoDatoquitar(Cola*cola) IntcolaVacia(Colacola) intfrente(Colacola)/*Entregael
frentedecolasinborrarlo*/

Voidinsertar(Cola*cola,TipoDato entrada) VoidborrarCola(Cola*cola)

TADColaLineal:coladinamica.c
#include<colalineal.h> #include<stdlib.h> voidcrearcola(cola*cola) {cola>frente=cola>final=NULL} Nodo*crearNodo(Tipodatoelemento) { Nodo*t t=(Nodo*)malloc(sizeof(Nodo)) t>elemento=elemento t>siguiente=NULL returnt } IntcolaVacia(ColaCola) {return(cola.frente==NULL)}

TADColaLineal:coladinamica.c
Voidinsertar(cola*cola,TipoDatoentrada) { Nodo*a a=crearNodo(entrada) if(colaVacia(*cola)) cola>frente=a else (cola>final)>siguiente=a cola>final=a Final }
Null

Frente

Ptro

Ptro

TADColaLineal:coladinamica.c
TipoDatoquitar(cola*cola) { TipoDatotmp if(colaVacia(*cola)) {puts(Errorcometidoaleliminardeunacolavaca) exit(1) } else { Nodo*a=cola>frente tmp=(cola>frente)>elemento cola>frente=(cola>frente)>siguiente free(a) returntmp Frente Final } } Null
a
Ptro Ptro

TADColaLineal:coladinamica.c
TipoDatofrente(Colacola) { if(colaVacia(cola)) { puts( Error:colavaca) exit(1) } return((cola.frente)>elemento) } VoidborrarCola(Cola*cola)/*Elimina,liberatodoslosnodosdelacola*/ { Nodo*n for(cola>frente!=NULL) { n=cola>frente cola>frente=(cola>frente)>siguiente free(n) } }

TrabajosPrcticosUnidad6
COMOMINIMO,REALIZAR: DelaBibliografa
DelCapitulo10:
Ejercicios:10.1 Problemas:10.1,10.2,10.7

DelCapitulo11:
Ejercicios:11.1,11.4,11.5 Problemas:11.1

EjerciciosComplementarios
RealizarlaOperacindeCorrimientoInternode laColaconArraysLineales. RealizarunAnlisisdeRendimientodelosTAD COLAimplementadocon:ArrayLinealyLista Simple.
EstudiarlaComplejidadenelTiempoyelEspacio DeterminarelOrdendelaEficienciadecadauno