Pilas Colas Listas

Pilas Colas Listas
Estructuras de datos: Pilas, Colas, Listas

Algoritmos
- Fac. de Informatica Dep. de Computacion Universidad de A Coruna
J. Santiago Jorge sjorge@udc.es
Algoritmos
Pilas, Colas, Listas
Pilas Colas Listas
Indice
Pilas
Colas
Listas
Algoritmos
Pilas Colas Listas
Referencias bibliogracas
M. A. Weiss. Listas, pilas y colas. En Estructuras de datos y algoritmos, cap tulo 3, paginas 4592. Addison-Wesley Iberoamericana, 1995. Mar de estructuras de datos. En R. Pena . Implementacion de Programas. Formalismo y abstraccion , cap Diseno tulo 7, 1998. paginas 257290. Prentice Hall, segunda edicion, G. Brassard y T. Bratley. Estructura de datos. En Fundamentos de algoritmia, cap tulo 5, paginas 167210. Prentice Hall, 1997.
Algoritmos
Pilas Colas Listas
Indice
Pilas
Colas
Listas
Algoritmos
Pilas Colas Listas
Pilas
Acceso limitado al ultimo elemento insertado Operaciones basicas: apilar, desapilar y cima. desapilar o cima en una pila vac a es un error en el TDA pila. Quedarse sin espacio al apilar es un error de implementacion. deber Cada operacion a tardar una cantidad constante de tiempo en ejecutarse.
Con independencia del numero de elementos apiladas.
Algoritmos
Pilas Colas Listas
a base de vectores (i) Pseudocodigo: Implementacion

tipo Pila = registro Cima_de_pila : 0..Tama no_m aximo_de_pila Vector_de_pila : vector [1..Tama no_m aximo_de_pila] de Tipo_de_elemento fin registro procedimiento Crear Pila ( P ) P.Cima_de_pila := 0 fin procedimiento funci on Pila Vac a ( P ) : test devolver P.Cima_de_pila = 0 fin funci on
Algoritmos Pilas, Colas, Listas
Pilas Colas Listas
a base de vectores (ii) Pseudocodigo: Implementacion

procedimiento Apilar ( x, P ) si P.Cima_de_pila = Tama no_m aximo_de_pila entonces error Pila llena sino P.Cima_de_pila := P.Cima_de_pila + 1; P.Vector_de_pila[P.Cima_de_pila] := x fin procedimiento funci on Cima ( P ) : Tipo_de_elemento si Pila Vac a (P) entonces error Pila vac a sino devolver P.Vector_de_pila[P.Cima de Pila] fin funci on procedimiento Desapilar ( P ) si Pila Vac a (P) entonces error Pila vac a sino P.Cima_de_pila := P.Cima_de_pila - 1 fin procedimiento
Pilas Colas Listas
Codigo C: pilas.h
#ifndef TAMANO_MAXIMO_PILA #define TAMANO_MAXIMO_PILA 10 #endif typedef int tipo_elemento; typedef struct { int cima; tipo_elemento vector[TAMANO_MAXIMO_PILA]; } pila; void crear_pila(pila *); int pila_vacia(pila); void apilar(tipo_elemento, pila *); tipo_elemento cima(pila); void desapilar(pila *); /* ERRORES: cima o desapilar sobre la pila vac a apilar sobre la pila llena */
Pilas Colas Listas
Codigo C: pilas.c (i)

#include <stdlib.h> #include <stdio.h> #include "pilas.h" void crear_pila(pila *p) { p->cima = -1; } int pila_vacia(pila p) { return (p.cima == -1); } void apilar(tipo_elemento x, pila *p) { if (++p->cima == TAMANO_MAXIMO_PILA) { printf("error: pila llena\n"); exit(EXIT_FAILURE); } p->vector[p->cima] = x; }
Pilas Colas Listas
Codigo C: pilas.c (ii)

