Estructuras de Datos

Unidad 3: Estructuras lineales

Contenido
Listas. .............................................................................................................. 2
Operaciones bsicas con listas. .................................................................... 3
Tipos de listas. .............................................................................................. 4
Listas simplemente enlazadas. ..................................................................... 5
Listas doblemente enlazadas. ...................................................................... 7
Listas circulares. ........................................................................................... 8
Aplicaciones. .............................................................................................. 10
Pilas. .............................................................................................................. 11
Representacin en memoria esttica y dinmica. ...................................... 13
Operaciones bsicas con pilas. ................................................................... 18
Aplicaciones. .............................................................................................. 19
Notacin infija y postfija. ........................................................................... 20
Recursividad con ayuda de pilas. ................................................................ 22
Colas.............................................................................................................. 23
Representacin en memoria esttica y dinmica. ...................................... 24
Operaciones bsicas 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 caractersticas 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
vaca, insertar un elemento borrar y obtener un elemento. Para definir claramente el
comportamiento de la estructura es necesario determinar en qu posicin 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 programacin, una lista es una coleccin de elementos
homogneos, con una relacin 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 nmero total de datos en memoria no sobre pasa n.
Si disponemos de suficiente memoria, podemos guardar en memoria n arreglos de
tamao k o una matriz de tamao nk, pero no siempre disponemos de tanta memoria.
Ejemplos:

Lista de estudiantes.
Lista de compras.
Lista de empleados.

Lista de Clientes.

Tambin hay veces que se requieren tener listas de nmeros y agregar nmeros 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 ms adelante.

Operaciones bsicas con listas.

Insercin. Esta operacin consiste en agregar un nuevo nodo a la lista. Para esta
operacin se pueden considerar tres casos:
> Insertar un nodo al inicio.
> Insertar un nodo antes o despus de cierto nodo.
> Insertar un nodo al final.
Borrado. La operacin 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 informacin.
Recorrido. Esta operacin 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 direccin
del tercer nodo, y as sucesivamente.
Bsqueda. Esta operacin 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 descripcin de una lista por parte del usuario y la representacin final de la misma
en la memoria de la computadora, existen decisiones de diseo por parte del
programador. Por ejemplo: ser representada la lista como una estructura secuencial o
enlazada?
En una lista secuencial la colocacin fsica de los elementos coincide con su orden lgico,
es decir, el sucesor de cada elemento est implcito por la posicin del elemento.

En una lista enlazada el orden de sus elementos est determinado por un campo de
enlace explcito en cada elemento, en vez de por su posicin 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 coleccin 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, habra 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 direccin 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 direccin de su
siguiente nodo.
Ejemplo:
lista = 50 (imaginemos que 50 es la direccin real en memoria del primer nodo)
lista.info =A
lista.sig = 100

Una variable apuntador o referencia contiene la direccin 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 coleccin 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 travs de la lista, segn
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 ms clara de cmo se trabaja con las listas doblemente
enlazadas dejo el siguiente link para su revisin.
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 caracterstica 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 posicin 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 despus de uno que ya tengamos referenciado. Por esta razn, es usual
quedarse con una referencia solamente al ltimo elemento en una lista enlazada circular
simple, esto nos permite rpidas inserciones al principio, y tambin 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 algn 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 tambin como en una lista doblemente enlazada.

Nota: link con informacin completa y ejemplos.

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

Aplicaciones.
Las listas enlazadas son usadas como mdulos 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 prctica tiene
su origen en el lenguaje de programacin Lisp ("LISt Processing" (Proceso de LIStas)),
donde las listas enlazadas son una estructura de datos primaria, y ahora es una
caracterstica comn en el estilo de programacin 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 bsqueda equilibrados. Sin embargo, a veces una lista enlazada es
dinmicamente creada fuera de un subconjunto propio de nodos semejantes a un rbol, y
son usadas ms eficientemente para recorrer sta serie de datos.

