Estructura de Datos 1

APUNTES DE ESTRUCTURAS DE DATOS Un enfoque orientado a objetos RODOLFO E. ARANA GONZALES

SASCI 01/01/2009

APUNTES DE ESTRUCTURAS DE DATOS Un enfoque orientado a objetos RODOLFO E. ARANA GONZALES

Prefacio

Este material ha sido escrito en forma paralela al desenvolvimiento de cursos de Estructuras de

datos dictados en las universidades de Santa Cruz de la Sierra, con el afn de proporcionar al

estudiante una gua para aprender estructuras de datos en forma prctica. Asimismo, presentar

y entender ciertos conceptos, que a menudo no se abordan con la claridad necesaria, como ser

el manejo de punteros. Tambin se mira la temtica de las estructuras de datos desde un

enfoque orientado a objetos, explicando que esta metodologa es una especie de evolucin

natural de los tipos abstractos de datos en cuanto a su implementacin.

Estos apuntes estn dedicados a todos aquellos que estn dispuestos a sacrificar horas de

descanso o diversin, con el fin de superarse permanentemente, hacerse mejores y hacer un

mundo mejor.

El autor

Tabla de contenido

PREFACIO............................................................................................................................................................ 3

1. ESTRUCTURAS Y ABSTRACCIN DE DATOS ...................................................................................................... 6

1.1. INTRODUCCIN A LAS ESTRUCTURAS DE DATOS ........................................................................................... 6 1.2. ABSTRACCIN DE DATOS .............................................................................................................................. 6 1.3. CLASIFICACIN DE LAS ESTRUCTURAS DE DATOS ......................................................................................................... 2 1.4. TIPOS ABSTRACTOS DE DATOS............................................................................................................................... 2

Operaciones con arreglos ................................................................................................................................. 4 1.6 BSQUEDA Y CLASIFICACIN DE ARREGLOS ................................................................................................................ 4

Bsqueda secuencial ........................................................................................................................................ 5 Bsqueda binaria ............................................................................................................................................. 5 Clasificacin ..................................................................................................................................................... 6 Mtodo de intercambio o de Burbuja ............................................................................................................... 7 Mtodo de la Baraja ........................................................................................................................................ 8 Metodo QuickSort ............................................................................................................................................ 8

2. ESTRUCTURA DE LENGUAJES DE PROGRAMACIN ORIENTADOS A OBJETO. .................................................... 10

2.1 . ASPECTOS GENERALES DE LOS LENGUAJES .......................................................................................... 10 2.2 LENGUAJES ORIENTADOS A OBJETO ........................................................................................................................ 12 2.2. ESTRUCTURAS DE DATOS ORIENTADAS A OBJETOS ..................................................................................................... 14 2.4. RECURSIVIDAD Y LENGUAJES DE PROGRAMACIN OO ................................................................................................ 15

Concepto de Recursividad............................................................................................................................... 15 1. Clculo de la potencia................................................................................................................................. 17 2. La suma de forma recursiva ........................................................................................................................ 18 3. Bsqueda lineal recursiva (con dos casos base) ........................................................................................... 18 4. Bsqueda Binaria recursiva ........................................................................................................................ 18

3. ALMACENAMIENTO ESTTICO EN SECUENCIA LISTAS .................................................................................... 20

3.1 ASPECTOS GENERALES DE LISTAS ........................................................................................................................... 20 3.2. PILAS ............................................................................................................................................................ 20

Aplicacin de pila: Evaluacin de expresiones ................................................................................................. 21 Transformacin de infija a postfija ................................................................................................................. 22

3.3. COLAS ........................................................................................................................................................... 24 Operaciones Bsicas....................................................................................................................................... 25 Aplicaciones ................................................................................................................................................... 25

IMPLEMENTACIN DE COLAS EN C++ ........................................................................................................................... 26 Tipos de colas ................................................................................................................................................ 27

3.4. PROBLEMAS DE APLICACIN DE PILAS, COLAS Y LISTAS................................................................................................ 27

4. ALMACENAMIENTO DINMICO ........................................................................................................................ 30

4.1 MANEJO DINMICO DE LA MEMORIA LOS PUNTEROS ............................................................................................... 30 Cmo se almacena una variable? ................................................................................................................. 30 Qu son los punteros? .................................................................................................................................. 32

4.2. LISTAS ENCADENADAS ....................................................................................................................................... 34 4.3 DISEO E IMPLEMENTACIN DINMICA DE LISTAS ENCADENADAS .................................................................................. 35

Estructura de Nodo ........................................................................................................................................ 35 Estructura de Lista encadenada ...................................................................................................................... 36 Esquema y diseo de una lista enlazada ......................................................................................................... 36 Operacin de Recorrido .................................................................................................................................. 38

Operacin de Insercin ................................................................................................................................... 39 Operacin de Borrado .................................................................................................................................... 40 Operacin de Bsqueda ................................................................................................................................. 40

4.4. IMPLEMENTACIN DINMICA DE ESTRUCTURAS DE DATOS .......................................................................................... 40 Implementacin de pilas con punteros............................................................................................................ 40

5. ARBOLES Y GRAFOS ........................................................................................................................................... 41

55..11 AARRBBOOLLEESS BBIINNAARRIIOOSS ............................................................................................................................................ 41 Definicin de rbol ......................................................................................................................................... 42 Formas de representacin .............................................................................................................................. 42 Declaracin de rbol binario........................................................................................................................... 43 Recorridos sobre rboles binarios ................................................................................................................... 43 Construccin de un rbol binario .................................................................................................................... 45

55..22 RRBBOOLL BBIINNAARRIIOO DDEE BBSSQQUUEEDDAA ............................................................................................................................. 47 Operaciones bsicas sobre rboles binarios de bsqueda................................................................................ 48 Ejercicio resuelto ............................................................................................................................................ 51 Aplicacin prctica de un rbol binario de bsqueda ...................................................................................... 51 Ejercicios propuestos ...................................................................................................................................... 52

5.3. RBOLES B ..................................................................................................................................................... 54 Utilizacin de los Arboles B ............................................................................................................................. 54 Funcionamiento ............................................................................................................................................. 55 Qu es un Arbol B? ....................................................................................................................................... 57 Costos ............................................................................................................................................................ 61 Casos especiales............................................................................................................................................. 62 Conclusin ..................................................................................................................................................... 63

TRABAJOS PRACTICOS ............................................................................................................................... 64 BIBLIOGRAFA .................................................................................................................................................... 67

1. Estructuras y abstraccin de datos

1.1. Introduccin a las estructuras de datos

Los programas estn constituidos fundamentalmente por algoritmos y estructuras de datos. Esto

significa que los algoritmos se ejecutan sobre estas estructuras de datos. Esto permite ver que las

estructuras de datos son una parte fundamental de la programacin de computadoras, en

particular; y del procesamiento de informacin, en general

Una estructura de datos es una coleccin de datos que pueden ser caracterizados por su

organizacin y las operaciones que se definen sobre ella.

Se trata de un conjunto de variables de un determinado tipo agrupadas y organizadas de alguna

manera para representar un comportamiento. Lo que se pretende con las estructuras de datos es

facilitar un esquema lgico para manipular los datos en funcin del problema que haya que tratar

y el algoritmo para resolverlo. En algunos casos la dificultad para resolver un problema radica en

escoger la estructura de datos adecuada. Y, en general, la eleccin del algoritmo y de las

estructuras de datos que manipular estar muy relacionada.

1.2. Abstraccin de datos

El procesamiento de informacin en una computadora requiere hacer una tarea llamada

abstraccin de datos, que consiste en ver las cosas del mundo real en una forma integral, en el

sentido de que se ignoran algunas propiedades irrelevantes de los objetos reales, es decir, se

simplifican. De este modo se hace una seleccin de los datos ms representativos de la realidad a

partir de los cuales se los pueda obtener un modelo del objeto para trabajar el computador y

obtener determinados resultados.

As los lenguajes de programacin proporcionan una serie de tipos de datos simples, como son

los nmeros enteros, caracteres, nmeros reales. En realidad los lenguajes suministran un modelo

de datos que son un subconjunto finito de stos, pues la memoria del ordenador es finita. Los

punteros o apuntadores (si los tiene) son tambin un tipo de datos. El tamao de cada tipo de

datos depende de la mquina y del compilador sobre los que se trabaja.

En principio, conocer la representacin interna de estos tipos de datos no es necesaria para

realizar un programa, pero s puede afectar en algunos casos al rendimiento. Sin embargo, cuando

se trata con problemas donde el tiempo o el espacio de almacenamiento es primordial, habr que

entender en detalle no solo los alcances de los tipos de datos sino tambin de su forma de

almacenamiento.

Apuntes de Estructuras de datos SASCI Rodolfo Arana Gonzales

2

1.3. Clasificacin de las Estructuras de datos

Segn su comportamiento durante la ejecucin del programa distinguimos dos tipos de

estructuras: estticas y dinmicas.

Las estructuras estticas son aquellas en las que el tamao ocupado en memoria se define antes

de que el programa se ejecute y no puede modificarse dicho tamao durante la ejecucin del

