Estructuras de Datos

Unidad 3: Estructuras lineales

Contenido

Listas. .............................................................................................................. 2

Operaciones básicas con listas. .................................................................... 3

Tipos de listas. .............................................................................................. 4

Listas simplemente enlazadas. ..................................................................... 5

Listas doblemente enlazadas. ...................................................................... 7

Listas circulares. ........................................................................................... 8

Aplicaciones. .............................................................................................. 10

Pilas. .............................................................................................................. 11

Representación en memoria estática y dinámica. ...................................... 13

Operaciones básicas con pilas. ................................................................... 18

Aplicaciones. .............................................................................................. 19

Notación infija y postfija. ........................................................................... 20

Recursividad con ayuda de pilas. ................................................................ 22

Colas.............................................................................................................. 23

Representación en memoria estática y dinámica. ...................................... 24

Operaciones básicas con colas. .................................................................. 25

Tipos de colas: Cola simple, Cola circular y Colas dobles. ........................... 26

Aplicaciones: Colas de prioridad. ................................................................ 28

Listas.

Las estructuras lineales son importantes porque aparecen con mucha frecuencia en

situaciones de la vida: Una cola de clientes en un banco, las pilas de platos en un

restaurante.

Sus características son que existe un único elemento, llamado primero y un único

elemento llamado último, cada elemento excepto el primero tiene predecesor (antes) y

cada elemento excepto el último tiene un único sucesor (siguiente).

Operaciones que se pueden realizar con las estructuras lineales son: crear la estructura

vacía, insertar un elemento borrar y obtener un elemento. Para definir claramente el

comportamiento de la estructura es necesario determinar en qué posición se inserta un

elemento nuevo y qué elemento se borrara.

Las principales estructuras lineales son: pilas, colas y listas.

Desde el punto de vista de programación, una lista es una colección de elementos

homogéneos, con una relación lineal entre ellos, es decir, cada elemento excepto el

primero y el último tienen un único sucesor y un único predecesor.

Frecuentemente necesitamos tener almacenadas unas k listas de datos en memoria,

sabiendo que el número total de datos en memoria no sobre pasa n.

Si disponemos de suficiente memoria, podemos guardar en memoria n arreglos de

tamaño k o una matriz de tamaño nk, pero no siempre disponemos de tanta memoria.

Ejemplos:

Lista de estudiantes.

Lista de compras.

Lista de empleados.

Lista de Clientes.

También hay veces que se requieren tener listas de números y agregar números a dichas

listas pero no al final ni al principio, sino en medio.

Para solucionar estos y otros problemas, existen las listas enlazadas.

Las listas enlazadas se mencionan en este documento un poco más adelante.

Operaciones básicas con listas.

Inserción. Esta operación consiste en agregar un nuevo nodo a la lista. Para esta

operación se pueden considerar tres casos:

> Insertar un nodo al inicio.

> Insertar un nodo antes o después de cierto nodo.

> Insertar un nodo al final.

Borrado. La operación de borrado consiste en quitar un nodo de la lista, redefiniendo las

ligas o enlaces que correspondan. Se pueden presentar cuatro casos:

> Eliminar el primer nodo.

> Eliminar el último nodo.

Eliminar un nodo con cierta información.

Recorrido. Esta operación consiste en visitar cada uno de los nodos que forman la lista.

Para recorrer todos los nodos de la lista, se comienza con el primero, se toma el valor del

campo SIG para avanzar al segundo nodo, el campo SIG de este nodo nos dará la dirección

del tercer nodo, y así sucesivamente.

Búsqueda. Esta operación consiste en visitar cada uno de los nodos, tomando al campo

SIG como puntero al siguiente nodo a visitar, para encontrar el elemento buscado.

Tipos de listas.

Entre la descripción de una lista por parte del usuario y la representación final de la misma

en la memoria de la computadora, existen decisiones de diseño por parte del

programador. Por ejemplo: ¿será representada la lista como una estructura secuencial o

enlazada?

En una lista secuencial la colocación física de los elementos coincide con su orden lógico,

es decir, el sucesor de cada elemento está implícito por la posición del elemento.

En una lista enlazada el orden de sus elementos está determinado por un campo de

enlace explícito en cada elemento, en vez de por su posición secuencial.

Listas simplemente enlazadas.

Nodo: cada nodo de una lista contiene al menos dos campos.

El primero que contiene los datos (INFO) y el segundo que es el enlace o apuntador (SIG).

Una lista simplemente enlazada es una colección de nodos, cada uno contiendo datos y un

enlace al siguiente nodo de la lista.