tipo_elemento cima(pila p) { if (pila_vacia(p)) { printf("error: pila vacia\n"); exit(EXIT_FAILURE); } return p.vector[p.cima]; } void desapilar(pila *p) { if (pila_vacia(*p)) { printf("error: pila vacia\n"); exit(EXIT_FAILURE); } p->cima--; }
Pilas Colas Listas
Indice
Pilas
Colas
Listas
Algoritmos
Pilas Colas Listas
Colas
Operaciones basicas: insertar, quitarPrimero y primero. Cada rutina deber a ejecutarse en tiempo constante.
Algoritmos
Pilas Colas Listas
circular a base de vectores (i) Implementacion

circular devuelve cabeza y n al principo del La implementacion vector cuando rebasan la ultima posicion. nal 1) Crear Cola (C) cabeza
Algoritmos
Pilas Colas Listas

circular devuelve cabeza y n al principo del La implementacion vector cuando rebasan la ultima posicion. nal 1) Crear Cola (C) cabeza nal a cabeza
2) Insertar en Cola (a,C)
Algoritmos
Pilas Colas Listas

circular devuelve cabeza y n al principo del La implementacion vector cuando rebasan la ultima posicion. nal 1) Crear Cola (C) cabeza nal a cabeza nal b
2) Insertar en Cola (a,C)
3) Insertar en Cola (b,C)
a cabeza
Algoritmos
Pilas Colas Listas

4) Insertar en Cola (c,C) a cabeza b nal c
Algoritmos
Pilas Colas Listas

5) Insertar en Cola (d,C)
a cabeza
nal d
Algoritmos
Pilas Colas Listas

a cabeza
nal d
6) Quitar Primero (C)
b cabeza
nal d
Algoritmos
Pilas Colas Listas

a cabeza
nal d
6) Quitar Primero (C)
b cabeza nal e
Algoritmos
nal d
7) Insertar en Cola (e,C)
b cabeza
Pilas Colas Listas
Pseudocodigo (i)
tipo Cola = registro Cabeza_de_cola, Final_de_cola: 1..Tama no_m aximo_de_cola Tama no_de_cola : 0..Tama no_m aximo_de_cola Vector_de_cola : vector [1..Tama no_m aximo_de_cola] de Tipo_de_elemento fin registro procedimiento Crear_Cola ( C ) C.Tama no_de_cola := 0; C.Cabeza_de_cola := 1; C.Final_de_cola := Tama no_m aximo_de_cola fin procedimiento funci on Cola_Vac a ( C ) : test devolver C.Tama no_de_cola = 0 fin funci on
Pilas Colas Listas
Pseudocodigo (ii)
procedimiento incrementar ( x ) (* privado *) si x = Tama no_m aximo_de_cola entonces x := 1 sino x := x + 1 fin procedimiento procedimiento Insertar_en_Cola ( x, C ) si C.Tama no_de_Cola = Tama no_m aximo_de_cola entonces error Cola llena sino C.Tama no_de_cola := C.Tama no_de_cola + 1; incrementar(C.Final_de_cola); C.Vector_de_cola[C.Final_de_cola] := x; fin procedimiento
Pilas Colas Listas
Pseudocodigo (iii)
funci on Quitar_Primero ( C ) : Tipo_de_elemento si Cola_Vac a ( C ) entonces error Cola vac a sino C.Tama no_de_cola := C.Tama no_de_cola - 1; x := C.Vector_de_cola[C.Cabeza_de_cola]; incrementar(C.Cabeza_de_cola); devolver x fin funci on funci on Primero ( C ) : Tipo_de_elemento si Cola_Vac a ( C ) entonces error Cola vac a sino devolver C.Vector_de_cola[C.Cabeza_de_cola] fin funci on
Pilas Colas Listas
Codigo C: colas.h
#ifndef TAMANO_MAXIMO_COLA #define TAMANO_MAXIMO_COLA 5 #endif typedef int tipo_elemento; typedef struct { int cabeza, final, tamano; tipo_elemento vector[TAMANO_MAXIMO_COLA]; } cola; void crear_cola(cola *); int cola_vacia(cola); void insertar(tipo_elemento, cola *); tipo_elemento quitar_primero(cola *); tipo_elemento primero(cola); /* ERRORES: quitar_primero o primero sobre una cola vac a insertar en una cola llena */
Pilas Colas Listas
Codigo C: colas.c (i)