programa. Cuando el nmero de datos es grande, las operaciones de insercin y eliminacin de

elementos es una tarea relativamente pesada; es decir los algoritmo deben realizar movimiento de

grandes cantidades de datos de una posicin a otra. En general ocupan un tamao fijo de

memoria, aunque hay algunos lenguajes que permiten redefinir su tamao en pena ejecucin. Las

estructuras estticas se clasifican en arreglos, registros, archivos, conjuntos y strings.

Por otro lado, las estructuras dinmicas no tienen limitaciones en el tamao de memoria ocupada

que son propias de las estructuras estticas. El tamao de las estructuras dinmicas se ampla y

contrae durante la ejecucin del programa. Las estructuras dinmicas se clasifican en lineales y

no lineales. Las lineales son las pilas, colas y listas enlazadas. Las no lineales son los rboles y

los grafos.

Las estructuras dinmicas se diferencian de las estticas, fundamentalmente, en la rapidez con

que realizan las inserciones y borrados de elementos.

1.4. Tipos Abstractos de Datos

Los Tipos Abstractos de Datos (TAD) permiten describir una estructura de datos en funcin de

las operaciones que pueden efectuar, dejando de lado su implementacin. Esto se denomina

abstraccin de datos o tipo abstracto de datos. En realidad los propios tipos de datos provistos por

los lenguajes de programacin son Tipos Abstractos de Datos. Otros ejemplos son tipos muy

especficos de datos como ser TAD fecha, TAD hora, TAD Polinomio, TAD Racional, TAD

Array, etc.

Los TAD combinan estructuras de datos junto a una serie de operaciones de manipulacin.

Incluyen una especificacin sobre lo que ver el usuario, y una implementacin (algoritmos de

operaciones sobre las estructuras de datos y su representacin en un lenguaje de programacin),

que el usuario no tiene necesariamente que conocer para manipular correctamente los tipos

abstractos de datos.

Se caracterizan por el encapsulamiento. Es como una caja negra que funciona simplemente

conectndole unos cables. Esto permite aumentar la complejidad de los programas pero

manteniendo una claridad suficiente que no desborde a los desarrolladores. Adems, en caso de

que algo falle ser ms fcil determinar si lo que falla es la caja negra o son los cables.


3

Por ltimo, indicar que un TAD puede ser construido a partir de otro TAD ya definido. Por

ejemplo se pueden definir pilas, colas y rboles a partir de arrays o listas enlazadas. De hecho, las

listas enlazadas tambin pueden construirse a partir de arrays y viceversa.

Los tipos de datos abstractos (TAD) describen un conjunto de objetos con la misma

representacin y comportamiento. Los tipos abstractos de datos representan una separacin clara

entre la interfaz externa de un tipo de dato (nivel lgico) y su implementacin interna (nivel

fsico). La implementacin de un tipo abstracto de datos est oculta, por consiguiente se pueden

utilizar implementaciones alternativas para un mismo tipo abstracto de datos sin cambiar su

interfaz favoreciendo as las etapas de correccin y depuracin del software pues se puede

cambiar o mejorar un algoritmo interno sin cambiar su interfaz de modo tal que no afecta a los

dems mdulos del software.

Hoy en da con los nuevos paradigmas de programacin orientada a objetos, la aplicacin de los

conceptos de abstraccin se aplican mejor en paquetes cerrados llamados (clases) los cuales

presentan una interfaz al usuario de estas clases permitiendo solo el acceso a los mtodos y

operaciones definidas para este T.A.D., ocultando los detalles de la implementacin de tales

mtodos, aplicando as el concepto de abstraccin y facilitando al diseador del software pues

este utilizara dicha interfaz para construir aplicaciones sin la necesidad de preocuparse por

detalles de la implementacin del (T.A.D) Gracias a este concepto de abstraccin y la aplicacin

de la programacin orientada a objetos hoy por hoy se agiliza grandemente la realizacin de

proyectos de desarrollo de software desde proyectos que se terminaban en aproximadamente un

ao, a un mes; causando un gran impacto en el mercado del software. Por tanto las compaas de

desarrollo de software que no apliquen estos conceptos tienden a quedar en una gran desventaja

con sus competidores.

En trminos formales, a nivel lgico una Estructura de Datos d se define como una tripleta

compuesta por con conjunto de dominios D, un conjunto de funciones u operaciones F y un

conjunto de axiomas A.

donde:

D El conjunto de dominios consiste en los tipos de datos primitivos que utiliza la estructura

F Es el conjunto de funciones que manipulan los datos

A Describen el significado de las funciones

1.5 Estructura de datos Arreglo

Un arreglo es una estructura de datos que consiste en un conjunto de pares ndice-valor, sobre la

que se definen las operaciones de almacenamiento y recuperacin. Todos los valores o elementos

d = (D, F, A)


4

de una rreglo son del mismo tipo, es decir es una estructura homognea. El almacenamiento se

hace asociando un valor con cada ndice y la recuperacin significa que a partir de un ndice se

puede obtener el valor.

Aqu en conjunto dominios seran los enteros (para los ndices) y un tipo de dato (para los

valores), el conjunto de operaciones seran aadir un valor y recuperar un valor. Los axiomas

sera el significado de aadir un valor y el significado de recuperar un valor.

Por ejemplo, el siguiente arreglo es de nmeros enteros

Valores

(elementos)

242 666 45 3 -6 321 31 12

[1] [2] [3] [4] [5] [6] [7] [8]

Indices

(posiciones)

Este es un arreglo de los meses del ao

Enero Febrero Marzo Abril Mayo Junio Julio Agosto Septiembre Octubre Noviembre Diciembre

[1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12]

Operaciones con arreglos

Para realizar operaciones con arreglos, es necesario hacer operaciones a nivel de cada elemento;

es decir, por ejemplo cargar con datos un arreglo (leer) significara cargar cada elemento mediante

una instruccin apropiada del lenguaje de programacin.

Las principales operaciones con arreglos son: leer, imprimir, buscar mximo y mnimo, hallar

totales y subtotales, buscar un elemento, clasificar u ordenar un arreglo.

1.6 Bsqueda y clasificacin de arreglos

La bsqueda de arreglos es un proceso de recuperacin de datos. Consiste en localizar o ubicar la

posicin de un valor dentro del arreglo, dando como resultado el ndice correspondiente. Existen

varios mtodos para realizar este proceso, los ms comunes son la bsqueda secuencial y la

bsqueda binaria.


5

Bsqueda secuencial

Tambin llamada bsqueda lineal. Este proceso consiste en que dado el valor que se busca, se lo

debe comparar con cada valor del arreglo hasta dar con el que se busca; en ese momento se

captura la posicin o ndice. En caso de haber revisado todos los valores y no encontrar el valor,

se dir que el valor no se encuentra. Un algoritmo para este proceso es el siguiente:

entero BsquedaSecuencial( V arreglo, n tamao, x valor, i ndice) // devuelve el indice

Inicio

encontrado = falso

i = -1 // posicin ficticia para valor no encontrado

k = 1

