Listas, Pilas y Colas

Edison Sepúlveda

10-1010

Lista (estructura de datos)

• En Ciencias de la Computación, una lista enlazada es una de las estructuras de datos fundamentales, y puede ser usada para implementar otras estructuras de datos. Consiste en una secuencia de nodos, en los que se guardan campos de datos arbitrarios y una o dos referencias (punteros) al nodo anterior o posterior. El principal beneficio de las listas enlazadas respecto a los array convencionales es que el orden de los elementos enlazados puede ser diferente al orden de almacenamiento en la memoria o el disco, permitiendo que el orden de recorrido de la lista sea diferente al de almacenamiento.

Lista (estructura de datos)

• Una lista enlazada es un tipo de dato auto-referenciado porque contienen un puntero o link a otro dato del mismo tipo. Las listas enlazadas permiten inserciones y eliminación de nodos en cualquier punto de la lista en tiempo constante (suponiendo que dicho punto está previamente identificado o localizado), pero no permiten un acceso aleatorio. Existen diferentes tipos de listas enlazadas: Lista Enlazadas Simples, Listas Doblemente Enlazadas, Listas Enlazadas Circulares y Listas Enlazadas Doblemente Circulares.

Lista (estructura de datos)

• Las listas enlazadas pueden ser implementadas en muchos lenguajes. Lenguajes tales como Lisp y Scheme tiene estructuras de datos ya construidas, junto con operaciones para acceder a las listas enlazadas. Lenguajes imperativos u orientados a objetos tales como C o C++ y Java, respectivamente, disponen de referencias para crear listas enlazadas.

Pila

• Una pila (stack en inglés) es una lista ordinal o estructura de datos en la que el modo de acceso a sus elementos es de tipo LIFO (del inglés Last In First Out, último en entrar, primero en salir) que permite almacenar y recuperar datos. Esta estructura se aplica en multitud de ocasiones en el área de informática debido a su simplicidad y ordenación implícita de la propia estructura.

Pila

• Para el manejo de los datos se cuenta con dos operaciones básicas: apilar (push), que coloca un objeto en la pila, y su operación inversa, retirar (o desapilar, pop), que retira el último elemento apilado.

Pila

• En cada momento sólo se tiene acceso a la parte superior de la pila, es decir, al último objeto apilado (denominado TOS, Top of Stack en inglés).

• La operación retirar permite la obtención de este elemento, que es retirado de la pila permitiendo el acceso al siguiente (apilado con anterioridad), que pasa a ser el nuevo TOS.

Pila

• Por analogía con objetos cotidianos, una operación apilar equivaldría a colocar un plato sobre una pila de platos, y una operación retirar a retirarlo.

Pila

Las pilas suelen emplearse en los siguientes contextos:

• Evaluación de expresiones en notación postfija (notación polaca inversa).

• Reconocedores sintácticos de lenguajes independientes del contexto

• Implementación de recursividad.

Cola

• Una cola es una estructura de datos, caracterizada por ser una secuencia de elementos en la que la operación de inserción push se realiza por un extremo y la operación de extracción pop por el otro. También se le llama estructura FIFO (del inglés First In First Out), debido a que el primer elemento en entrar será también el primero en salir.

Cola

• Las colas se utilizan en sistemas informáticos, transportes y operaciones de investigación (entre otros), dónde los objetos, personas o eventos son tomados como datos que se almacenan y se guardan mediante colas para su posterior procesamiento. Este tipo de estructura de datos abstracta se implementa en lenguajes orientados a objetos mediante clases, en forma de listas enlazadas.

Diferencias entre pila y cola

• La pila es un sistema LIFO (Last In First Out), osea lo que entra de ultimo a la lista sera lo primero en salir, mientras que la cola es un FIFO (First In First Out) en la que lo primero en entrar sera lo primero en salir.

Operaciones basicas de una lista.