#include <stdlib.h> #include <stdio.h> #include "colas.h" void crear_cola(cola *c) { c->tamano = 0; c->cabeza = 0; c->final = -1; } int cola_vacia(cola c) { return (c.tamano == 0); } void incrementar(int *x) { /* privado */ if (++(*x) == TAMANO_MAXIMO_COLA) *x = 0; }
Pilas Colas Listas
Codigo C: colas.c (ii)

void insertar(tipo_elemento x, cola *c) { if (c->tamano == TAMANO_MAXIMO_COLA) { printf("error: cola llena: %d\n", c->tamano); exit(EXIT_FAILURE); } c->tamano++; incrementar(&(c->final)); c->vector[c->final] = x; } tipo_elemento primero(cola c) { if (cola_vacia(c)) { printf("error: cola vacia\n"); exit(EXIT_FAILURE); } return(c.vector[c.cabeza]); }
Pilas Colas Listas
Codigo C: colas.c (iii)
tipo_elemento quitar_primero(cola *c) { tipo_elemento x; if (cola_vacia(*c)) { printf("error: cola vacia\n"); exit(EXIT_FAILURE); } c->tamano--; x = c->vector[c->cabeza]; incrementar(&(c->cabeza)); return x; }
Algoritmos
Pilas Colas Listas
Indice
Pilas
Colas
Listas
Algoritmos
Pilas Colas Listas
Listas
Operaciones basicas: Visualizar su contenido. de la primera ocurrencia de un elemento. Buscar la posicion Insertar y Eliminar un elemento en alguna posicion. Buscar k esimo, que devuelve el elemento
indicada de la posicion
Algoritmos
Pilas Colas Listas
de listas a base de vectores Implementacion
de la lista. Tiene que declararse el tamano

Exige sobrevaloracion. Consume mucho espacio.
Complejidad computacional de las operaciones: Buscar k esimo, tiempo constante Visualizar y Buscar, tiempo lineal. Insertar y Eliminar son costosas.
Insertar o eliminar un elemento exige, en promedio, desplazar la mitad de los valores, O (n). de una lista o la eliminacion La construccion de todos sus elementos podr a exigir un tiempo cuadratico.
Algoritmos
Pilas Colas Listas
de listas a base de apuntadores Implementacion

Cada nodo apunta al siguiente; el ultimo no apunta a nada. La lista es un puntero al primer nodo (y al ultimo). Complejidad computacional de las operaciones: Visualizar y Buscar, tiempo lineal. Buscar k esimo, tiempo lineal. Eliminar realiza un cambio de apuntadores y una orden dispose, O (1).
es lineal. Usa Buscar anterior cuyo tiempo de ejecucion
p require una llamada a new y Insertar tras una posicion dos maniobras con apuntadores, O (1).
p podr Buscar la posicion a llevar tiempo lineal.
y la eliminacion al comienzo Un nodo cabecera facilita la insercion de la lista.
Algoritmos
Pilas Colas Listas
de listas doblemente enlazadas Implementacion
Cada nodo apunta al siguiente y al anterior. Duplica el uso de la memoria necesaria para los punteros. Duplica el coste de manejo de punteros al insertar y eliminar. se simplica. La eliminacion
No es necesario buscar el elemento anterior.
Algoritmos
Pilas Colas Listas
con un nodo cabecera (i) Pseudocodigo: Implementacion

tipo PNodo = puntero a Nodo Lista = PNodo Posici on = PNodo Nodo = registro Elemento : Tipo_de_elemento Siguiente : PNodo fin registro procedimiento Crear Lista ( L ) nuevo ( tmp ); si tmp = nil entonces error Memoria agotada sino tmp.Elemento := { nodo cabecera }; tmp.Siguiente := nil; L := tmp fin procedimiento
Pilas Colas Listas
con un nodo cabecera (ii) Pseudocodigo: Implementacion