mientras (no encontrado ) y (k


6

Un algoritmo para el proceso de bsqueda binaria es el siguiente:

entero BsquedaBinaria( V arreglo, n tamao, x valor, i ndice) // devuelve el indice

Inicio

bajo = 1

alto = n

encontrado = falso

i = -1 // posicin ficticia para valor no encontrado

mientras (no encontrado) y bajo x entonces

alto = central -1

sino

bajo = central + 1

fin_si

fin_si

fin_mientras

BusquedaBinaria = i

Fin

No olvidemos que la bsqueda binaria requiere que el vector est ordenado, y en la prctica esta

condicin puede ser difcil de mantener, sin embargo, en contrapartida, la bsqueda binaria es un

mtodo muy rpido ya que el nmero de comparaciones es pequeo en relacin al tamao del

vector. Se ha determinado que el nmero mximo de comparaciones esta dado por log2 n.

Esto significar que si se tienen100 elementos, requerirn solo 7 comparaciones como mximo.

Si son 100000 elementos, el nmero de comparaciones ser de 20.

Clasificacin

La clasificacin u ordenacin es el proceso de organizar datos en algn orden o secuencia

especfica, tal como creciente o decreciente para datos numricos o alfabticamente para datos de

caracteres.

La eleccin de algn mtodo de ordenacin depende de tres parmetros: el nmero de datos a

clasificar, el tipo de datos y la cantidad de memoria disponible.

Los mtodos de ordenacin se dividen en dos categoras:


7

Ordenacin de arreglos Ordenacin de archivos (ordenacin externa)

La ordenacin de arreglos se denomina tambin ordenacin interna, ya que se realiza y almacena

en la memoria de una computadora de gran velocidad y acceso aleatorio. La ordenacin de

archivos se suele hacer casi siempre sobre soportes de almacenamiento externo, discos, cintas,

etc. Por ello se denomina tambin ordenacin externa. Estos dispositivos son ms lentos en las

operaciones de E/S, pero por el contrario, pueden contener mayor cantidad de informacin.

En este curso veremos solo la ordenacin interna. Los principales mtodos de ordenacin de

arreglos son:

Insercin o Insercin directa (baraja)

o Insercin binaria

Intercambio o Burbuja

o Pares no adyacentes

Seleccin Shell Ordenacin rpida (quick-sort)

Mtodo de intercambio o de Burbuja

Este mtodo se basa en el principio de comparar pares de elementos adyacentes e intercambiarlos

entre si hasta que estn ordenados. El algoritmo burbuja es el siguiente

Burbuja(V vector, n tamao)

Inicio

bandera = Falso

mientras bandera = Falso hacer

bandera = Verdadero

para k = 1 hasta n-1

si V[k] > V[k+1] entonces

Intercambiar(V[k], V[k+1])

bandera = Falso

fin_si

fin_para

fin_mientras

Fin

Intercambiar (x, valor, y valor)


8

Inicio

temporal = x

x = y

y = temporal

Fin

Mtodo de la Baraja

Es un mtodo de insercin, consiste en insertar un elemento en una parte del vector ya ordenada y

comenzar de nuevo con los elementos restantes. Por ser utilizado generalmente por los jugadores

de cartas se le conoce con el nombre de Baraja.

Baraja(V vector, n tamao)

Inicio

para i = 2 hasta n

aux = V[i]

k = i - 1

u = i-1

bandera = Falso

mientras bandera < > Falso y k >= 1 hacer

si aux < V[k] entonces

V[k+1] = V[k]

k = k 1

sino

bandera = Verdad

fin_si

fin_para

fin_mientras

V[k+1] = aux

Fin

Metodo QuickSort

El ordenamiento rpido (quicksort en ingls) es un algoritmo basado en la tcnica de divide y

vencers, que permite, en promedio, ordenar n elementos en un tiempo proporcional a n log n.

Esta es la tcnica de ordenamiento ms rpida conocida. Fue desarrollada por Carl Antony R.

Hoare en 1960.

El algoritmo fundamental es el siguiente:

Elegir un elemento de la lista de elementos a ordenar, al que llamaremos pivote. Reubicar los dems elementos de la lista a cada lado del pivote, de manera que a un lado

queden todos los menores que l, y al otro los mayores. En este momento, el pivote ocupa

exactamente el lugar que le corresponder en la lista ordenada.


9

La lista queda separada en dos sublistas, una formada por los elementos a la izquierda del pivote, y otra por los elementos a su derecha.

Repetir este proceso de forma recursiva para cada sublista mientras stas contengan ms de un elemento. Una vez terminado este proceso todos los elementos estarn ordenados.

Como se puede suponer, la eficiencia del algoritmo depende de la posicin en la que termine el

pivote elegido.

En el mejor caso, el pivote termina en el centro de la lista, dividindola en dos sublistas de igual tamao. En este caso, el orden de complejidad del algoritmo es O(nlog n).

En el peor caso, el pivote termina en un extremo de la lista. El orden de complejidad del algoritmo es entonces de O(n). El peor caso depender de la implementacin del algoritmo,

aunque habitualmente ocurre en listas que se encuentran ordenadas, o casi ordenadas.

En el caso promedio, el orden es O(nlog n).

No es extrao, pues, que la mayora de optimizaciones que se aplican al algoritmo se centren en

la eleccin del pivote. Una versin en C++ que ordena un vector de tipo numrico es la siguiente

es la siguiente:

void QuickSort(float V[], int m, int N)

{

int i, j, p;

if (m < N)

{

i = m; j = (N) + 1; p = V[m];

do

{

do i++; while(V[i]p);

if (i


10

2. Estructura de lenguajes de programacin orientados a objeto.

2.1 . Aspectos generales de los lenguajes

Si se echa un vistazo a la historia de la ingeniera del software, prestando particular atencin a

cmo ha evolucionado, se puede observar que los progresos ms significativos se han obtenido

gracias a la aplicacin de uno de los principios fundamentales a la hora de resolver cualquier

problema, incluso de la vida cotidiana, la descomposicin de un sistema complejo en partes que

sean ms fciles de manejar, es decir, gracias a la aplicacin del dicho popular conocido como

divide y vencers.

En los primeros estadios de desarrollo de los lenguajes de programacin (Basic, Fortran) se tena

un cdigo en el que no haba separacin de conceptos, datos y funcionalidad se mezclaban sin

una lnea divisoria clara. A esta etapa se la conoce como la del cdigo spaghetti, ya que se tena

una maraa entre datos y funcionalidad que recuerda a la que se forma del plato de esta pasta

italiana. En la siguiente etapa (Algol, Pascal, C) se pas a aplicar la llamada descomposicin

funcional, (da origen a la llamada programacin modular) que pone en prctica el principio de

divide y vencers identificando las partes ms manejables como funciones que se definen en el

dominio del problema. La principal ventaja que proporciona esta descomposicin es la facilidad

de integracin de nuevas funciones, aunque tambin tiene grandes inconvenientes, como son el

hecho de que las funciones quedan algunas veces poco claras debido a la utilizacin de datos

compartidos, y el que los datos quedan esparcidos por todo el cdigo, con lo cual, normalmente el

integrar un nuevo tipo de datos implica que se tengan que modificar varias funciones.

Intentando solventar estas desventajas con respecto a los datos, se dio otro paso en el desarrollo

de los sistemas software (lenguajes Smalltalk, Eiffel, C++, Java, Delphi, Phyton,). La

programacin orientada a objetos (POO) ha supuesto uno de los avances ms importantes de los

ltimos aos en la ingeniera del software para construir sistemas complejos utilizando el

principio de descomposicin, ya que el modelo de objetos subyacente se ajusta mejor a los

problemas del dominio real que la descomposicin funcional. La ventaja que tiene es que es fcil

la integracin de nuevos datos, aunque tambin quedan las funciones esparcidas por todo el

cdigo, y tiene los inconvenientes de que, con frecuencia, para realizar la integracin de nuevas

funciones hay que modificar varios objetos, y de que se produce un enmaraamiento de los

objetos en funciones de alto nivel que involucran a varias clases.

En la Figura 1 se representa mediante un esquema los distintos estadios en la evolucin de los

sistemas software. En este esquema se refleja de forma clara la mezcla de conceptos que se

produce en cada una de las etapas de la evolucin (etapas comnmente conocidas como

generaciones). Si cada una de las distintas formas que aparecen dibujadas (tringulo, cuadrado,

trapecio, elipse) representa a un tipo de datos distinto, y cada color o tonalidad representa a una


11

funcin distinta, se tiene que en la primera generacin de los sistemas software funciones y datos

se entremezclaban.

En la segunda y tercera generacin se tienen conjuntos de elementos agrupados por tonalidades, y

en cada conjunto conviven distintas formas, lo que nos indica que la descomposicin del sistema

se hace en base a las funciones (tonalidades), y que los datos quedan esparcidos por todos los

conjuntos.

En la cuarta generacin, sin embargo, esta agrupacin se realiza en base a las formas (datos), pero

como se puede observar, en cada conjunto tenemos representadas distintas funcionalidades

(tonalidades), con lo cual stas tambin se nos dispersan por todo el sistema.

Uno de los principales inconvenientes con el que nos encontramos al aplicar estas

descomposiciones ya tradicionales es que muchas veces se tienen ejecuciones ineficientes debido

a que las unidades de descomposicin no siempre van acompaadas de un buen tratamiento de

aspectos tales como la gestin de memoria, la coordinacin, la distribucin, las restricciones de

tiempo real, ...

En el desarrollo de un sistema software adems del diseo y la implementacin de la

funcionalidad bsica, se recogen otros aspectos tales como la sincronizacin, la distribucin, el

manejo de errores, la optimizacin de la memoria, la gestin de seguridad, etc. Mientras que las

descomposiciones funcional y orientada a objetos no nos plantean ningn problema con respecto

al diseo y la implementacin de la funcionalidad bsica, estas tcnicas no se comportan bien con

los otros aspectos. Es decir, que nos encontramos con problemas de programacin en los cuales


12

ni las tcnicas funcionales, ni las orientadas a objeto son suficientes para capturar todas las

decisiones de diseo que el programa debe implementar.

Con las descomposiciones tradicionales no se aislan bien estos otros aspectos, sino que quedan

diseminados por todo el sistema enmaraando el cdigo que implementa la funcionalidad bsica,

y yendo en contra de la claridad del mismo. Se puede afirmar entonces que las tcnicas

tradicionales no soportan bien la separacin de competencias para aspectos distintos de la

funcionalidad bsica de un sistema, y que esta situacin claramente tiene un impacto negativo en

la calidad del software.

La programacin orientada a aspectos (POA) es una nueva metodologa de programacin que aspira

a soportar la separacin de competencias para los aspectos antes mencionados. Es decir, que

intenta separar los componentes y los aspectos unos de otros, proporcionando mecanismos que

hagan posible abstraerlos y componerlos para formar todo el sistema. En definitiva, lo que se

persigue es implementar una aplicacin de forma eficiente y fcil de entender.

2.2 Lenguajes orientados a objeto

Los lenguajes orientados a objeto se basan en un concepto fundamental llamado objeto y en toda

la tecnologa desarrollada en torno a l. Muchos lenguajes se declaran Orientados a Objetos. Pero

la definicin exacta del trmino depende de muchos rasgos y conceptos que se deben cumplir en

su totalidad; estos rasgos y caractersticas son:

1. Ocultamiento y encapsulamiento de la informacin

2. Herencia

3. Polimorfismo

4. Todos los tipos de datos predefinidos son objetos

5. Todas las operaciones realizan envo de mensajes a objetos

6. Todos los tipos de datos definidos por los usuarios son objetos

Para propsito de esta discusin, un lenguaje ser considerado Orientado a Objetos Puro si

satisface todos los seis tems nombrados. Ser hbrido si slo cumple con algunos de esos 6

lineamientos (por lo generar son hbridos cumpliendo los tres primeros).

Programacin Orientada a Objeto

Los objetos son entidades que combinan estado, comportamiento e identidad:

El estado est compuesto de datos, sern uno o varios atributos a los que se habrn

asignado unos valores concretos (datos).

El comportamiento est definido por los procedimientos o mtodos con que puede operar

dicho objeto, es decir, qu operaciones se pueden realizar con l.


13

La identidad es una propiedad de un objeto que lo diferencia del resto, dicho con otras

palabras, es su identificador (concepto anlogo al de identificador de una variable o una

constante).

La programacin orientada a objetos expresa un programa como un conjunto de estos objetos,

que colaboran entre ellos para realizar tareas. Esto permite hacer los programas y mdulos ms

fciles de escribir, mantener y reutilizar.

De esta forma, un objeto contiene toda la informacin que permite definirlo e identificarlo frente

a otros objetos pertenecientes a otras clases e incluso frente a objetos de una misma clase, al

poder tener valores bien diferenciados en sus atributos. A su vez, los objetos disponen de

mecanismos de interaccin llamados mtodos que favorecen la comunicacin entre ellos. Esta

comunicacin favorece a su vez el cambio de estado en los propios objetos. Esta caracterstica

lleva a tratarlos como unidades indivisibles, en las que no se separan ni deben separarse el estado

y el comportamiento.

Los mtodos (comportamiento) y atributos (estado) estn estrechamente relacionados por la

propiedad de conjunto. Esta propiedad destaca que una clase requiere de mtodos para poder

tratar los atributos con los que cuenta. El programador debe pensar indistintamente en ambos

conceptos, sin separar ni darle mayor importancia a ninguno de ellos, hacerlo podra producir el

hbito errneo de crear clases contenedoras de informacin por un lado y clases con mtodos que

manejen a las primeras por el otro.

Entre los lenguajes orientados a objetos se destacan los siguientes:

Ada

C++

C#

Lenguaje de programacin D

Object Pascal (Delphi)

Eiffel

Java

JavaScript (la herencia se realiza por medio de la programacin basada en prototipos)

Lexico (en castellano)

Objective-C

Ocaml

Oz

Lenguaje de programacin R

Perl

PHP (en su versin 5)

Python

Ruby

Smalltalk


14

Magik (SmallWorld)

VB.NET

Visual FoxPro (en su versin 6)

Visual Basic

XBase++

Muchos de estos lenguajes de programacin no son puramente orientados a objetos, sino que son

hbridos que combinan la POO con otros paradigmas

2.2. Estructuras de datos orientadas a objetos

Las Estructuras de Datos Orientadas a Objeto EDOO, pueden ser obtenidas directamente a partir

de los Tipos Abstractos de Datos, con solo aadirles, si es necesario, la funcionalidad, a travs de

la implementacin de sus operaciones. De este modo los TDA se convierten en clases, por lo

tanto, toda la tecnologa y la terminologa de la POO se aplica a las estructuras de datos

Orientadas a Objeto.

Los conceptos fundamentales y la terminologa a ser utilizados en la definicin de las EDOO son

los siguientes:

Clase: definiciones de las propiedades y comportamiento de un tipo de objeto concreto.

La instanciacin es la lectura de estas definiciones y la creacin de un objeto a partir de

ellas.

Herencia: (por ejemplo, herencia de la clase D a la clase C) Es la facilidad mediante la

cual la clase D hereda en ella cada uno de los atributos y operaciones de C, como si esos

atributos y operaciones hubiesen sido definidos por la misma D. Por lo tanto, puede usar

los mismos mtodos y variables publicas declaradas en C. Los componentes registrados

como "privados" (private) tambin se heredan, pero como no pertenecen a la clase, se

mantienen escondidos al programador y solo pueden ser accesado a travs de otros

mtodos publicos. Esto es as para mantener hegemnico el ideal de OOP.

Objeto: entidad provista de un conjunto de propiedades o atributos (datos) y de

comportamiento o funcionalidad (mtodos). Se corresponde con los objetos reales del

mundo que nos rodea, o a objetos internos del sistema (del programa). Es una instancia a

una clase.

Mtodo: Algoritmo asociado a un objeto (o a una clase de objetos), cuya ejecucin se

desencadena tras la recepcin de un "mensaje". Desde el punto de vista del

comportamiento, es lo que el objeto puede hacer. Un mtodo puede producir un cambio

en las propiedades del objeto, o la generacin de un "evento" con un nuevo mensaje para

otro objeto del sistema.

Evento: un suceso en el sistema (tal como una interaccin del usuario con la mquina, o

un mensaje enviado por un objeto). El sistema maneja el evento enviando el mensaje


15

adecuado al objeto pertinente. Tambin se puede definir como evento, a la reaccin que

puede desencadenar un objeto, es decir la accin que genera.

Mensaje: una comunicacin dirigida a un objeto, que le ordena que ejecute uno de sus

mtodos con ciertos parmetros asociados al evento que lo gener.

Propiedad o atributo: contenedor de un tipo de datos asociados a un objeto (o a una

clase de objetos), que hace los datos visibles desde fuera del objeto y esto se define como

sus caractersticas predeterminadas, y cuyo valor puede ser alterado por la ejecucin de

algn mtodo.

Estado interno: es una variable que se declara privada, que puede ser nicamente

accedida y alterada por un mtodo del objeto, y que se utiliza para indicar distintas

situaciones posibles para el objeto (o clase de objetos). No es visible al programador que

maneja una instancia de la clase.

Componentes de un objeto: atributos, identidad, relaciones y mtodos.

Representacin de un objeto: un objeto se representa por medio de una tabla o entidad

que est compuesta por sus atributos y funciones correspondientes.

2.4. Recursividad y lenguajes de programacin OO

Concepto de Recursividad

La recursividad constituye una de las herramientas ms potentes en programacin. Es un

concepto matemtico conocido. Esencialmente, un proceso es recursivo cuando en su

procesamiento se utiliza a si mismo. Dentro de la recursividad se distinguen dos situaciones

llamadas caso base (final) y caso general (recursivo).

Caso Base

Son hechos verdadero que no requieren demostracin. En esta parte del algoritmo no existen

llamadas recursivas, son condiciones de terminacin de ciclos o llamadas recursivas. Un

algoritmo recursivo puede tener varios casos base.

Caso General

Son hechos que se definen en funcin al cumplimiento de una definicin previa. Estas

definiciones previas las define el mismo algoritmo en llamadas a si mismo con parmetros que

aseguren el cumplimiento de uno de los casos base en cada llamada recursiva.

La recursividad se expresa, generalmente, mediante una funcin recursiva. Una funcin que se

llama as misma se denomina recursiva. Podemos usar recursividad si la solucin de un problema

est expresada en funcin de si misma, aunque de menor tamao y conocemos la solucin no-

recursiva para un determinado caso.

Ventajas: No es necesario definir la secuencia de pasos exacta para resolver el problema.

Desventajas: Podra ser menos eficiente.


16

Para que una definicin recursiva est completamente identificada es necesario tener un caso base

que no se calcule utilizando casos anteriores y que la divisin del problema converja a ese caso

base.

Ejemplo: La potencia recursiva

1 si n = 0 (caso base)

xn =

x xn1

si n > 0 (caso general)

Otra funcin recursiva es el factorial. Como se puede ver a continuacin la definicin recursiva

es clara.

Definicin recursiva de factorial

1 si n = 0

n! =

n . (n 1)! si n > 0

Por ejemplo calculamos el factorial con n=3. Este proceso se muestra paso a paso a continuacin:

1) 3! = 3 * 2!

2) 3! = 3 * 2!

2! = 2 * 1!

3) 3! = 3 * 2!

2! = 2 * 1!

1! = 1 * 0!

4) 3! = 3 * 2!

2! = 2 * 1!

1! = 1 * 0!

0! = 1 (caso base)

5) 3! = 3 * 2!