Pilas.
Una pila (stack en ingls) es una lista ordenada o estructura de datos en la que el modo de
acceso a sus elementos es de tipo LIFO (del ingls 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 informtica debido a su simplicidad y ordenacin
implcita de la propia estructura.
Para el manejo de los datos se cuenta con dos operaciones bsicas: apilar (push), que
coloca un objeto en la pila, y su operacin inversa, retirar (o desapilar, pop), que retira el
ltimo elemento apilado.
En cada momento slo se tiene acceso a la parte superior de la pila, es decir, al ltimo
objeto apilado (denominado TOS, Top of Stack en ingls). La operacin retirar permite la
obtencin 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 analoga con objetos cotidianos, una operacin apilar equivaldra a colocar un plato
sobre una pila de platos, y una operacin retirar a retirarlo.
Las pilas suelen emplearse en los siguientes contextos:

Evaluacin de expresiones en notacin postfija (notacin polaca inversa).

Reconocedores sintcticos de lenguajes independientes del contexto

Implementacin de recursividad.

Historia
El mtodo de pila para la evaluacin de expresiones fue propuesto en 1955 y dos aos
despus patentado por Friedrich L. Bauer, quin 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 bsicas: push (o apilar) y pop (o desapilar). 'Push' aade 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 metfora que se utiliza con frecuencia es la idea de

una pila de platos en una cafetera con muelle de pila. En esa serie, slo la primera placa
es visible y accesible para el usuario, todas las dems placas permanecen ocultas. Como se
aaden 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 metfora: En primer lugar la ltima
salida es un principio, la segunda es que el contenido de la pila est oculto. Slo 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 tendrn que ser retirados.

Representacin en memoria esttica y dinmica.

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 dems 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: \nQue 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 DINMICA 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); }

Implementacin 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 bsicas 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 aadir ms de uso habitual.

Crear: se crea la pila vaca. (constructor)

Tamao: regresa el nmero de elementos de la pila. (size)

Apilar: se aade 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)

Vaca: devuelve cierto si la pila est vaca 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 aplicacin.
Las pilas son un EDs muy usadas en la solucin de diversos tipos de problemas, en el rea
de computacin. Algunos de los casos ms representativos de aplicacin de las mismas
son:

Llamadas a subprogramas
Recursividad
Tratamiento de expresiones aritmticas
Ordenacin

Notacin 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 slo podemos
acceder al primer y al ltimo elemento de la estructura. As mismo, los elementos slo se
pueden eliminar por el principio y slo se pueden aadir por el final de la cola.
Ejemplos de colas en la vida real seran: personas comprando en un supermercado,
esperando para entrar a ver un partido de bisbol, esperando en el cine para ver una
pelcula, una pequea peluquera, etc. La idea esencial es que son todos lneas de espera.

Representacin en memoria esttica y dinmica.

Representacin en memoria esttica
Elem 1
Elem 2
Elem 3
Elem 4
Elem 5
Elem 6
Elem 7
Elem 8

Elem n

0
1
2
3
4
5
6
7

n-1

Representacin en memoria dinmica

Elem 1

Elem 2

Elem 3

Elem n

Operaciones bsicas con colas.

Crear: se crea la cola vaca.

Encolar: (aadir, entrar, insertar): se aade un elemento a la cola. Se aade 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 despus sabr dnde debe ubicarse.

Cola circular
Una cola circular o anillo es una estructura de datos en la que los elementos estn de
forma circular y cada elemento tiene un sucesor y un predecesor. Los elementos pueden
cosultarse, aadirse y eliminarse nicamente desde la cabeza del anillo que es una
posicin 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 insercin y eliminacin
de elementos de ambos extremos de la cola.
Puede representarse a partir de un vector y dos ndices, siendo su representacin ms
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 atendern de modo convencional segn la posicin que ocupen.
Caractersticas generales
Este tipo especial de colas tienen las mismas operaciones que las colas , pero con la
condicin de que los elementos se atienden en orden de prioridad.
Ejemplos de la vida diaria seran la sala de urgencias de un hospital, ya que los enfermos
se van atendiendo en funcin de la gravedad de su enfermedad.
Entendiendo la prioridad como un valor numrico y asignando a altas prioridades valores
pequeos, las colas de prioridad nos permiten aadir elementos en cualquier orden y
recuperarlos de menor a mayor.
Implementacin
Hay 2 formas de implementacin:
1. Aadir 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 genricas:

Crear: se crea la cola vaca.

Aadir: se aade 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.

Implementacin en Java
Partimos a partir de la implementacin 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