Un apuntador externo nos dice donde comienza la lista. No se puede acceder a los nodos

de la lista directamente, habría que acceder al primer nodo mediante el apuntador

externo, al segundo utilizando el SIG del primero y así sucesivamente.

Ejemplo:

lista es un apuntador que contiene la dirección real en memoria del primer nodo.

lista.info guarda lo que contiene la parte INFO del primer nodo.

lista.sig guarda el contenido de la parte SIG del primer nodo, es decir la dirección de su

siguiente nodo.

Ejemplo:

lista = 50 (imaginemos que 50 es la dirección real en memoria del primer nodo)

lista.info =“A”

lista.sig = 100

• Una variable apuntador o referencia contiene la dirección real en memoria de un

Nodo.

• NULL es una constante que puede ser asignada a una variable apuntador indicando

que no se apunta a nada. (No es lo mismo que cero).

• Ejemplo: LISTA=NULL;

Listas doblemente enlazadas.

Una lista doble, ó doblemente enlazada es una colección de nodos en la que cada nodo

tiene dos punteros, uno de ellos apuntando a su predecesor (ANT) y otra a su sucesor

(SIG). Por medio de estos punteros se podrá enlazar o retroceder a través de la lista, según

se tomen las direcciones de uno y otro puntero.

El nodo que se utiliza es el mismo para construir las listas, salvo que tiene otro apuntador

al nodo anterior.

El puntero anterior (ANT) del primer elemento debe apuntar hacia NULL (el inicio de la

lista).

El puntero siguiente (SIG) del último elemento debe apuntar hacia NULL (el fin de la lista).

Nota: para tener una idea más clara de cómo se trabaja con las listas doblemente

enlazadas dejo el siguiente link para su revisión.

http://es.kioskea.net/faq/2872-listas-doblemente-enlazadas

Listas circulares.

La lista circular es una especie de lista enlazada simple o doblemente enlazada, pero que

posee una característica adicional para el desplazamiento dentro de la lista, “está no tiene

fin”.}

Para que la lista sea sin fin, el puntero siguiente del último elemento apuntará hacia el

primer elemento de la lista en lugar de apuntar al valor NULL, como hemos visto en el

caso de listas doblemente enlazadas.

En las listas circulares, nunca se llega a una posición en la que ya no sea posible

desplazarse.

Cuando se llegue al último elemento, el desplazamiento volverá a comenzar desde el

primer elemento.

Lista circular simplemente enlazada.

Cada nodo tiene un enlace, similar al de la lista simplemente enlazada, excepto que el

siguiente nodo del último apunta al primero.

Como en una lista enlazada simple, los nuevos nodos pueden ser solo eficientemente

insertados después de uno que ya tengamos referenciado. Por esta razón, es usual

quedarse con una referencia solamente al último elemento en una lista enlazada circular

simple, esto nos permite rápidas inserciones al principio, y también permite el acceso al

primer nodo desde el puntero del último nodo.

Lista circular doblemente enlazada.

En este tipo de listas, cada nodo tiene dos enlaces, similares a los de la lista doblemente

enlazada, excepto que el enlace anterior del primer nodo apunta al último y el enlace

siguiente del último nodo apunta al primero. Las inserciones y eliminaciones pueden ser

hechas desde cualquier punto con acceso a algún nodo cercano.

Aunque estructuralmente una lista circular doblemente enlazada no tienen ni un principio

ni un fin, un puntero de acceso externo puede establecer el nodo apuntado que está en la

cabeza, y así mantener el orden también como en una lista doblemente enlazada.

Nota: link con información completa y ejemplos.

http://es.kioskea.net/faq/2972-las-listas-circulares-ring-buffer

Aplicaciones.

Las listas enlazadas son usadas como módulos para otras muchas estructuras de datos,

tales como pilas, colas y sus variaciones.

El campo de datos de un nodo puede ser otra lista enlazada. Mediante mecanismos,

podemos construir muchas estructuras de datos enlazadas con listas; esta práctica tiene

su origen en el lenguaje de programación Lisp ("LISt Processing" (Proceso de LIStas)),

donde las listas enlazadas son una estructura de datos primaria, y ahora es una

característica común en el estilo de programación funcional.

A veces, las listas enlazadas son usadas para implementar arreglos asociativos, y estas en

el contexto de las llamadas listas asociativas. Hay pocas ventajas en este uso de las listas

enlazadas: hay mejores formas de implementar éstas estructuras, por ejemplo con árboles

binarios de búsqueda equilibrados. Sin embargo, a veces una lista enlazada es