• Recorrer los elementos hacia adelante• Recorrer los elementos hacia atras• Insertar un nuevo elemento al principio• Insertar un nuevo elemento al final• Insertar un nuevo elemento antes de otro• Insertar un nuevo elemento despues de otro• Remover un elemento del principio• Remover un elemento que esta antes que otro• Remover un elemento que esta despues de otro• Remover un elemento del principio• Remover un elemento del final

Diferencia entre estruturas estaticas y dinamicas

• Las estructuras de datos estáticas:

• Son aquellas en las que el tamaño ocupado en memoria se define antes de que el programa se ejecute y no puede modificarse dicho tamaño durante la ejecución del programa.

Diferencia entre estruturas estaticas y dinamicas

• Estas estructuras están implementadas en casi todos los lenguajes.

• Su principal característica es que ocupan solo una casilla de memoria, por lo tanto una variable simple hace referencia a un único valor a la vez, dentro de este grupo de datos se encuentra: enteros, reales, caracteres, boléanos, enumerados y subrangos (los últimos no existen en algunos lenguajes de programación)

Diferencia entre estruturas estaticas y dinamicas

• Las estructuras de datos dinámicas:

• No tienen las limitaciones o restricciones en el tamaño de memoria ocupada que son propias de las estructuras estáticas.

Diferencia entre estruturas estaticas y dinamicas

• Mediante el uso de un tipo de datos especifico, denominado puntero, es posible construir estructuras de datos dinámicas que no son soportadas por la mayoría de los lenguajes, pero que en aquellos que si tienen estas características ofrecen soluciones eficaces y efectivas en la solución de problemas complejos.

Diferencia entre estruturas estaticas y dinamicas

• Se caracteriza por el hecho de que con un nombre se hace referencia a un grupo de casillas de memoria. Es decir un dato estructurado tiene varios componentes.

Implementación de una lista enlazada en C

• #include <stdio.h> /* for printf */• #include <stdlib.h> /* for malloc */• • typedef struct ns {• int data;• struct ns *next;• } node;• • node *list_add(node **p, int i) {• /* algunos compiladores no requieren un casting del valor del retorno para malloc

*/• node *n = (node *)malloc(sizeof(node));• if (n == NULL)• return NULL;• n->next = *p; • *p = n;• n->data = i;

Implementación de una lista enlazada en C

• return n;• }• • void list_remove(node **p) { /* borrar cabeza*/• if (*p != NULL) {• node *n = *p;• *p = (*p)->next;• free(n);• }• }• • node **list_search(node **n, int i) {• while (*n != NULL) {• if ((*n)->data == i) {• return n;• }

Implementación de una lista enlazada en C

• n = &(*n)->next;• }• return NULL;• }• • void list_print(node *n) {• if (n == NULL) {• printf("lista esta vacía\n");• }• while (n != NULL) {• printf("print %p %p %d\n", n, n->next, n->data);• n = n->next;• }• }• • int main(void) {

Implementación de una lista enlazada en C

• node *n = NULL;• • list_add(&n, 0); /* lista: 0 */• list_add(&n, 1); /* lista: 1 0 */• list_add(&n, 2); /* lista: 2 1 0 */• list_add(&n, 3); /* lista: 3 2 1 0 */• list_add(&n, 4); /* lista: 4 3 2 1 0 */• list_print(n);• list_remove(&n); /* borrar primero(4) */• list_remove(&n->next); /* borrar nuevo segundo (2) */• list_remove(list_search(&n, 1)); /* eliminar la celda que contiene el 1 (primera) */• list_remove(&n->next); /* eliminar segundo nodo del final(0)*/• list_remove(&n); /* eliminar ultimo nodo (3) */• list_print(n);• • return 0;• }

Colas en C++

• #ifndef COLA• #define COLA // Define la cola• template <class T>• class Cola{• private:• struct Nodo{• T elemento;• struct Nodo* siguiente; // coloca el nodo en la

segunda posición• }* primero;• struct Nodo* ultimo;

Colas en C++