funci on Lista Vac a ( L ) : test devolver L.Siguiente = nil fin funci on funci on Buscar ( x, L ) : posici on de la 1a ocurrencia o nil p := L.Siguiente; mientras p <> nil y p.Elemento <> x hacer p := p.Siguiente; devolver p fin funci on funci on Ultimo Elemento ( p ) : test { privada } devolver p.Siguiente = nil fin funci on
Pilas Colas Listas
con un nodo cabecera (iii) Pseudocodigo: Implementacion

funci on Buscar Anterior ( x, L ) : posici on anterior a x o a nil { privada } p := L; mientras p.Siguiente <> nil y p.Siguiente.Elemento <> x hacer p := p.Siguiente; devolver p fin funci on procedimiento Eliminar ( x, L ) p := Buscar Anterior ( x, L ); si Ultimo Elemento ( p ) entonces error No encontrado sino tmp := p.Siguiente; p.Siguiente := tmp.Siguiente; liberar ( tmp ) fin procedimiento
Pilas Colas Listas
con un nodo cabecera (iv) Pseudocodigo: Implementacion
procedimiento Insertar ( x, L, p ) nuevo ( tmp ); { Inserta despu es de la posici on p } si tmp = nil entonces error Memoria agotada sino tmp.Elemento := x; tmp.Siguiente := p.Siguiente: p.Siguiente := tmp fin procedimiento
Algoritmos
Pilas Colas Listas
Codigo C: listas.h
typedef int tipo_elemento; struct nodo { tipo_elemento elemento; struct nodo * siguiente; }; typedef struct nodo *pnodo; typedef pnodo lista; void crear_lista(lista *); int lista_vacia(lista); pnodo buscar(tipo_elemento, lista); int ultimo_elemento(pnodo); void eliminar(tipo_elemento, lista *); void insertar(tipo_elemento, lista *, pnodo); /* ERRORES: eliminar un elemento que no esta en la lista */
Pilas Colas Listas
Codigo C: listas.c (i)

#include <stdlib.h> #include <stdio.h> #include "listas.h" void crear_lista(lista *l){ pnodo tmp = (pnodo) malloc(sizeof(struct nodo)); if (tmp == NULL) { printf("memoria agotada\n"); exit(EXIT_FAILURE); } tmp->siguiente = NULL; *l = tmp; } int lista_vacia(lista l){ return (l->siguiente == NULL); }
Pilas Colas Listas
Codigo C: listas.c (ii)

pnodo buscar(tipo_elemento x, lista l){ pnodo p = l->siguiente; while (p != NULL && p->elemento != x) p = p->siguiente; return p; } int ultimo_elemento(pnodo p) { /* privada */ return (p->siguiente == NULL); } pnodo buscar_anterior(tipo_elemento x, lista l) {/*privada*/ pnodo p = l; while (p->siguiente != NULL && p->siguiente->elemento !=x) p = p->siguiente; return p; }
Pilas Colas Listas
Codigo C: listas.c (iii)
void eliminar(tipo_elemento x, lista *l) { pnodo tmp, p = buscar_anterior(x, *l); if (ultimo_elemento(p)) { printf("no encontrado: %d\n", x); exit(EXIT_FAILURE); } tmp = p->siguiente; p->siguiente = tmp->siguiente; free(tmp); }
Algoritmos
Pilas Colas Listas
Codigo C: listas.c (iv)
void insertar(tipo_elemento x, lista *l, pnodo p) { pnodo tmp = (pnodo) malloc(sizeof(struct nodo)); if (tmp == NULL) { printf("memoria agotada\n"); exit(EXIT_FAILURE); } tmp->elemento = x; tmp->siguiente = p->siguiente; p->siguiente = tmp; }
Algoritmos
Pilas Colas Listas
Algoritmos

Pilas Colas Listas

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Pilas Colas Listas

Enviado por

Direitos autorais:

Formatos disponíveis

Pilas Colas Listas

Estructuras de datos: Pilas, Colas, Listas

J. Santiago Jorge sjorge@udc.es