dinámicamente creada fuera de un subconjunto propio de nodos semejantes a un árbol, y

son usadas más eficientemente para recorrer ésta serie de datos.

Pilas.

Una pila (stack en inglés) es una lista ordenada 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.

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.

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.

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.

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.

Historia

El método de pila para la evaluación de expresiones fue propuesto en 1955 y dos años

después patentado por Friedrich L. Bauer, quién recibió en 1988 el premio "IEEE Computer

Society Pioneer Award" por su trabajo en el desarrollo de dicha estructura de datos.

Pila como tipo abstracto de datos

A modo de resumen tipo de datos, la pila es un contenedor de nodos y tiene dos

operaciones básicas: push (o apilar) y pop (o desapilar). 'Push' añade un nodo a la parte

superior de la pila, dejando por debajo el resto de los nodos. 'Pop' elimina y devuelve el

actual nodo superior de la pila. Una metáfora que se utiliza con frecuencia es la idea de

una pila de platos en una cafetería con muelle de pila. En esa serie, sólo la primera placa

es visible y accesible para el usuario, todas las demás placas permanecen ocultas. Como se

añaden las nuevas placas, cada nueva placa se convierte en la parte superior de la pila,

escondidos debajo de cada plato, empujando a la pila de placas. A medida que la placa

superior se elimina de la pila, la segunda placa se convierte en la parte superior de la pila.

Dos principios importantes son ilustrados por esta metáfora: En primer lugar la última

salida es un principio, la segunda es que el contenido de la pila está oculto. Sólo la placa

de la parte superior es visible, por lo que para ver lo que hay en la tercera placa, el primer

y segundo platos tendrán que ser retirados.

Representación en memoria estática y dinámica.

PILA ESTATICA EN JAVA

package PILAS; import java.util.Scanner; public class pilaestatica { public int dato; public static int tope; public static int op; int pila[] = new int [10]; public void Insertar(){ if(tope==10){ System.err.println("Pila llena"); } else{ System.out.println("Proporciona el dato para la pila"); System.out.println("dato "+tope); Scanner cap = new Scanner(System.in); pila[tope]= cap.nextInt(); tope++; } } public void Imprimir(){ if(tope>=10){ for(int topeM=tope-1; topeM>=0; topeM--){ System.out.println("\n\n"+pila[topeM]); } } else System.err.println("Pila Vacia No hay nada que mostrar"); } public void Eliminar(){ if(tope==0){ System.err.println("Pila vacia"); } else if(tope==10){//Esto se usa cuando la pila esta totalmente llena, ya que se incremento en insertar y quedo en 10, de lo contrario nos arrojará un error de Array tope--; pila[tope]=0; tope--;//SE vuelva a decrementar para que este en la posicion correcta, porque tenia un numero demás por el insertar } else { pila[tope]=0;

tope--; } } public static void main(String[] args) { pilaestatica p = new pilaestatica(); String r; Scanner cap1= new Scanner(System.in); Scanner cap= new Scanner(System.in); tope=0; h: do{ System.out.println("Menu Principal: \n¿Que desea hacer con la pila?"); System.out.println("1.- Insertar"); System.out.println("2.- Eliminar"); System.out.println("3.- Imprimir"); System.out.println("4.- Salir"); op=cap.nextInt(); switch(op){ case 1: { p.Insertar(); } break; case 2: { p.Eliminar(); } break; case 3: { p.Imprimir(); } break; case 4: { System.out.println("Adios!!!"); } break h; default: System.err.println("Seleccion erronea, teclea otra opcion esa opcion no existe!!!"); } System.out.println("Deseas realizar otra operacion con tu pila?(S/N)"); r=cap1.nextLine(); }while(r.equalsIgnoreCase("S")); } }

PILA DINÁMICA EN JAVA

package estructuradedatospilas; import java.util.ArrayList; import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.Scanner; public class pilas { public static void main(String[] args) { Scanner leer = new Scanner (System.in); int num; int op; LinkedList pila = new LinkedList(); do{ System.out.println("\t menu \t"); System.out.println("operaciones con pilas"); System.out.println("1.-insertar al principio"); System.out.println("2.-insertar al final"); System.out.println("3.-borrar al final"); System.out.println("4.-mostrar la pila"); System.out.println("5.-salir"); System.out.println("\n"); System.out.println("elija la operacion que desee"); op=leer.nextInt(); switch (op){ case 1: System.out.println("inserte numero"); num=leer.nextInt(); pila.addFirst(num); break; case 2: System.out.println("inserte numero"); num=leer.nextInt(); pila.addLast(num); break; case 3: System.out.println("se borra el nodo final"); pila.removeLast(); break; case 4: System.out.println("la pila es la siguiente"); List pila2= new ArrayList(pila); Iterator it = pila2.iterator();

while (it.hasNext()){ System.out.println(it.next()+""); } break; case 5: System.out.println("al rato"); break; } } while (op !=5); } }