2! = 2 * 1!

1! = 1 * 1

1

6) 3! = 3 * 2!

2! = 2 * 1

1! = 1 * 1 = 1

7) 3! = 3 * 2

2! = 2 * 1 = 2

8) 3! = 3 * 2 = 6


17

El algoritmo del factorial recursivo es el siguiente:

int factorial (int n) {

if (n==0) //Caso base

return 1;

else //Caso general

return n*factorial(n-1);

}

Otros ejemplos de funciones recursivas:

1. Clculo de la potencia

1 si n = 0

xn =

x xn1

si n > 0

int potencia(int base, int expo){

if (expo==0)

return 1;

else

return base * potencia(base,expo-1);


18

}

2. La suma de forma recursiva

a si b = 0

suma(a, b) =

1 + suma(a, b 1) si b > 0

int suma(int a, int b){

if (b==0)

return a;

else

return 1+suma(a,b-1);

}

3. Bsqueda lineal recursiva (con dos casos base)

Verdad si V [n] = b

Falso si V [0] 6= b

BusquedaLineal(V, n, b) =

(V [n] == b) (b 2 {V [0], . . . , V [n 1]}) en otro caso

int BusquedaLineal(int *V, int n, int b)

{

if (n x, el elemento buscado est en una posicin menor que t, entonces


19

BusBinRec(v, i, t-1, x)

3. Al modificar los extremos puede darse que i > d, en cuyo caso el proceso termina (Fracaso).

int BusBinRec (int v[], int i, int d, int x) // v arreglo, d tamao, x valor

{

int centro;

if (ix) // Buscar izda.

return BusBinRec (v,i,centro-1,x);

else // Buscar dcha.

return BusBinRec (v,centro+1,d,x);

}

else // i > d

return -1; // Caso base 2

}


20

3. Almacenamiento esttico en secuencia Listas

3.1 Aspectos generales de listas

Una lista es un conjunto lineal de elementos o valores del mismo tipo que se encuentran

ordenados y pueden variar en nmero.

Los elementos de una lista se almacenan normalmente en forma contigua, es decir un elemento

despus de otro, en posiciones consecutivas de memoria. Una lista lineal se almacena en la

memoria principal de una computadora en posiciones contiguas sucesivas de memoria. Esta

asignacin de memoria se denomina almacenamiento secuencial o esttico.

Las lneas as definidas se llaman contiguas. Las operaciones que se pueden realizar con listas

lineales son las siguientes:

1. Insertar, eliminar o localizar un elemento

2. Determinar el tamao de la lista nmero de elementos

3. Recorrer la lista para localizar un determinado elemento

4. Clasificar los elementos de la lista en orden ascendente o descendente

5. Unir dos o ms listas en una sola

6. Dividir una lista en varias sublistas

7. Copiar un a lista

8. Borrar una lista

Una lista lineal se almacena en la memoria de la computadora en posiciones sucesivas o

adyacentes y se procesa como un arreglo unidimensional. En este caso el acceso a cualquier

elemento de la lista y la adicin de nuevos elementos es fcil; sin embargo, la insercin o borrado

requieren desplazamiento de lugar de los elementos que le siguen y, en consecuencia, el diseo

de algoritmos especficos.

Las operaciones de aadir y eliminar se efectan nicamente en los extremos de la lista. Esta

limitacin es una de las razones por las que esta estructura de datos es poco utilizada como tal;

sin embargo, es til en casos donde la cantidad de inserciones y/o eliminaciones es reducida, es

decir la estructura es esttica. Asimismo, esta estructura permite disear otras estructuras ms

complejas, implementndolas de manera sencilla; en especial las estructuras dinmicas de pilas y

colas.

3.2. Pilas

Una pila (o stack) es un tipo especial de lista lineal en la que la insercin y el borrado de nuevos

elementos se realiza slo por un extremo que se denomina cima o tope (top).


21

La pila es una estructura con numerosas analogas en la vida real: una pila de platos, una pila de

monedas, una pila de cajas de zapatos, una pila de bandeja, un a pila de libros, etc.

Dado que la operacin de insertar solo puede hacerse por un extremo, -el superior- los elementos

solo pueden eliminarse en orden inverso al que se insertaron en la pilas. El ltimo elemento que

se pone en la pila es el primero que se puede sacar; por ello, a estas estructuras se les conoce por

el nombre LIFO (Last In, First Out) o UEPS (Ultimo en Entrar, Primero en Salir).

Las pilas se pueden representar como en la figura de la izquierda y se pueden implementar en un

arreglo con un determinado tamao, como el la figura de la derecha.

Arreglo que implementa una pila

Cima Cima Longitud mxima de la pila

Otra manera de implementar pilas es de manera dinmica a travs de nodos con punteros; sin

embargo, cualquiera que sea su implementacin, las operaciones sobre las pilas son las mismas y

deben ser transparentes para su utilizacin.

Las operaciones bsicas sobre una pila son: poner o meter un nuevo elemento y sacar o quitar un

elemento. En la siguiente lista se muestran estas y otras operaciones y su significado:

P = Cima Apuntador a la cima de la pila

esVaca Funcin lgica que indica si la pila est vaca

Poner Subprograma para aadir elementos

Sacar Subprograma para quitar elementos

LongMax Longitud mxima que puede tener la pila

Entre las muchas aplicaciones de las pilas estn las que se usan en ciencias de la computacin

como el rastreo de llamados a subprogramas, el control de bucles, la evaluacin de expresiones

aritmticas, etc.

Aplicacin de pila: Evaluacin de expresiones

Esta aplicacin consiste en calcular el valor de una expresin aritmtica dada; es decir, siguiendo

las reglas de la aritmtica se debe obtener un valor final. Las expresiones aritmticas,

1 2 P-1 P n-1 n


22

normalmente se escriben en una notacin denominada infija, en la que el operador se encuentra

en medio de los operandos.

Proceso para evaluacin de una expresin aritmtica

Una expresin aritmtica escrita normalmente en notacin infija, se evala segn los siguientes

pasos:

1. Transformar la expresin de infija o postfija

2. Evaluar la expresin en postfija

Se entiende que la notacin postfija es aquella cuyos operandos aparecen primero, luego aparece

el operador.

Para resolver cada paso es fundamental que los algoritmos utilicen pilas.

Transformacin de infija a postfija

Se parte de una expresin en notacin infija que tiene operandos, operadores y puede tener

parntesis. Los operandos vienen representados por letras, los operadores van a ser:

Operadores: ^, *, / , +, -

La transformacin se realiza utilizando una pila en la que se almacenan los operadores y los

parntesis izquierdos. La expresin se va leyendo carcter a carcter, los operandos pasan

directamente a formar parte de la expresin en postfija.

Los operadores se meten en la pila siempre que esta est vaca, o bien siempre que tengan

mayor prioridad que el operador cima de la pila (o bien igual si es la mxima prioridad).

Si la prioridad es menor o igual se saca el elemento cima de la pila y se vuelve a hacer la

comparacin con el nuevo elemento cima.

Los parntesis izquierdos siempre se meten en la pila, asignndoles la mnima prioridad. Cuando

se lee un parntesis derecho, hay que sacar todos los operadores de la pila pasando a formar parte

de la expresin postfija, hasta llegar a un parntesis izquierdo, el cual se elimina de la pila, ya que

los parntesis no forman parte de la expresin postfija.

El algoritmo termina cuando no hay ms elementos en la expresin infija, y la pila esta vaca.

Sea por ejemplo la expresin infija

A + B * C / ( D E ) - F


23

En consecuencia, la expresin postfija resultante es

A B C * D E - / + F -

Con el fin de que el algoritmo de conversin de infija a postfija se pueda manejar mejor, es

necesario definir prioridades para los operadores y el parntesis izquierdo.

Operador Prioridad

^

*, /

+, -

(

3

2

1

0 (dentro)

Items en

Proceso

Expresin

postfija

Resultante

Estado de la

PILA Comentario

A A Pila vacia El operando A va a expresin postfija.

+ A + El operador + va a la pila, ya que est vaca.

B * AB + *

El operando B va a expresin postfija y el operador *

tiene mayor prioridad que la cima de la pila, en

consecuencia va a la pila

C / ABC* + /

El operando C va a expresin postfija y el operador /

tiene menor o igual prioridad que la cima de la

pila, por tanto, salen tems de la pila hasta un item

de menor prioridad. Luego / entra a la pila.

( ABC* + / ( El parntesis izquierdo ( siempre va a la pila.

D - ABC*D + / ( - El operando D va a expresin postfija. El operador

tiene mayor prioridad que la cima, va a la pila.

E ) ABC*DE- + /

El operando E va a expresin postfija. El parntesis

derecho ) no va a la pila, solo obliga a sacar tems

de la pila hasta un parntesis izquierdo ( inclusive.

- ABC*DE-/+ -

El operador tiene menor o igual prioridad que la

cima, en consecuencia salen de la pila hasta un

operador de menor prioridad que l. Luego el

entra a la pila.

F ABC*DE-/+F - El operando F va a la expresin postfija

No hay ABC*DE-/+F- Pila vacia Como ya no hay ms tems en la expresin, la pila se

debe vaciar.


24

Ejercicio.

1. Hallar el equivalente postfijo de la siguiente expresin infija: A*(B+C(D/E^F)+G)-H

Respuesta ABC+DEF^/-G+*H-

2. Escribir el algoritmo para convertir una expresin infija en postfija.

3.3. Colas

Al igual que las pilas, las colas son estructuras de listas lineales pero con una disciplina diferente

de aquellas. Las colas insertan elemento por un extremo y sacan elementos por el otro. Esto se

conoce como FIFO (First In, First Out) o PEPS (Primero en Entrar, Primero en Salir).

Las eliminaciones se realizan por el comienzo de la lista (front) llamado frente, y las inserciones

se realizan por el otro extremo (rear) o final

En la vida real se tienen numerosos ejemplos de colas: la cola de un cine, la cola de atencin en

un banco, una cola de vehculos en una gasolinera, etc. En todas ellas, el primero en llegar es el

primero en ser atendido.

En el campo de informtica tambin se encuentran muchas aplicaciones de colas. Por ejemplo en

un sistema informtico suele haber una impresora que atiende las solicitudes de impresin en el

orden de una cola. Existe otra aplicacin en un sistema de tiempo compartido, donde un

procesador central atiende la peticin de proceso segn el orden de llegada, suponiendo que

existen varias terminales, y otros perifricos que demandan tiempo de procesador.

Un ejemplo bastante actual de aplicacin de colas lo constituye el proceso de atencin al pblico

por parte de bancos y otras entidades. En este caso se pueden presentar no solo una sino varias

colas, en funcin de determinados criterios de atencin o prioridad.

Eliminacin Insercin

Frente Final

Las colas se pueden implementar en forma esttica mediante arreglos, como se ve en la figura, o

bien con el uso de punteros, en forma dinmica.

Cuando se implementa en forma esttica en un arreglo se presenta el problema de que luego de

varias inserciones y eliminaciones, la cola parece viajar por el arreglo, hasta que llega a su

lmite final, en cuyo caso el estado de la cola ser aparentemente de cola llena, sin embargo, en el

1 2 n-1 n


25

frente de la cola pueden haber espacios vacos. Una forma de superar esta limitacin es utilizando

el arreglo como un espacio circular que se recicla con el primer elemento, cada vez que la cola

alcanza el final del arreglo. Este problema se puede abordar de diferentes maneras.

La implementacin ms adecuada para colas es mediante las llamadas listas encadenadas,

mediante el uso de punteros. Esta implementacin se estudiar ms adelante.

Operaciones Bsicas

Crear: se crea la cola vaca.

Poner (push): se aade un

elemento a la cola. Se aade

al final de esta.

Sacar (pop): 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

primero elemento que entr.

Implementacin de la operaciones

Las operaciones bsicas sobre una cola son: poner o meter un nuevo elemento al final y sacar o

quitar un elemento del frente. En la siguiente lista se muestran estas y otras operaciones y su

significado:

F = Frente Apuntador hacia el frente de la cola

R = Final Apuntador hacia el final de la cola

esVaca Funcin lgica que indica si la cola est vaca

Poner Subprograma para aadir elementos por el frente

Sacar Subprograma para quitar elementos por el final

LongMax Longitud mxima que puede tener la cola

Aplicaciones

Ejemplos de colas en la vida real seran: personas comprando en un supermercado, esperando

para entrar a ver un partido de futbol, esperando en el cine para ver una pelcula, una pequea

peluquera, las colas en los bancos, etc. La idea esencial es que son todos lneas de espera.

En estos casos, el primer elemento de la lista realiza su funcin (pagar comida, pagar entrada para

el partido o para el cine) y deja la cola. Este movimiento est representado en la cola por la

funcin pop o desencolar. Cada vez que otro elemento se aade a la lista de espera se aaden al

final de la cola representando la funcin push o encolar. Hay otras funciones auxiliares para ver


26

el tamao de la cola (size), para ver si est vaca en el caso de que no haya nadie esperando

(empty) o para ver el primer elemento de la cola (front).

Las colas tambin se utilizan en muchas maneras en los sistemas operativos para planificar el uso

de los distintos recursos de la computadora. Uno de estos recursos es la propia CPU (Unidad

Central de Procesamiento).

Si esta trabajando en una sistema multiusuario, cuando le dice a la computadora que ejecute un

programa concreto, el sistema operativo aade su peticin a su cola de trabajo.

Cuando su peticin llega al frente de la cola, el programa solicitado pasa a ejecutarse.

Igualmente, las colas se utilizan para asignar tiempo a los distintos usuarios de los dispositivos

de entrada/salida (E/S), impresoras, discos, cintas y dems. El sistema operativo mantiene colas

para peticiones de imprimir, leer o escribir en cada uno de estos dispositivos.

Implementacin de colas en C++

#ifndef COLA

#define COLA // define la cola

template

class Cola {

private:

struct Nodo {

T elemento;

Nodo* siguiente; // coloca el nodo en la segunda posicion

}* primero;

Nodo* ultimo;

unsigned int elementos;

public:

Cola() {

elementos = 0;

}

~Cola() {

while (elementos != 0) pop();

}

void push(const T& elem) {

Nodo* aux = new Nodo;

aux->elemento = elem;

if (elementos == 0) primero = aux;

else ultimo->siguiente = aux;

ultimo = aux;

++elementos;

}

void pop() {

Nodo* aux = primero;


27

primero = primero->siguiente;

delete aux;

--elementos;

}

T consultar() const {

return primero->elemento;

}

bool vacia() const {

return elementos == 0;

}

unsigned int size() const {

return elementos;

}

};

#endif

Tipos de colas

Colas circulares (anillos): en las que el ltimo elemento y el primero estn unidos.

Colas de prioridad: En ellas, 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. 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.

Bicolas: son colas en donde los nodos se pueden aadir y quitar por ambos extremos; se

les llama DEQUE (Double Ended QUEue). Para representar las bicolas lo podemos hacer

con un array circular con Inicio y Fin que apunten a cada uno de los extremos. Hay

variantes:

Bicolas de entrada restringida: Son aquellas donde la insercin slo se hace por el final,

aunque podemos eliminar al inicio al final.

Bicolas de salida restringida: Son aquellas donde slo se elimina por el final, aunque se

puede insertar al inicio y al final.

3.4. Problemas de aplicacin de pilas, colas y listas

Aplicaciones de Pila


28

Problema 1. Implementar un programa para administrar una pila.

Problema 2. En el lgebra, comunmente se utilizan signos de agrupacin tales como ( ), [ ] o { },

y se pueden utilizar para indicar el orden en que se realizarn las operaciones aritmeticas.

Ej. [a(x+y)+c]d+ (b(c+d)),

sin embargo, existen ciertas formas invalidas de utilizar dichos signos de agrupacin

Ej [a+b) (a (b)) o tambien ([a+b)c].

Es decir, cada signo que abre debe tener un signo correspondiente que lo cierre, cada signo que cierra debe de tener un signo correspondiente qu cerrar, y los signos no se pueden traslapar. Escribe un programa, que dada una expresin algebrarica, determine si tiene o no error

en los signos de agrupacin en tiempo lineal.

Problema 3. Una manera de encriptar mensajes(no muy segura), es colocar parentesis de manera

arbitraria, y todo lo que esta dentro de un parentesis, ponerlo al reves, por ejemplo Olimpiada de Informatica se puede encriptar como Olimpia(ad) de I(rofn)matica, los parentesis tambien se pueden anidar, es decir, otra forma de encriptar el mismo mensaje podra ser Olimpia(am(nfor)I ed (da))tica. Escribe un programa, que dado un mensaje encriptado, determine el mensaje original en tiempo lineal.

(9 Olimpiada Mexicana de Informtica)

Problema 4. Hay n faros acomodados en lnea recta, cada faro puede tener una altura arbitraria, y

adems, cada faro brilla con cierta intensidad. La luz de cada faro ilumina unicamente a los

primeros faros en cada direccin cuyas alturas sean estrictamente mayores a la del faro que emite

la luz. La iluminacin total de un faro, es la suma de las luces que llegan al faro(sin incluir la

propia). Escribe un programa, que dadas las alturas de los n faros y las intensidades de cada uno,

determine cual es el faro mas iluminado en tiempo lineal.

(USACO 2006)

Problema 5. Una cuadricula bicolorada, es aquella en la cual cada cuadro puede estar pintado de

color negro o de color blanco(todos los cuadros estan pintados de alguno de estos 2 colores).

Puedes asumir que cada casilla de la cuadricula tiene area 1. Escribe un programa, que dada una

cuadricula bicolorada, determine el rea del mayor rectangulo (dentro de la cuadricula) pintado

de un solo color. Tu programa deber funcionar en tiempo lineal (lineal en funcin del nmero de

casillas de la cuadricula, NO en funcin de la base o de la altura).

(Croatian Olympiad in Informatics)

Problema 6. Considera el siguiente algoritmo recursivo para generar permutaciones de arreglo[ ]

desde inicio hasta fin:

1 funcion permuta(arreglo[ ],inicio, fin)

2 si inicio=fin entonces

3 imprime arreglo[ ];

4 fin_de_funcion;


29

5 para i=inicio hasta fin

6 intercambia(arreglo[inicio], arreglo[i]);

7 pemuta(arreglo[ ], inicio+1, fin);

8 intercambia(arreglo[inicio], arreglo[i]);

9 fin_de_funcion;

Escribe una funcin no recursiva que genere todas las permutaciones de arreglo[ ] desde inicio

hasta fin, con la misma complejidad que la funcin que se muestra.

Aplicaciones de Cola

Problema 1. Implementar un programa qupara administrar una cola.

Problema 2.Una cola de atencin al pblico, en realidad es un conjunto de colas que son

atendidas en forma cclica segn determinada prioridad. Esta prioridad puede ser administrada

inclusive sobre la periodicidad de atencin a cada cola; es decir las colas con mayor prioridad

pueden atenderse en forma secuencial un cierto nmero de veces (segn el nmero de elementos

que tengan en ese momento).

Por otra parte, la cantidad de puntos de atencin puede ser diseada segn los requerimientos. EL

programa de ser tan flexible que permita configurar todos estos detalles.Esta aplicacin tiene

como componente principal la interfaz del usuario.

Problema 3. En tu negocio tienes una secuencia de n sillas acomodas en lnea recta y numeradas

de 1 a n, por cada persona que se siente en una silla con el nmero x, debers pagar $x al

gobierno, pero como quieres tener cmodos a los clientes, no tienes otra opcin que pedirles que

tomen asiento; sin embargo, el aprecio por el cliente an no te ha quitado la codicia, por lo que

puedes indicarle a cada cliente donde sentarse, pero el cliente deside cuando irse; desde el

momento que un cliente llega hasta el momento que se va, el cliente pasar todo el tiempo

sentado en una silla y no estar dispuesto a compartirla con nadie mas. Escribe un programa que

dado el historial de qu clientes llegan y qu clientes se van en orden cronolgico, calcule que

asientos asignarles a cada quien para que el dinero que debas pagar al gobierno sea el mnimo

posible. Tu programa deber funcionar en tiempo lineal.

Problema de Listas

Problema 1. Un verdugo es mandado a exterminar a n prisioneros de guerra. El exterminio lo

ejecuta de la siguiente manera: los prinsioneros forman un crculo al rededor del verdugo, el

verdugo elige a quien fusilar primero, una vez muerto el primero, el verdugo cuenta, a partir del

lugar donde estaba su ultima victima, k prisioneros en orden de las manesillas del reloj, y luego

fusila al k-simo prisionero despues de su ltima vctima (a los muertos no los cuenta), y repite

este proceso hasta que solo quede un prisionero. El ltimo prisionero podr ser liberado. El

verdugo tiene un amigo entre los n prisioneros, escribe un programa que dado, n, k y la ubicacin

de su amigo, le diga a quien fusilar primero, para asegurar que su amigo sea el que quede libre.


30

4. Almacenamiento dinmico

4.1 Manejo dinmico de la memoria Los punteros

Cmo se almacena una variable?

Una computadora opera manipulando direcciones de memoria y los valores almacenados en

dichas direcciones. Un lenguaje de programacin es una herramienta que permite al programador

codificar operaciones binarias en un lenguaje ms parecido a nuestro lenguaje natural. Un

programa que realiza la traduccin de instrucciones desde un lenguaje de programacin dado al

lenguaje de maquina se llama compilador.

Una variable es un recurso, entre otros, para manipular un dato binario de modo ms legible. Una

variable es un identificador de dato, al igual que el nombre de una funcin, este NOMBRE

representa para la maquina una localidad de memoria donde el programa puede almacenar y

manipular un dato.

Una declaracin de variable como:

char xx=B;

int nn=25;

produce una asociacin entre los nombre 'xx', nn y sus correspondientes espacios de

almacenamiento en memoria. Por lo tanto hay dos elementos relacionados con el nombre de una

variable: un valor que se puede almacenar all y una direccin de memoria para la variable.

Existe una correspondencia entre el nombre de cada variable y una direccin de memoria a quien

representa; es decir, el nombre de la variable propiamente dicha (por ejemplo xx) es solo un

smbolo grfico que realmente significa una direccin. Esta asociacin podemos representarla

como una tabla virtual de variables. En consecuencia, esta tabla, luego de las anteriores

declaraciones y asignaciones, podra tener el siguiente estado:

Realmente las direcciones de la tabla virtual existen en lo que podramos llamar el espacio real

de datos, el cual se puede representar como una tabla que podra tener el siguiente estado:

Nombre de la variable Direccin de memoria

xx 0012FF8B

nn 0012FF84

Direccin de memoria Contenido

0012FF8B 00000042

0012FF84 00000019

B

25


31

Adems del identificador "xx", tenemos la palabra "char" que nos indica el tipo (type) de la

variable. El tipo nos indica:

Cuantas celdas de memoria se reservan para ese nombre de variable; es decir cuantos bytes. Como se interpretarn los bits contenidos en ese espacio o direccin de memoria

Para el manejo de direcciones y contenidos de variables existen dos operadores: & de direccin y

* de indireccin.

Operador de direccion &. El operador (ampersand) & aplicado como prefijo a una variable,

devuelve la direccin de memoria en la que se encuentra la variable (sea variable normal o

variable puntero).

Operador de indireccion *. El asterisco escrito como prefijo de una variable puntero o de una

direccin de memoria, permite acceder o referirse al contenido de dicho puntero o direccin de

memoria.

Por ejemplo:

&xx : devuelve la direccin en la que se encuentra la variable xx.

*xx: permite acceder al contenido de la variable xx.

Entonces, si escribimos: printf("%p \n", &xx); // p formato para punteros

obtendremos una direccin de memoria como 0012FF8B

si escribimos: *(&xx) = C;

estamos almacenando el carcter C en la variable xx. Esta ltima expresin es equivalente a:

xx = C;

Por otra parte se sabe que un byte es la menor unidad de informacin que pueden direccionar la

mayora de las computadoras. En la mayora de las arquitecturas el tipo char ocupa un solo byte.

Un bool admite solo dos valores diferentes, pero es almacenado como un byte. El tipo int de C++

ocupa generalmente 2 bytes, un long 4, double 8, y as con el resto de los tipos.

El otro punto es la relacin entre lo que hay en una celda de memoria y como es interpretado. Lo

que hay en un celda cuya extensin es un byte es simplemente un conjunto de ocho estados

posibles (8 bits) que a nivel hardware admiten dos estados diferenciables, estados que pueden ser

simbolizados como 'verdadero/falso', 0/1, o cualquier otro par de valores.

As, la variable xx del ejemplo anterior en el espacio de datos, tiene como contenido lo siguiente:


32

Pero que significa este contenido?, Depende en gran medida del tipo (type) que hayamos

asociado a esa celda (y suponiendo que exista tal asociacin). Ese contenido interpretado como

un hexadecimal es 0x42, en decimal es 66, y si fue asociado al tipo char (este es el caso del

ejemplo) representara la letra 'B', cuyo codigo ASCII es igual a 66. En ninguna localidad de

memoria hay algo como la letra 'B', lo que encontramos son valores binarios que en caso de estar

asociados a char y en caso de que lo saquemos en pantalla como char har que veamos

encendidos ciertos pixeles de pantalla, en los cuales reconoceremos una representacin de la letra

'B'.

Puesto que la representacin binaria de datos ocupa demasiado espacio, es preferible utilizar el

sistema hexadecimal, que adems de ser muy fcil de traducir a binario es ms prctico.

Qu son los punteros?

Un puntero es un tipo especial de variable, cuyo contenido es el valor de una direccin de

memoria, esta direccin puede ser la de una variable individual, pero ms frecuentemente ser la

de un elemento de un arreglo, o una estructura u objeto de una clase. Los punteros, al igual que

una variable comn, pertenecen a un tipo (type), se dice que un puntero 'apunta a' ese tipo al que

pertenece.

Continuando con el ejemplo anterior, declaramos los siguientes punteros

char *x; // Puntero a char int *n; // Puntero a entero

x = &xx; // asignamos la direccin de la variable xx al puntero x

n = &nn; // asignamos la direccin de la variable nn al puntero n

Luego de las anteriores declaraciones, la tabla virtual de variables podra tener el siguiente

estado:

Nombre de la variable Direccin de memoria

xx 0012FF8B

nn 0012FF84

*x 0012FF80

*n 0012FF7C

0 0 0 0 0 0 4 2


33

Tambin podemos suponer que el espacio real de datos podra tener el siguiente estado:

Como se puede ver, un puntero es, en esencia, una variable cuyo contenido es una direccin de

memoria, que apunta a un tipo dado.

El siguiente programa en C++, prueba lo explicado en este apartado

Direccin de memoria Contenido

0012FF80

0012FF8B

0012FF7C

0012FF84

0012FF8B 00000042

0012FF84 00000019

B

25

Apunta a xx

Apunta a nn

#include #include

main()

{ char xx='B';

int nn=25; char *x;

int *n;

x = &xx; n = &nn;

printf("TABLA DE VARIABLES\n\n");

printf(" Variable Direccion \n\n"); printf("%15s ", "xx"); printf("%15p \n", &xx);

printf("%15s ", "nn"); printf("%15p \n", &nn);

printf("%15s ", "*x"); printf("%15p \n", &x);

printf("%15s ", "*n"); printf("%15p \n", &n);

printf("\n\n\nESPACIO DE DATOS\n\n");

printf(" Direccion Contenido Comentario\n\n"); printf("%15p ", &xx); printf("%15p ", xx); printf(" %-15c \n", xx);

printf("%15p ", &nn); printf("%15p ", nn); printf(" %-15i \n", nn);

printf("%15p ", &x); printf("%15p ", x); printf(" %-15s \n", "apunta a xx"); printf("%15p ", &n); printf("%15p ", n); printf(" %-15s \n", "apunta a nn");

getchar();

}


34

Independientemente del tamao (sizeof en C++) del objeto apuntado, el valor almacenado por el

puntero ser el de una nica direccin de memoria. En sentido estricto un puntero no puede

almacenar la direccin de memoria de un arreglo (completo), sino la de un elemento del arreglo,

y por este motivo no existen diferencias sintcticas entre punteros a elementos individuales y

punteros a arrays. La declaracin de un puntero a un tipo char y otro a un arreglo de char es

igual.

Al definir variables o arreglos hemos visto que el tipo (type) modifica la cantidad de bytes que se

usaran para almacenar tales elementos, as un elemento de tipo 'char' utiliza 1 byte, y un entero 2

o 4. No ocurre lo mismo con los punteros, el tipo no influye en la cantidad de bytes asociados al

puntero, pues todas las direcciones de memoria se pueden expresar con solo 2 bytes (o 4 si es una

direccin de otro segmento)

La forma general de declarar un puntero es la siguiente:

Ejemplos:

int * pe // pe es un puntero a un entero

float *f // f es un puntero a float

TMatriz *m // m es un puntero a un objeto de la clase TMatriz.

int **t // t es un puntero a un puntero que apunta a entero

TRacional *r // r es un puntero a objetos de la clase TRacional

4.2. Listas encadenadas

Una estructura de datos muy utilizada en programacin es la lista encadena (editores de texto,

compiladote, interfaces de bases de datos, etc.). En C++, es posible crear clases que representen a

listas encadenadas y que facilitarn la gestin de estas listas.

Una lista encadenada consta de nodos que se pueden almacenar en cualquier parte de la memoria

del sistema. Cada nodo contiene los datos asociados con el nodo y la direccin o puntero del

siguiente nodo. La siguiente figura muestra la estructura lgica de la lista encadenada.

TipoDeDato *NombrePuntero


35

Dato Link

Donde Head representa el comienzo de la lista

Una lista encadenada se puede implementar mediante arreglos, esta manera de implementacin

de listas basadas en arreglos funcionan bien para listas estticas, sin embargo tiene algunas

desventajas importantes:

Alta volatilidad de datos. No resultan eficientes para listas dinmicas en las que continuamente se estn aadiendo y eliminando elementos.

Procesos lentos. La razn es que, en general, para insertar o eliminar un elemento de la lista tenemos que desplazar otros elementos.

Cantidad limitada de datos. Existen problemas de programacin en los cuales no se conocen con anticipacin la cantidad mxima de elementos a insertar a la lista.

Los procesos de insercin eliminacin en las listas estticas requieren recorrer gran parte de los datos y modificar su posicin de todos los elementos causando un retraso en el

procesamiento

La mayora de estas desventajas pueden ser superadas utilizando listas implementadas con

punteros; es decir manejando dinmicamente la memoria.

4.3 Diseo e implementacin dinmica de listas encadenadas

Para implementar una lista encadena mediante punteros, es necesario definir el concepto de nodo,

en base al cual se definir la lista encadenada.

Estructura de Nodo

Un nodo es una estructura en memoria dividida en al menos dos campos:

Un campo para almacenar la

ddiirreecccciinn ddee

mmeemmoorriiaa ddeell

ssiigguuiieennttee nnooddoo de informacin si este existe

Un campo para los datos (de cualquier tipo) que contienen la informacin o elementos que conforman la lista

Dato Null

Dato Dato Link

El Campo de enlace link proporciona la direccin o referencia del siguiente nodo de la lista

En caso de que un nodo sea nodo terminal, se representa como Null, cero o un smbolo de tierra

NODO


36

Una posible implementacin en C++ de un nodo es la siguiente:

Estructura de Lista encadenada

Una lista encadenada o lista enlazada es una coleccin de elementos nodos, en donde cada uno

contiene datos y un enlace o link al siguiente nodo de la lista

Para acceder a los elementos de la lista encadenada basta conocer la direccin de memoria del

primer nodo.

Esquema y diseo de una lista enlazada

Dependiendo de donde se aplique la lista enlazada se pueden optar por diversos diseos de

acuerdo a las necesidades del problema en particular a continuacin mostraremos algunos de los

diseos mas utilizados

a) Con un solo puntero

Link Dato Link Dato Link Dato

L

class nodo { public: char dato; nodo *link; nodo() { dato = ' '; link = NULL; } void imprimir(); // void poner(char valor); // char obtener(); };

El programa completo se puede ver en clase lista)


37

Para agregar un elemento o llegar al ltimo elemento de la lista se tiene que navegar toda la lista

desde el inicio, este hecho se considera como una desventaja ya que representa una tardanza en el

hecho de navegar secuencialmente de nodo a nodo

b) Con dos punteros

Mejora el inconveniente anterior pero ocupa ms espacio para almacenar el puntero al ltimo

nodo. Si se requiere conocer la cantidad de elementos se tendra que navegar y contar los

elementos (Mucho proceso para algo que puede ser ms simple) este hecho se considera como

una desventaja.

Ultimo

F

Primero L


Primero


class lista { private : nodo *L; // apunta al comienzo de la lista nodo *F; // apunta al final de la lista int tam; public: lista() { L = NULL; tam = 0; } void tamano(); void anadirFin(char c); void anadirIni(char c); void recorrer(); void insertar(int u, char c);

// inserta c despues de la posicin u. // Si excede el tamao actual inserta al final void eliminar(int u); // elimina de la posicin u }; El programa completo se puede ver en clase lista)


38

c) Con dos punteros y un campo tamao

Mejora el diseo anterior manteniendo un campo (tamao) actualizado en todos los procesos de

insercin y eliminacin que permita almacenar la cantidad de nodos de la lista, de modo que el

hecho de conocer la cantidad de nodos no sera ms que una simple devolucin de esta variable

actualizada en todas las operaciones que modifiquen la cantidad de nodos de la lista.

Definicin de operaciones

Las principales operaciones que podemos realizar sobre la lista encadenada simple son:

RReeccoorrrriiddoo IInnsseerrcciinn BBoorrrraaddoo BBssqquueeddaa

Operacin de Recorrido

Consiste en visitar cada uno de los nodos que forman la lista. Se comienza con el primero, se

toma el valor del campo Link para avanzar al segundo nodo, as sucesivamente.

Cuando se encuentre un link = Null se habr terminado de recorrer la lista

L

P

55 22 99 77

Tamao = 3 Ultimo Primero

Link 23 Link 60 Link 90

55

L

22 99

00 77

P

Fx


39

Utilizando una variable auxiliar P que se inicia en L y desde ah se comienza a navegar de nodo en nodo utilizando el Link de cada uno de ellos. El hecho de utilizar un puntero auxiliar es para

no alterar el valor del puntero L ya que si se altera se puede perder la direccin de toda la lista enlazada.

Operacin de Insercin

Consiste en insertar un nodo a cualquier parte de la lista, esto se realiza mediante asignacin

dinmica de memoria es decir que se reserva memoria para un nuevo nodo y luego se almacena

en l el dato para enlazarlo a la lista en el lugar deseado ya sea al principio de la lista, al final o

entre medio de la lista. En cualquiera de los casos se deben actualizar los punteros de los nodos

adyacentes para mantener la lista enlazada.

El proceso se realiza en cuatro pasos, dada una lista como la que muestra a continuacin:

1) Se crea un nuevo nodo, al cual se le asigna un dato:

2) Se recorre la lista hasta el lugar de insercin, mediante un puntero P:

3) Se copia el campo link del nodo apuntado por P, al campo link del nuevo nodo N:

55

L

22 99 77

55

L

22 99 77

P

55

L

22 99 77

P 4

N

44

N


40

4) Por ltimo, se copia en el campo link del nodo apuntado por P, el puntero N del nuevo nodo:

Operacin de Borrado

Consiste en eliminar un nodo de lista enlazada, en este caso se debe actualizar las direcciones de

los punteros necesarios y liberar la memoria ocupada por el nodo al sistema operativo para que

pueda ser utilizado en otras operaciones.

Operacin de Bsqueda

Consiste en buscar un elemento cualquiera en la lista enlazada, este hecho se realiza recorriendo

la lista y comparando el dato de cada uno de los nodos visitados con el elemento que se est

buscando hasta que se lo encuentre. Es similar a la operacin de recorrido.

4.4. Implementacin dinmica de estructuras de datos

Las estructuras de datos dinmicas como son las pilas y las colas son mejor implementadas

mediante el manejo dinmico de memoria, a travs de punteros.

Implementacin de pilas con punteros

Utilizando la estructura nodal de un

Estructura de Datos 1

Documents

Transcript of Estructura de Datos 1