• unsigned int elementos;• public:• Cola(){• elementos = 0;• }• ~Cola(){• while (elementos != 0) pop();• }• void push(const T& elem){• Nodo* aux = new Nodo;• aux->elemento = elem;

Colas en C++

• if (elementos == 0) primero = aux;• else ultimo->siguiente = aux;• ultimo = aux;• ++elementos;• }• void pop(){• Nodo* aux = primero;• primero = primero->siguiente;• delete aux;• --elementos;• }

Colas en C++

• T consultar() const{• return primero->elemento;• }• bool vacia() const{• return elementos == 0;• }• unsigned int size() const{• return elementos;• }• };• #endif

PILA CON PUNTEROS EN C++

• #include<stdio.h>• #include<conio.h>• • #define TAM 6• #define MAX TAM-1• • typedef struct• {• int tope;• int item[TAM];

PILA CON PUNTEROS EN C++

• }pila;• • • int full(pila *);• int empty(pila *);• void push(pila *, int);• void pop(pila *,int *);• • • void main()

PILA CON PUNTEROS EN C++

• {• pila p,t;• int dato,opc,elemento,flag=0;• p.tope=0;• do• {• clrscr();• printf("\nMENU-PILA");• printf("\n1-> Insertar elemento");• printf("\n2-> Eliminar elemento");

PILA CON PUNTEROS EN C++

• printf("\n3-> Eliminar elemento X");• printf("\n4-> Visualizar");• printf("\n5-> Salir");• printf("\n\nDe su opci¢n : ");• scanf("%d",&opc);• switch(opc)• {• case 1:• if(!full(&p)) // si pila no esta llena• {• printf("\nDe el elemento a insertar: ");

PILA CON PUNTEROS EN C++

• scanf("%d",&dato);• push(&p,dato);• printf("\nElemento insertado...");• }• else• {• printf("\nERROR: Pila llena");• }• break;•

PILA CON PUNTEROS EN C++

• case 2:• if(!empty(&p))• {• pop(&p,&dato);• printf("\nEl elemento eliminado es %d",dato);• }• else• {• printf("\nERROR: Pila vac¡a");• }• break;

PILA CON PUNTEROS EN C++

• • case 3:• if(!empty(&p))• {• printf("eliminar elemento seleccionado: ");• scanf("%d",&elemento);• • if(p.tope != 1){• t.tope=0;• do

PILA CON PUNTEROS EN C++

• {• pop(&p,&dato);• if (dato != elemento)• { • push(&t,dato);• } • }while(!empty(&p));• • do• {• pop(&t,&dato);

PILA CON PUNTEROS EN C++

• push(&p,dato);• }while(!empty(&t));• }• else if(dato == elemento){pop(&p,&dato);}• else {printf("el elemento no se encuentra en la

pila");}• }• else• {• printf("\nERROR: Pila vac¡a");• }

PILA CON PUNTEROS EN C++

• break;• • • case 4:• if(!empty(&p))• {• t.tope=0;• do• {• pop(&p,&dato);• printf("\n%d",dato);

PILA CON PUNTEROS EN C++

• push(&t,dato);• }while(!empty(&p));• do• {• pop(&t,&dato);• push(&p,dato);• }while(!empty(&t));• }• else• {

PILA CON PUNTEROS EN C++

• printf("\nERROR: Pila vac¡a");• }• break;• case 5:• flag=1;• break;• case 6:• flag=0;• break;• • default:

PILA CON PUNTEROS EN C++

• printf("\nOpci¢n no v lida...");• }• if(!flag)• {• printf("\n\nPresione una tecla para continuar...");• getch();• }• }while(!flag);• • }

PILA CON PUNTEROS EN C++

• • int full(pila *p)• {• return(p->tope==MAX);• }• • int empty(pila *p)• {• return(p->tope==0);• }•

PILA CON PUNTEROS EN C++

• void push(pila *p,int dato)• {• if(!full(p))• {• (p->tope)++;• p->item[p->tope]=dato; //elemento[1]=dato• }• else• printf("\nOVERFLOW");• }

PILA CON PUNTEROS EN C++

• • void pop(pila *p,int *dato)• {• if(!empty(p))• {• *dato=p->item[p->tope];• (p->tope)--;• }• else• printf("\nUNDERFLOW");• }