Implementación en Java

public class Nodo<tipo> { public tipo dato; private Nodo<tipo> siguiente; public Nodo(tipo Dato) { dato = Dato; siguiente = null; } public void conectar(Nodo<tipo> elSiguiente) { siguiente = elSiguiente; } public Nodo<tipo> getSiguiente() { return siguiente; } } public class Pila<tipo> { Nodo<tipo> cima; public Pila() { cima = null; } public int tamano() { Nodo<tipo> lectorAuxiliar = cima; int contadorDeDatos = 0; while (lectorAuxiliar != null) { contadorDeDatos++; lectorAuxiliar = lectorAuxiliar.getSiguiente(); }

return contadorDeDatos; } public void apilar(tipo datoNuevo) { Nodo<tipo> nuevo = new Nodo<tipo>(datoNuevo); nuevo.conectar(cima); cima = nuevo; } public tipo desapilar() { tipo dato = cima.dato; cima = cima.getSiguiente(); return dato; } public tipo getCima() { return cima.dato; } public boolean estaVacia() { return cima == null; } public String toString() { Nodo<tipo> lectorAuxiliar = cima; String respuesta = "IN/OUT <->"; while (lectorAuxiliar != null) { respuesta += " [" + lectorAuxiliar.dato.toString() + "] "; lectorAuxiliar = lectorAuxiliar.getSiguiente(); } return respuesta;

Operaciones básicas con pilas.

Operaciones

Una pila cuenta con 2 operaciones imprescindibles: apilar y desapilar, a las que en las

implementaciones modernas de las pilas se suelen añadir más de uso habitual.

Crear: se crea la pila vacía. (constructor)

Tamaño: regresa el número de elementos de la pila. (size)

Apilar: se añade un elemento a la pila.(push)

Desapilar: se elimina el elemento frontal de la pila.(pop)

Cima: devuelve el elemento que esta en la cima de la pila. (top o peek)

Vacía: devuelve cierto si la pila está vacía o falso en caso contrario (empty).

Aplicaciones.

Las pilas son utilizadas ampliamente para solucionar una amplia variedad de problemas.

Se utiliza en compiladores, sistemas operativos y en programas de aplicación.

Las pilas son un EDs muy usadas en la solución de diversos tipos de problemas, en el área

de computación. Algunos de los casos más representativos de aplicación de las mismas

son:

Llamadas a subprogramas

Recursividad

Tratamiento de expresiones aritméticas

Ordenación

Notación infija y postfija.

Recursividad con ayuda de pilas.

Implementar los ejemplos vistos en recursividad con ayuda de pilas…

Colas.

La particularidad de una estructura de datos de cola es el hecho de que sólo podemos

acceder al primer y al último elemento de la estructura. Así mismo, los elementos sólo se

pueden eliminar por el principio y sólo se pueden añadir por el final de la cola.

Ejemplos de colas en la vida real serían: personas comprando en un supermercado,

esperando para entrar a ver un partido de béisbol, esperando en el cine para ver una

película, una pequeña peluquería, etc. La idea esencial es que son todos líneas de espera.

Representación en memoria estática y dinámica.

Representación en memoria estática

Elem 1 0

Elem 2 1

Elem 3 2

Elem 4 3

Elem 5 4

Elem 6 5

Elem 7 6

Elem 8 7

… …

… …

… …

Elem n n-1

Representación en memoria dinámica

Elem 1 Elem 2 Elem 3 … Elem n

Operaciones básicas con colas.

Crear: se crea la cola vacía.

Encolar: (añadir, entrar, insertar): se añade un elemento a la cola. Se añade al final

de esta.

Desencolar: (sacar, salir, eliminar): se elimina el elemento frontal de la cola, es

decir, el primer elemento que entró.

Frente: (consultar, front): se devuelve el elemento frontal de la cola, es decir, el

primer elemento que entró.

Tipos de colas: Cola simple, Cola circular y Colas dobles.

Cola simple

La cola simple es una cola normal, como la que usualmente hacen los seres humanos al

pagar en un supermercado, o al ir a un banco: Un elemento tras otro, y el primero que

llega es al primero que se atiende. El último de la fila tiene un "indicador" para decir que

es el último elemento, así alguien que llegue a la cola después sabrá dónde debe ubicarse.

Cola circular

Una cola circular o anillo es una estructura de datos en la que los elementos están de

forma circular y cada elemento tiene un sucesor y un predecesor. Los elementos pueden

cosultarse, añadirse y eliminarse únicamente desde la cabeza del anillo que es una

posición distinguida. Existen dos operaciones de rotaciones, una en cada sentido, de

manera que la cabeza del anillo pasa a ser el elemento sucesor, o el predecesor,

respectivamente, de la cabeza actual.

Colas dobles

La bicola o doble cola es un tipo de cola especial que permiten la inserción y eliminación

de elementos de ambos extremos de la cola.

Puede representarse a partir de un vector y dos índices, siendo su representación más

frecuente una lista circular doblemente enlazada.

Todas las operaciones de este tipo de datos tienen coste constante.

// ArrayCircularQueue.java package com.javajeff.cds; public class ArrayCircularQueue implements Queue { private int front = 0, rear = 0; private Object [] queue; public ArrayCircularQueue (int maxElements) { queue = new Object [maxElements]; }

public void insert (Object o) { int temp = rear; rear = (rear + 1) % queue.length; if (front == rear) { rear = temp; throw new FullQueueException (); } queue [rear] = o; } public boolean isEmpty () { return front == rear; } public boolean isFull () { return ((rear + 1) % queue.length) == front; } public Object remove () { if (front == rear) throw new EmptyQueueException (); front = (front + 1) % queue.length; return queue [front]; } }

Aplicaciones: Colas de prioridad.

Una cola de prioridades es una estructura de datos en la que los elementos se atienden

en el orden indicado por una prioridad asociada a cada uno. Si varios elementos tienen la

misma prioridad, se atenderán de modo convencional según la posición que ocupen.

Características generales

Este tipo especial de colas tienen las mismas operaciones que las colas , pero con la

condición de que los elementos se atienden en orden de prioridad.

Ejemplos de la vida diaria serían la sala de urgencias de un hospital, ya que los enfermos

se van atendiendo en función de la gravedad de su enfermedad.

Entendiendo la prioridad como un valor numérico y asignando a altas prioridades valores

pequeños, las colas de prioridad nos permiten añadir elementos en cualquier orden y

recuperarlos de menor a mayor.

Implementación

Hay 2 formas de implementación:

1. Añadir un campo a cada nodo con su prioridad. Resulta conveniente mantener la cola ordenada por orden de prioridad.

2. Crear tantas colas como prioridades haya, y almacenar cada elemento en su cola. Tipos

Colas de prioridades con ordenamiento ascendente: en ellas los elementos se insertan de forma arbitraria, pero a la hora de extraerlos, se extrae el elemento de menor prioridad.

Colas de prioridades con ordenamiento descendente: son iguales que la colas de prioridad con ordenamiento ascendente, pero al extraer el elemento se extrae el de mayor prioridad.

Operaciones

Las operaciones de las colas de prioridad son las mismas que las de las colas genéricas:

Crear: se crea la cola vacía.

Añadir: se añade un elemento a la cola, con su correspondiente prioridad.

Eliminar: se elimina el elemento frontal de la cola.

Frente: se devuelve el elemento frontal de la cola. Destruye: elimina la cola de memoria.

Implementación en Java Partimos a partir de la implementación en Java utilizando clases. package colaPrioridadSimpleEnlazada; import colaException.*; public class ColaPrioridad<T> implements colaPrioridadInterface.ColaPrioridad { class Celda<T> { T elemento; int prioridad; Celda sig; } private Celda cola; public ColaPrioridad() { cola = new Celda(); cola.sig = null; } public boolean vacia() { return (cola.sig==null); } public <T> primero() throws ColaVaciaException { if (vacia()) throw new ColaVaciaException(); return cola.sig.elemento; } public int primero_prioridad() throws ColaVaciaException { if (vacia()) throw new ColaVaciaException(); return cola.sig.prioridad; } public void inserta(T elemento, int prioridad) { Celda<T> p,q; boolean encontrado = false; p = cola; while((p.sig!=null)&&(!encontrado)) { if (p.sig.prioridad<prioridad) encontrado = true; else p = p.sig; } q = p.sig; p.sig = new Celda(); p = p.sig; p.elemento = elemento; p.prioridad = prioridad; p.sig = q; } public void suprime() throws ColaVaciaException { if (vacia()) throw new ColaVaciaException(); cola = cola.sig; } } // fin clase ColaPrioridad