MD Estructuras de Datos

ESTRUCTURA DE DATOS I MANUAL DEL DOCENTE
Objetivo de la
unidad
Introducción a la
asignatura
Desglose de
temas
Glosario
MANUAL DEL DOCENTE
ESTRUCTURA DE DATOS I
SECRETARÍA DE EDUCACIÓN PÚBLICA

SUBSECRETARÍA DE EDUCACIÓN SUPERIOR E INVESTIGACIÓN CIENTÍFICA
SUBSISTEMA DE UNIVERSIDADES TECNOLÓGICAS
COORDINACIÓN GENERAL DE UNIVERSIDADES TECNOLÓGICAS
UNIVERSIDAD TECNOLÓGICA DE IZÚCAR DE MATAMOROS
LIC. IVAN ANTONIO FLORES

TRUJILLO
ELABORÓ: LIC. ALEJANDRO SALVADOR REVISÓ: CUERPO COLEGIADO TIC-SI
VARGAS
FECHA DE ENTRADA
APROBÓ: CUERPO COLEGIADO TIC-SI EN VIGOR: SEPTIEMBRE 2004
I. DIRECTORIO
Dr. Reyes Taméz Guerra

Secretario de Educación Pública
Dr. Julio Rubio Oca
Subsecretario de Educación Superior e Investigación Científica
DR. Arturo Nava Jaimes
Coordinador General de Universidades Tecnológicas
Reconocimientos
Universidad Tecnológica Izúcar de Matamoros
División de TIC-SI
Estructuras de Datos D.R.  2005
ESTA OBRA, SUS CARACTERÍSTICAS Y DERECHOS SON PROPIEDAD DE LA: COORDINACIÓN

GENERAL DE UNIVERSIDADES TECNOLÓGICAS (CGUT) FRANCISCO PETRARCA No. 321, COL.
CHAPULTEPEC MORALES, MÉXICO D.F. LOS DERECHOS DE PUBLICACIÓN PERTENECEN A LA CGUT.
QUEDA PROHIBIDA SU REPRODUCCIÓN PARCIAL O TOTAL POR CUALQUIER MEDIO, SIN
AUTORIZACIÓN PREVIA Y POR ESCRITO DEL TITULAR DE LOS DERECHOS.
ISBN (EN TRÁMITE)
IMPRESO EN MÉXICO.
Estructura de Datos. UTIM

ÍNDICE
Preámbulo…………………………………………………………………………………………………………5
1. Antecedentes……………………………………………………………………………9.
1.1. Introducción a la orientación a objetos……………………………………………9
1.2. Tipos de datos abstractos…………………………………………………………...11
1.3. Definición de estructuras de datos………………………………………………….14
1.4. Acceso directo y Secuencial a los datos………………………………… 16
1.5. Iteradores……………………………………………………………………………………………… 16
1.6. Apuntadores o punteros…………………………………………………………...16
1.7. Plantillas (Templates)……………………………………………………………..34
1.8. La biblioteca STL…………………………………………………………………38
2. Arreglos………………………………………………………………………………..34
2.1. Introducción…..…………………………………………………………………...34
2.2. Arreglos dinámicos………………………………………………………………..36
2.3. La clase VECTOR………………………………………………………………...36
3. Listas…………………………………………………………………………………...44
3.1. Definición de lista…………………………………………………………………44
3.2. Operaciones básicas con listas…………………………………………………….45
3.2.1. Insertar un elemento en la lista……………………………………………..45
3.2.2. Localizar un elemento en la lista…………………………………………...47
3.2.3. Eliminar elementos de la lista……………………………………………...48
3.2.4. Moverse a través de una lista………………………………………………50
3.2.5. Borrar una lista completa…………………………………………………..50
3.2.6. Ejemplo de lista Ordenada………………………………………………....50
3.2.7. Ejemplo de lista en C++ usando clases…………………………………….53
3.3. La clase LIST de STL……………………………………………………………..54
4. Pilas…………………………………………………………………………………….58
4.1. Definición de pilas……………………………………………………………...…58
4.2. Operaciones básicas con pilas……………………………………………………..59
4.2.1. Push, insertar elemento…………………………………………………….59
4.2.2. Pop, leer y eliminar un elemento…………………………………………...60
4.3. Implementación de pilas…………………………………………………………..60
4.3.1. Ejemplo de pilas en C++ usando clases……………………………………61
4.4. La clase STACK de STL………………………………………………………….62
5. Colas…...………………………………………………………………………………65
5.1. Definición de colas………………………………………………………………..65
5.2. Operaciones básicas con colas…………………………………………………….66
5.2.1. Añadir un elemento………………………………………………………...66
5.2.2. Leer un elemento…………………………………………………………..67
5.3. Implementación de colas………………………………………………………….69
5.3.1. Ejemplo de una cola en C++ usando clases………………………………..70
5.4. La clase QUEUE de STL………………………………………………………….71
6. Árboles…….…………………………………………………………………………..73
6.1. Definición de árboles……………………………………………………………...73

6.2. Árboles binarios…………………………………………………………………...75

6.3. Árboles de Búsqueda binaria……………………………………………………...76
6.3.1. Operaciones en ABB. ……………………………………………………..76
6.3.1.1. Buscar un elemento…………………………………………………77
6.3.1.2. Insertar un elemento………………………………………………...77
6.3.1.3. Eliminar un elemento……………………………………………….78
6.3.2. Ejemplos de eliminación en un ABB………………………………………79
6.4. Aplicaciones de árboles…………………………………………………………...81
Bibliografía……………………………...…………………………………...……………82

Preámbulo.
Resumidamente, el ANSI define un conjunto de reglas. Cualquier compilador de C
o de C++ debe cumplir esas reglas, si no, no puede considerarse un compilador de
C o C++. Estas reglas definen las características de un compilador en cuanto a
palabras reservadas del lenguaje, comportamiento de los elementos que lo
componen, funciones externas que se incluyen, etc. Un programa escrito en ANSI
C o en ANSI C++, podrá compilarse con cualquier compilador que cumpla la
norma ANSI. Se puede considerar como una homologación o etiqueta de calidad
de un compilador.
Todos los compiladores incluyen, además del ANSI, ciertas características no

ANSI, por ejemplo librerías para gráficos. Pero mientras no usemos ninguna de
esas características, sabremos que nuestros programas son transportables, es
decir, que podrán ejecutarse en cualquier ordenador y con cualquier sistema
operativo.
Este curso es sobre C++, con respecto a las diferencias entre C y C++, habría
mucho que hablar, pero no es este el momento adecuado. Pero para comprender
muchas de estas diferencias necesitarás cierto nivel de conocimientos de C++.
Probablemente este es el lugar más adecuado para explicar cómo se obtiene un

fichero ejecutable a partir de un programa C++.
Para empezar necesitamos un poco de vocabulario técnico. Veremos algunos

conceptos que se manejan frecuentemente en cualquier curso de programación y
sobre todo en manuales de C y C++.
Archivos fuente y programa o código fuente:
Los programas C y C++ se escriben con la ayuda de un editor de textos del mismo
modo que cualquier texto corriente. Los ficheros que contiene programas en C o
C++ en forma de texto se conocen como ficheros fuente, y el texto del programa
que contiene se conoce como programa fuente. Nosotros siempre escribiremos
programas fuente y los guardaremos en ficheros fuente.
Archivos objeto, código objeto y compiladores:
Los programas fuente no pueden ejecutarse. Son ficheros de texto, pensados para
que los comprendan los seres humanos, pero incomprensibles para los
ordenadores.
Para conseguir un programa ejecutable hay que seguir algunos pasos. El primero
es compilar o traducir el programa fuente a su código objeto equivalente. Este es
el trabajo que hacen los compiladores de C y C++. Consiste en obtener un fichero

equivalente a nuestro programa fuente comprensible para el ordenador, este

fichero se conoce como fichero objeto, y su contenido como código objeto.
Los compiladores son programas que leen un fichero de texto que contiene el
programa fuente y generan un fichero que contiene el código objeto.
El código objeto no tiene ningún significado para los seres humanos, al menos no
directamente. Además es diferente para cada ordenador y para cada sistema
operativo. Por lo tanto existen diferentes compiladores para diferentes sistemas
operativos y para cada tipo de ordenador.
Librerías:
Junto con los compiladores de C y C++, se incluyen ciertos ficheros llamados

librerías. Las librerías contienen el código objeto de muchos programas que
permiten hacer cosas comunes, como leer el teclado, escribir en la pantalla,
manejar números, realizar funciones matemáticas, etc. Las librerías están
clasificadas por el tipo de trabajos que hacen, hay librerías de entrada y salida,
matemáticas, de manejo de memoria, de manejo de textos, etc.
Hay un conjunto de librerías muy especiales, que se incluyen con todos los
compiladores de C y de C++. Son las librerías ANSI o estándar. Pero también hay
librerías no estándar, y dentro de estas las hay públicas y comerciales. En este
curso sólo usaremos librerías ANSI.
Archivos ejecutables y enlazadores:
Cuando obtenemos el fichero objeto, aún no hemos terminado el proceso. El

fichero objeto, a pesar de ser comprensible para el ordenador, no puede ser
ejecutado. Hay varias razones para eso:
1. Nuestros programas usaran, en general, funciones que estarán incluidas en

librerías externas, ya sean ANSI o no. Es necesario combinar nuestro fichero
objeto con esas librerías para obtener un ejecutable.
2. Muy a menudo, nuestros programas estarán compuestos por varios ficheros
fuente, y de cada uno de ellos se obtendrá un fichero objeto. Es necesario unir
todos los ficheros objeto, más las librerías en un único fichero ejecutable.
3. Hay que dar ciertas instrucciones al ordenador para que cargue en memoria
el programa y los datos, y para que organice la memoria de modo que se
disponga de una pila de tamaño adecuado, etc. La pila es una zona de
memoria que se usa para que el programa intercambie datos con otros
programas o con otras partes del propio programa. Veremos esto con más
detalle durante el curso.
Existe un programa que hace todas estas cosas, se trata del "link", o enlazador. El
enlazador toma todos los ficheros objeto que componen nuestro programa, los
combina con los ficheros de librería que sea necesario y crea un fichero ejecutable.

Una vez terminada la fase de enlazado, ya podremos ejecutar nuestro programa.
Errores:
Por supuesto, somos humanos, y por lo tanto nos equivocamos. Los errores de
programación pueden clasificarse en varios tipos, dependiendo de la fase en que
se presenten.
Errores de sintaxis: son errores en el programa fuente. Pueden deberse a palabras

reservadas mal escritas, expresiones erróneas o incompletas, variables que no
existen, etc. Los errores de sintaxis se detectan en la fase de compilación. El
compilador, además de generar el código objeto, nos dará una lista de errores de
sintaxis. De hecho nos dará sólo una cosa o la otra, ya que si hay errores no es
posible generar un código objeto.
Avisos: además de errores, el compilador puede dar también avisos (warnings).

Los avisos son errores, pero no lo suficientemente graves como para impedir la
generación del código objeto. No obstante, es importante corregir estos avisos, ya
que el compilador tiene que decidir entre varias opciones, y sus decisiones no
tienen por qué coincidir con lo que nosotros pretendemos, se basan en las
directivas que los creadores del compilador decidieron durante su creación.
Errores de enlazado: el programa enlazador también puede encontrar errores.

Normalmente se refieren a funciones que no están definidas en ninguno de los
ficheros objetos ni en las librerías. Puede que hayamos olvidado incluir alguna
librería, o algún fichero objeto, o puede que hayamos olvidado definir alguna
función o variable, o lo hayamos hecho mal.
Errores de ejecución: incluso después de obtener un fichero ejecutable, es posible

que se produzcan errores. En el caso de los errores de ejecución normalmente no
obtendremos mensajes de error, sino que simplemente el programa terminará
bruscamente. Estos errores son más difíciles de detectar y corregir. Existen
programas auxiliares para buscar estos errores, son los llamados depuradores
(debuggers). Estos programas permiten detener la ejecución de nuestros
programas, inspeccionar variables y ejecutar nuestro programa paso a paso. Esto
resulta útil para detectar excepciones, errores sutiles, y fallos que se presentan
dependiendo de circunstancias distintas.
Errores de diseño: finalmente los errores más difíciles de corregir y prevenir. Si nos
hemos equivocado al diseñar nuestro algoritmo, no habrá ningún programa que
nos pueda ayudar a corregir los nuestros. Contra estos errores sólo cabe practicar
y pensar.
Propósito de C/C++
¿Qué clase de programas y aplicaciones se pueden crear usando C y C++?

La respuesta es muy sencilla: TODOS.
Tanto C como C++ son lenguajes de programación de propósito general. Todo

puede programarse con ellos, desde sistemas operativos y compiladores hasta
aplicaciones de bases de datos y procesadores de texto, pasando por juegos,
aplicaciones a medida, etc.
Oirás y leerás mucho sobre este tema. Sobre todo diciendo que estos lenguajes
son complicados y que requieren páginas y páginas de código para hacer cosas
que con otros lenguajes se hacen con pocas líneas. Esto es una verdad a medias.
Es cierto que un listado completo de un programa en C o C++ para gestión de
bases de datos (por poner un ejemplo) puede requerir varios miles de líneas de
código, y que su equivalente en Visual Basic sólo requiere unos pocos cientos.
Pero detrás de cada línea de estos compiladores de alto nivel hay cientos de líneas
de código en C, la mayor parte de estos compiladores están respaldados por
enormes librerías escritas en C. Nada te impide a ti, como programador, usar
librerías, e incluso crear las tuyas propias.
Una de las propiedades de C y C++ es la reutilización del código en forma de

librerías de usuario. Después de un tiempo trabajando, todos los programadores
desarrollan sus propias librerías para aquellas cosas que hacen frecuentemente. Y
además, raramente piensan en ello, se limitan a usarlas.
Además, los programas escritos en C o C++ tienen otras ventajas sobre el resto.
Con la excepción del ensamblador, generan los programas más compactos y
rápidos. El código es transportable, es decir, un programa ANSI en C o C++ podrá
ejecutarse en cualquier máquina y bajo cualquier sistema operativo. Y si es
necesario, proporcionan un acceso a bajo nivel de hardware sólo igualado por el
ensamblador.
Otra ventaja importante, C tiene más de 30 años de vida, y C++ casi 20 y no

parece que su uso se debilite demasiado. No se trata de un lenguaje de moda, y
probablemente a ambos les quede aún mucha vida por delante. Sólo hay que
pensar que sistemas operativos como Linux, Unix o incluso Windows se escriben
casi por completo en C.
Por último, existen varios compiladores de C y C++ gratuitos, o bajo la norma

GNU, así como cientos de librerías de todo propósito y miles de programadores en
todo el mundo, muchos de ellos dispuestos a compartir su experiencia y
conocimientos.

1. Antecedentes
1.1. Introducción a la orientación a objetos.
La programación orientada a objetos (POO) es una nueva manera de

enfocar la programación. Desde sus comienzos, la programación ha estado
gobernada por varias metodologías. En cada punto crítico de la evolución de la
programación se creaba un nuevo enfoque para ayudar al programador a manejar
programas cada vez más complejos. Los primeros programas se crearon mediante
un proceso de cambio de los conmutadores del panel frontal de la computadora.
Obviamente, este enfoque solo es adecuado para programas pequeños. A
continuación se invento el lenguaje ensamblador que permitió escribir programas
más largos. El siguiente avance ocurrió en los años 50 cuando se invento el primer
lenguaje de alto nivel (FORTRAN).
Mediante un lenguaje de alto nivel, un programador estaba capacitado para

escribir programas que tuvieran una longitud de varios miles de líneas. Sin
embargo, el método de programación usado en el comienzo era un enfoque adhoc
que no solucionaba mucho. Mientras que esto esta bien para programas
relativamente cortos, se convierte en “código espagueti” ilegible y difícil de tratar
cuando se aplica a programas más largos. La eliminación del código espagueti se
consiguió con la creación de los lenguajes de programación estructurados en los
años sesenta. Estos lenguajes incluyen ALGOL y PASCAL. En definitiva, C es un
lenguaje estructurado, y casi todos los tipos de programas que se han estado
haciendo se podrían llamar programas estructurados.
Los programas estructurados se basan en estructuras de control bien

definidas, bloques de código, la ausencia del GOTO, y subrutinas independientes
que soportan recursividad y variables locales. La esencia de la programación
estructurada es la reducción de un programa a sus elementos constitutivos.
Mediante la programación estructurada un programador medio puede crear y
mantener programas de una longitud superior a 50,000 líneas.
Aunque la programación estructurada nos ha llevado a excelentes

resultados cuando se ha aplicado a programas moderadamente complejos, llega a
fallar en algún punto cuando el programa alcanza un cierto tamaño. Para poder
escribir programas de mayor complejidad se necesitaba de un nuevo enfoque en la
tarea de programación. A partir de este punto nace la programación orientada a
objetos (POO). La POO toma las mejores ideas incorporadas en la programación
estructurada y las combina con nuevos y potentes conceptos que permiten
organizar los programas de forma más efectiva. La POO permite descomponer un
problema en subgrupos relacionados. Cada subgrupo pasa a ser un objeto
autocontenido que contiene sus propias instrucciones y datos que le relacionan
con ese objeto. De esta manera, la complejidad se reduce y el programador puede
tratar programas más largos.

Todos los lenguajes de POO comparten tres características: encapsulación,

polimorfismo y herencia.
Encapsulación.
La encapsulación es el mecanismo que agrupa el código y los datos que

maneja y los mantiene protegidos frente a cualquier interferencia y mal uso. En un
lenguaje orientado a objetos, el código y los datos suelen empaquetarse de la
misma forma en que se crea una “caja negra” autocontenida. Dentro de la caja son
necesarios tanto el código como los datos. Cuando el código y los datos están
enlazados de esta manera, se ha creado un objeto. En otras palabras, un objeto es
el dispositivo que soporta encapsulación.
En un objeto, los datos y el código, o ambos, pueden ser privados para ese
objeto o públicos. Los datos o el código privado solo los conoce o son accesibles
por otra parte del objeto. Es decir, una parte del programa que esta fuera del
objeto no puede acceder al código o a los datos privados. Cuando los datos o el
código son públicos, otras partes del programa pueden acceder a ellos, incluso
aunque este definido dentro de un objeto. Normalmente, las partes públicas de un
objeto se utilizan para proporcionar una interfaz controlada a las partes privadas
del objeto.
Para todos los propósitos, un objeto es una variable de un tipo definido por
el usuario. Puede parecer extraño que un objeto que enlaza código y datos se
pueda contemplar como una variable. Sin embargo, en programación orientada a
objetos, este es precisamente el caso. Cada vez que se define un nuevo objeto, se
esta creando un nuevo tipo de dato. Cada instancia específica de este tipo de dato
es una variable compuesta.
Polimorfismo.
Polimorfismo (del Griego, cuyo significado es “muchas formas”) es la

cualidad que permite que un nombre se utilice para dos o más propósitos
relacionados pero técnicamente diferentes. El propósito del polimorfismo aplicado
a la POO es permitir poder usar un nombre para especificar una clase general de
acciones. Dentro de una clase general de acciones, la acción específica a aplicar
está determinada por el tipo de dato. Por ejemplo, en C, que no se basa
significativamente en el polimorfismo, la acción de valor absoluto requiere tres
funciones distintas: abs(), labs() y fabs(). Estas tres funciones calculan y devuelven
el valor absoluto de un entero, un entero largo y un valor real, respectivamente. Sin
embargo, en C++, que incorpora polimorfismo, a cada función se puede llamar
abs().

El tipo de datos utilizado para llamar a la función determina que versión

específica de la función se esta usando, es decir, es posible usar un nombre de
función para propósitos muy diferentes. Esto se llama sobrecarga de funciones.
De manera general, el concepto de polimorfismo es la idea de “una interfaz,

múltiples métodos”. Esto significa que es posible diseñar una interfaz genérica
para un grupo de actividades relacionadas. Sin embargo, la acción específica
ejecutada depende de los datos. La ventaja del polimorfismo es que ayuda a
reducir la complejidad permitiendo que la misma interfaz se utilice para especificar
una clase general de acción. Es trabajo del compilador seleccionar la acción
específica que se aplica a cada situación. El programador no necesita hacer esta
selección manualmente, solo necesita recordar y utilizar la interfaz general.
El polimorfismo se puede aplicar tanto a funciones como a operadores,

prácticamente todos los lenguajes de programación contienen una aplicación
limitada de polimorfismo cuando se relaciona con los operadores aritméticos, por
ejemplo, en C, el signo + se utiliza par añadir enteros, enteros largos, caracteres y
valores reales. En estos casos, el compilador automáticamente sabe que tipo de
aritmética debe aplicar, en C++, se puede ampliar este concepto a otros tipos de
datos que se definan, este tipo de polimorfismo se llama sobrecarga de
operadores.
Herencia.
La herencia es el proceso mediante el cual un objeto puede adquirir las

propiedades de otro. Mas en concreto, un objeto puede heredar un conjunto
general de propiedades a alas que puede añadir aquellas características que son
específicamente suyas. La herencia es importante porque permite que un objeto
soporte el concepto de clasificación jerárquica. Mucha información se hace
manejable gracias a esta clasificación, por ejemplo, la descripción de una casa.
Una casa es parte de una clase general llamada edificio, a su vez, edificio es una
parte de la clase mas general estructura, que es parte de la clase aun más general
de objetos que se puede llamar obra-hombre.
En cualquier caso, la clase hija hereda todas las cualidades asociadas con
la clase padre y le añade sus propias características definitorias. Sin el uso de
clasificaciones ordenadas, cada objeto tendría que definir todas las características
que se relacionan con él explícitamente.
Sin embargo, mediante el uso de la herencia, es posible describir un objeto

estableciendo la clase general (o clases) a las que pertenece, junto con aquellas
características específicas que le hacen único.
1.2 Tipos de datos abstractos.
Los tipos de datos abstractos (TDA) encapsulan datos y funciones que

trabajan con estos datos. Los datos no son visibles para el usuario en un tipo de

dato abstracto y el acceso a los datos es exclusivamente bajo el llamado a

funciones, también llamadas métodos. Así, el tipo de dato abstracto es
especificado por los métodos, no por los datos. En C++, los tipos de datos
abstractos son representados por clases, las cuales presentan a pequeña
deficiencia: el dato que representa el estado de un objeto de este tipo de dato
abstracto es visible (algunas veces no accesible) en la parte private de la clase
declarada para cada programa, la clase es reconocida mediante la vía # include.
Ejemplos de tipos de datos abstractos son: stack, queue, etc.
Los TDA por lo general manejan memoria dinámica, esto es, la asignación
dinámica de memoria es una característica que le permite al usuario crear tipos de
datos y estructuras de cualquier tamaño de acuerdo a las necesidades que se
tengan en el programa, para ello se emplean funciones típicas como malloc y free.
1.3 Definición de estructuras de datos.
En programación, una estructura de datos es una forma de organizar un

conjunto de datos elementales (un dato elemental es la mínima información que se
tiene en el sistema) con el objetivo de facilitar la manipulación de estos datos como
un todo y/o individualmente.
Una estructura de datos define la organización e interrelacionamiento de

estos, y un conjunto de operaciones que se pueden realizar sobre él. Las
operaciones básicas son:
 Alta, adicionar un nuevo valor a la estructura.

 Baja, borrar un valor de la estructura.
 Búsqueda, encontrar un determinado valor en la estructura para se realizar
una operación con este valor, en forma SECUENCIAL o BINARIO (siempre
y cuando los datos estén ordenados).
Otras operaciones que se pueden realizar son:
 Ordenamiento, de los elementos pertenecientes a la estructura.

 Apareo, dadas dos estructuras originar una nueva ordenada y que contenga
a las apareadas.
Cada estructura ofrece ventajas y desventajas en relación a la simplicidad y

eficiencia para la realización de cada operación. De esta forma, la elección de la
estructura de datos apropiada para cada problema depende de factores como las
frecuencias y el orden en que se realiza cada operación sobre los datos.
Algunas estructuras de datos utilizadas en programación son:
 Arrays (Arreglos)

o Vectores
o Matrices
 Listas Enlazadas
o Listas Simples
o Listas Dobles
o Listas Circulares
 Pilas (stack)
 Colas (queue)
 Árboles
o Árboles Binarios
 Árbol binario de búsqueda
 Árbol binario de búsqueda autoajustable
 Árboles Biselados (Árboles Splay)
o Árboles Multicamino (Multirrama)
 Árboles B
 Árboles B+
 Árboles B*
 Conjuntos (set)
 Grafos
 Montículos (o heaps)
1.4 Acceso Directo y Secuencial a los datos
 Secuencial. Para acceder a un objeto se debe acceder a los objetos

almacenados previamente en el archivo. El acceso secuencial exige
elemento a elemento, es necesario una exploración secuencial
comenzando desde el primer elemento.
 Directo o Aleatorio. Se accede directamente al objeto, sin recorrer los

anteriores. El acceso directo permite procesar o acceder a un elemento
determinado haciendo una referencia directamente por su posición en el
soporte de almacenamiento.
1.5 Iteradores
Un iterador es una especie de puntero utilizado por un algoritmo para recorrer los
elementos almacenados en un contenedor. Dado que los distintos algoritmos
necesitan recorrer los contenedores de diversas maneras para realizar diversas
operaciones, y los contenedores deben ser accedidos de formas distintas, existen

diferentes tipos de iteradores. Cada contenedor de la Librería Estándar puede

generar un iterador con funcionalidad adecuada a la técnica de almacenamiento
que utiliza. Es precisamente el tipo de iterador requerido como argumento, lo que
distingue que algoritmos STL pueden ser utilizados con cada clase de contenedor.
Por ejemplo, si un contenedor solo dispone de iteradores de acceso secuencial, no
pueden utilizarse con algoritmos que exijan iteradores de acceso aleatorio.
1.6 Apuntadores o punteros.
Un puntero es una variable destinada a contener una dirección de memoria.

Esta dirección generalmente corresponde a otra variable, decimos entonces que el
puntero contiene la dirección de la variable o que “apunta” a ésta.
En el siguiente esquema suponemos que la variable puntero está cargada

con el número 4A20. Decimos, entonces, que la dirección 0x4A20 es apuntada por
el puntero.
Usos y ventajas de los punteros
 Permiten el acceso a cualquier posición de la memoria, para ser leída o

para ser escrita (en los casos en que esto sea posible).
 Permiten la transferencia de argumentos a las funciones, de modo que
puedan retener un valor nuevo, que resulta de aplicarles la función.
 Permiten solicitar memoria que no fue reservada al inicio del programa.
Esto es el uso de memoria dinámica.
 Son el soporte de enlace que utilizan estructuras avanzadas de datos en
memoria dinámica como las listas, pilas, colas y árboles.
 Operan más eficientemente en los arrays, en comparación con el uso de
subíndices.
Declaración del tipo puntero
Sintaxis:

tipo * nombre_puntero;
nombre_puntero es el identificador de la variable.

El * es el operador de indirección que nos indica que la variable es de tipo puntero.
tipo indica el tipo de la variable apuntada por el puntero (se lo denomina tipo base).
Ejemplo 1:
En la siguiente declaración, p es un puntero a float, i es una variable tipo int y q es
un puntero a int.
int i, *q;
float *p;
Operadores para punteros
Operador &: Es un operador unario que devuelve la dirección de memoria de su

operando. A través de este operador podemos relacionar a los punteros con las
variables a ser apuntadas por los mismos. No puede aplicarse a expresiones,
constantes o variables tipo registro.
Operador *: Es el operador de indirección. También es unario y es relativamente

complementario del anterior. Da acceso a la variable señalada por el puntero.
Ejemplo 2:
int A, *p;
p = &A;
A partir de esta última sentencia, p se carga con la dirección de A, es decir,

p apunta a A. Y al suceder esto, *p es el contenido de lo apuntado por p, o sea, *p
es equivalente a A.
Recordar siempre que en la declaración “int A, *p” se está expresando que la

variable A corresponde a entero y que *p también corresponde a entero. Cuando
se declara un puntero, éste contiene “basura”y por lo tanto no apunta a nada. Es
necesario inicializarlo con el valor adecuado.
Asignación de punteros
Un puntero puede ser asignado de 3 maneras:
A través de otro puntero.
Ejemplo 3:
int A, *p, *q;
p = &A;
q = p;

En esta última sentencia, p apunta a A y a q se le carga el valor que

contiene p (que es justamente la dirección de memoria de A), por lo tanto *p es
equivalente a *q.
Con la dirección de una variable.
Es el caso de la segunda línea del ejemplo anterior.
Directamente con la dirección que deba contener.
Esta asignación se realiza entregándole un valor entero. Por ejemplo, al

realizar la asignación p = 10; p contendrá 0x000A (si la expresamos en el sistema
de numeración hexadecimal). Lo habitual es entregarle la dirección expresada
directamente en hexadecimal, aunque esto es sólo por comodidad, pues las
direcciones son de por sí números binarios. Si realizamos la asignación p =
0x0B75; p contendrá 0x0B75
Punteros y argumentos de funciones
Los punteros son útiles a la hora de hacer un paso de argumentos a una

función, en caso de ser necesario que la función modifique el valor de la variable
transferida. Esto es similar a lo que sería, en otros lenguajes, un paso por
referencia.
Ejemplo 10:
La siguiente función pretende intercambiar los valores de dos variables de tipo
float:
void swap(float x, float y)

{
int aux;
aux = x;
x = y;
y = aux;
}
La forma de invocar esta función podría ser swap(a, b), siendo a y b las
variables cuyos valores queremos intercambiar. De todas maneras, la función no
altera los valores de a y de b porque sólo intercambia “copias” de estas variables.
Hace un pasaje de argumentos por valor. Por lo tanto, esto no es correcto.
Ejemplo 11:
Luego de analizar el ejemplo anterior, observemos la siguiente función.
void swap(float *x, float *y)
{
int aux;

aux = *x;
*x = *y;
*y = aux;
}
Con esta función sí es posible intercambiar los valores de dos variables, y la

forma de invocarla es swap(&a, &b). Dentro de esta función, los parámetros se
declaran para ser punteros, y al invocarla se pasan las direcciones de a y de b.
Tipos de datos apuntados por punteros
Los tipos base apuntados pueden ser todos los provistos de manera
standard por el C++: int, char, long, float, double. También puede apuntar a un tipo
no especificado de dato como void, o a otro puntero.
Los punteros también pueden apuntar a tipos de datos creados por el

programador como cadenas, estructuras y uniones. No pueden apuntar a campos
de bit pues no pueden contener direcciones no enteras.
Punteros a caracteres
Sintaxis:
char * nombre_cadena;
Ejemplo 13:
El siguiente programa imprime en pantalla la frase “color azul”.
char * frase = “color azul”;

printf (“%s” , frase);
En su representación interna, las cadenas (y también los arreglos) terminan

con el carácter nulo „\0‟,de tal manera que sea posible encontrar el fin.
Punteros a estructura
Sintaxis:
struct tipo_estructura * nombre_estructura;
tipo_estructura es un rótulo de una estructura.

nombre_estructura es el identificador del puntero.
Ejemplo 17:

Se crea un tipo de dato estructura con el nombre fecha. Luego se declara una
variable de tipo estructura-fecha con el nombre hoy, y finalmente un puntero a
estructura-fecha llamado F.
struct fecha {
int día;
int mes;
int anio;
};
struct fecha hoy;
struct fecha * F;
F todavía no apunta a una dirección válida. Hacemos que F apunte a hoy,

cargándolo con la dirección de esa variable tipo estructura-fecha.
F = &hoy;
Observe la presencia del operador &. Es necesario no confundir una

estructura con un arreglo. En el caso de las estructuras, el nombre es el
identificador de la variable y representa a la variable misma, no a su dirección. Por
eso usamos el operador mencionado.
1.7 Plantillas (Templates).
La generalidad es una propiedad que permite definir una clase o una

función sin tener que especificar el tipo de todos o alguno de sus miembros. Esta
propiedad no es imprescindible en un lenguaje de programación orientado a
objetos y ni siquiera es una de sus características. Esta característica del C++
apareció mucho más tarde que el resto del lenguaje, al final de la década de los
ochenta. Esta generalidad se alcanza con las plantillas (templates).
La utilidad principal de este tipo de clases o funciones es la de agrupar

variables cuyo tipo no esté predeterminado . Así el funcionamiento de una pila, una
cola, una lista, un conjunto, un diccionario o un array es el mismo
independientemente del tipo de datos que almacene (int, long, double, char, u
objetos de una clase definida por el usuario). En definitiva estas clases se definen
independientemente del tipo de variables que vayan a contener y es el usuario de
la clase el que debe indicar ese tipo en el momento de crear un objeto de esa
clase.
Plantillas de funciones
Supóngase que se quiere crear una función que devolviese el mínimo entre
dos valores independientemente de su tipo (se supone que ambos tienen el mismo
tipo). Se podría pensar en definir la función tantas veces como tipos de datos se
puedan presentar (int, long, float, double, etc.). Aunque esto es posible, éste es un

caso ideal para aplicar plantillas de funciones. Esto se puede hacer de la siguiente
manera:
// Declaración de la plantilla de función

template <class T> T minimo( T a, T b);
En ese caso con <classT> se está indicando que se trata de una plantilla
cuyo parámetro va a ser el tipo T y que tanto el valor de retorno como cada uno de
los dos argumentos va a ser de este tipo de dato T. En la definición y declaración
de la plantilla puede ser que se necesite utilizar mas de un tipo de dato e incluido
algún otro parámetro constante que pueda ser utilizado en las declaraciones. Por
ejemplo, si hubiera que pasar dos tipos a la plantilla, se podría escribir:
// Declaración de la plantilla de función con dos tipos de datos

template <class T1, class T2> void combinar(T1 a, T2 b);
Podría darse el caso también de que alguno de los argumentos o el valor de

retorno fuese de un tipo de dato constante y conocido. En ese caso se indicaría
explícitamente como en una función convencional. La definición de la plantilla de
función es como sigue:
// Definición de la plantilla de función

template <class T> T minimo(T a, T b)
{
if(a <= b)
return a;
else
return b;
}
A continuación se presenta un programa principal que utiliza la plantilla de

función recién definida:
#include <iostream.h>
template <class T> T minimo(T a, T b);
void main(void)
{
int euno=1;
int edos=5;
cout << minimo(euno, edos) << endl;
long luno=1;
long ldos=5;
cout << minimo(luno, ldos) << endl;
char cuno='a';
char cdos='d';
cout << minimo(cuno, cdos) << endl;
double duno=1.8;

double ddos=1.9;
cout << minimo(duno, ddos) << endl;
}
La ejecución del programa anterior demuestra que el tipo de los argumentos

y el valor de retorno de la función minimo() se particularizan en cada caso a los de
la llamada. Es obvio también que se producirá un error si se pasan como
argumentos dos variables de distinto tipo, por lo que el usuario de la plantilla de
función debe ser muy cuidadoso en el paso de los argumentos. Seguidamente se
presenta un nuevo ejemplo de función para permutar el valor de dos variables:
template <class S> void permutar(S&, S&);
void main(void)
{
int i=2, j=3;
cout << "i=" << i << " " << "j=" << j << endl;
permutar(i, j);
cout << "i=" << i << " " << "j=" << j << endl;
double x=2.5, y=3.5;
cout << "x=" << x << " " << "y=" << y << endl;
permutar(x, y);
cout << "x=" << x << " " << "y=" << y << endl;
}
template <class S> void permutar(S& a, S& b)
{ S temp;
temp = a;
a = b;
b = temp;
}
Plantillas de clases
De una manera semejante a como se hace para las funciones se puede

generalizar para el caso de las clases por medio de plantillas de clases. Se definirá
un parámetro que indicará el tipo de datos con los que más adelante se crearán
los objetos. Se presenta a continuación un ejemplo completo de utilización de
plantillas de clases basado en una pila muy simple (sin listas vinculadas y sin
reserva dinámica de memoria):
// fichero Pila.h
template <class T>
// declaración de la clase
class Pila
{
public:
Pila(int nelem=10); // constructor

void Poner(T);
void Imprimir();
private:
int nelementos;
T* cadena;
int limite;
};
// definición del constructor
template <class T> Pila<T>::Pila(int nelem)
{
nelementos = nelem;
cadena = new T(nelementos);
limite = 0;
};
// definición de las funciones miembro
template <class T> void Pila<T>::Poner(T elem)
{
if (limite < nelementos)
cadena[limite++] = elem;
};
template <class T> void Pila<T>::Imprimir()
{
int i;
for (i=0; i<limite; i++)
cout << cadena[i] << endl;
};
El programa principal puede ser el que sigue:
#include "Pila.h"
void main()
{
Pila <int> p1(6);
p1.Poner(2);
p1.Poner(4);
p1.Imprimir();
Pila <char> p2(6);
p2.Poner('a');
p2.Poner('b');
p2.Imprimir();
}
En este programa principal se definen dos objetos p1 y p2 de la clase Pila.

En p1 el parámetro T vale int y en p2 ese parámetro vale char. El funcionamiento
de todas las variables y funciones miembro se particulariza en cada caso para
esos tipos de variable. Es necesario recordar de nuevo que el usuario de este tipo

de clases debe poner un muy especial cuidado en pasar siempre el tipo de

argumento correcto.
Puede pensarse que las plantillas y el polimorfismo son dos utilidades que
se excluyen mutuamente. Aunque es verdad que el parecido entre ambas es
grande, hay también algunas diferencias que pueden hacer necesarias ambas
características. El polimorfismo necesita punteros y su generalidad se limita a
jerarquías. Recuérdese que el polimorfismo se basa en que en el momento de
compilación se desconoce a qué clase de la jerarquía va a apuntar un puntero que
se ha definido como puntero a la clase base. Desde este punto de vista las
plantillas pueden considerarse como una ampliación del polimorfismo. Una
desventaja de las plantillas es que tienden a crear un código ejecutable grande
porque se crean tantas versiones de las funciones como son necesarias.
1.8 La biblioteca STL.
La Biblioteca Estándar de Patrones, comúnmente conocida en inglés por

sus siglas STL (Standard Template Library) es una biblioteca de C++ que incluye
la mayoría de algoritmos y estructuras de datos que se suelen utilizar en
Informática. Básicamente está compuesta de:
 clases contenedoras, es decir, patrones (templates) que permiten

almacenar objetos de muy diversos tipos,
 algoritmos de uso frecuente, e
 iteradores, que nos permitirán recorrer los elementos incluidos en los
contenedores.
También incluye "objetos función", que son generalizaciones de funciones

(clases útiles por el procesamiento que realizan y no por los datos que contienen),
y "adaptadores", que modifican el interfaz de ciertos contenedores e iteradores de
forma puedan ser manejados más fácilmente.
Esta biblioteca es genérica en tanto sus componentes están altamente

parametrizados, ya que casi todos son patrones, lo que permite su instancia con
cualquier otro tipo de objeto, lo que hace que la STL se configure como una gran
herramienta para la programación de aplicaciones en C++.
Los tipos de contenedores que nos podemos encontrar en la biblioteca son

los siguientes:
 Secuenciales:
o Vectores: contienen elementos contiguos almacenados al estilo de
un array o vector del lenguaje C++.
o Listas: secuencias de elementos almacenados en una lista enlazada.
o Deques: contenedores parecidos a los vectores, excepto que
permiten inserciones y borrados en tiempo constante tanto al
principio como al final.

 Adaptadores:
o Colas: contenedores que ofrecen la funcionalidad de listas " primero
en entrar, primero en salir".
o Pilas: contenedores asociados a listas " primero en entrar, último en
salir".
o Colas con prioridad: en este caso, los elementos de la cola salen de
ella de acuerdo con una prioridad (que se estableció en la inserción).
 Asociativos.
o Conjuntos de bits: contenedor para almacenar bits.
o Mapas: almacenan pares "clave, objeto", es decir, almacenan objetos
referidos mediante un identificador único.
o Multimapas: mapas que permiten claves duplicadas.
o Conjuntos: conjuntos ordenados de objetos únicos.
o Multiconjuntos: conjuntos ordenados de objetos que pueden estar
duplicados.
Todas estas clases de objetos tienen la posibilidad de poder ser "recorridas"

utilizan iteradores. Para ello, cada una de ellas tiene una subclase (o varias
subclases) que nos permiten colocarnos en el primer elemento de un objeto,
avanzar al siguiente elemento, ver el elemento (o modificarlo) y comprobar si ya
hemos llegado hasta el final.

2. Arreglos
2.1 Introducción.
Los arreglos (arrays) permiten agrupar datos usando un mismo

identificador. Todos los elementos de un array son del mismo tipo, y para acceder
a cada elemento se usan subíndices.
Sintaxis:
<tipo> <identificador>[<núm_elemen>][[<núm_elemen>]...];
Los valores para el número de elementos deben ser constantes, y se

pueden usar tantas dimensiones como queramos, limitado sólo por la memoria
disponible.
Cuando sólo se usa una dimensión se suele hablar de listas o vectores,

cuando se usan dos, de tablas.
Ahora podemos ver que las cadenas de caracteres son un tipo especial de
arrays. Se trata en realidad de arrays de una dimensión de objetos de tipo char.
Los subíndices son enteros, y pueden tomar valores desde 0 hasta <número
de elementos>-1. Esto es muy importante, y hay que tener mucho cuidado, por
ejemplo:
int Vector[10];
Creará un array con 10 enteros a los que accederemos como Vector[0] a Vector[9].
Como subíndice podremos usar cualquier expresión entera.
En general C++ no verifica el ámbito de los subíndices. Si declaramos un

array de 10 elementos, no obtendremos errores al acceder al elemento 11. Sin
embargo, si asignamos valores a elementos fuera del ámbito declarado,
estaremos accediendo a zonas de memoria que pueden pertenecer a otras
variables o incluso al código ejecutable de nuestro programa, con consecuencias
generalmente desastrosas.
Ejemplo:
int Tabla[10][10];
char DimensionN[4][15][6][8][11];
...
DimensionN[3][11][0][4][6] = DimensionN[0][12][5][3][1];
Tabla[0][0] += Tabla[9][9];

Cada elemento de Tabla, desde Tabla[0][0] hasta Tabla[9][9] es un entero.

Del mismo modo, cada elemento de DimensionN es un carácter.
Inicialización de arrays.
Los arrays pueden ser inicializados en la declaración.
Ejemplos:
float R[10] = {2, 32, 4.6, 2, 1, 0.5, 3, 8, 0, 12};

float S[] = {2, 32, 4.6, 2, 1, 0.5, 3, 8, 0, 12};
int N[] = {1, 2, 3, 6};
int M[][3] = { 213, 32, 32, 32, 43, 32, 3, 43, 21};
char Mensaje[] = "Error de lectura";
char Saludo[] = {'H', 'o', 'l', 'a', 0};
En estos casos no es obligatorio especificar el tamaño para la primera

dimensión, como ocurre en los ejemplos de las líneas 2, 3, 4, 5 y 6. En estos casos
la dimensión que queda indefinida se calcula a partir del número de elementos en
la lista de valores iniciales.
En el caso 2, el número de elementos es 10, ya que hay diez valores en la lista.
En el caso 3, será 4.
En el caso 4, será 3, ya que hay 9 valores, y la segunda dimensión es 3: 9/3=3.
Y en el caso 5, el número de elementos es 17, 16 caracteres más el cero de fin de

cadena.
Operadores con arrays
Ya hemos visto que se puede usar el operador de asignación con arrays para
asignar valores iniciales. El otro operador que tiene sentido con los arrays es
sizeof.
Aplicado a un array, el operador sizeof devuelve el tamaño de todo el array en

bytes. Podemos obtener el número de elementos dividiendo ese valor entre el
tamaño de uno de los elementos.
#include <iostream>
using namespace std;
int main()
{
int array[231];

cout << "Número de elementos: "

<< sizeof(array)/sizeof(int) << endl;
cout << "Número de elementos: "
<< sizeof(array)/sizeof(array[0]) << endl;
cin.get();
return 0;
}
Las dos formas son válidas, pero la segunda es, tal vez, más general.
2.2 Arreglos dinámicos.
Si al iniciar un programa no se sabe el número de elementos del que va a

constar el array, o no se quiere poner un límite predetermiado, lo que hay que
hacer es definir el array dinámicamente. Para hacer esto, primero se define un
puntero, que señalará la dirección de memoria del primer elemento del array:
tipo_de_elemento *nombre_de_array;
y luego se utiliza la función malloc (contenida en stdlib.h) para reservar memoria:
nombre_de_array=(tipo_de_elemento *)malloc(tamaño);
donde tamaño es el número de elementos del array por el tamaño en bytes de

cada elemento. La función malloc devuelve un puntero void, que indica la posición
del primer elemento. Antes de asignarlo a nuestro puntero, hay que convertir el
puntero que devuelve el malloc al tipo de nuestro puntero (ya que no se pueden
igualar punteros de distintos tipos).
Para arrays bidimensionales, hay que hacerlo dimensión a dimensión; primero se

define un puntero de punteros:
int **mapa;
Luego se reserva memoria para los punteros:
mapa=(int **)malloc(sizeof(int *)*N1);
y, por último, para cada puntero se reserva memoria para los elementos:
for(i1=0;i1<N1;i1++)
mapa[i1]=(int *)malloc(sizeof(int)*N2);
Ya se puede utilizar el array normalmente. Para arrays de más de dos

dimensiones, se hace de forma similar.
2.3 La clase VECTOR.

Aunque cada uno de los contenedores que ofrece la STL tienen

características diferentes, en esta sección presentaremos el contenedor vector. El
contenedor vector permite almacenar cero o más objetos del mismo tipo, pudiendo
acceder a ellos individualmente mediante un índice, es decir, acceso aleatorio. En
este sentido, es una extensión del vector o array que ofrece C++, aunque en este
caso el número de elementos de un objeto vector puede variar dinámicamente. La
gestión de la memoria se hace de manera totalmente transparente al usuario. Se
define como una clase patrón, lo que implica que puede albergar objetos de
cualquier tipo. En cuanto a las operaciones más frecuentes, ofrece un tiempo
constante en inserción y borrados de elementos al final, y lineal al comienzo o en
la mitad del vector.
La declaración más común de un objeto de tipo vector se realiza de la

siguiente manera:
vector<tipo> objeto;
donde tipo puede ser cualquier tipo o clase de los que ofrece C++, así como
cualquier otra clase implementada por un usuario. Así, podríamos declarar los
siguientes vectores:
vector<double> vectorReales; // De números reales.

vector<string> vectorCadenas; // De cadenas de caracteres.
vector<MiClase> vectorObj; // Contendrá objetos de una clase construida por
un usuario.
Una declaración:
vector <int> vectorEnteros(10);
crea un vector de diez enteros. Si deseamos inicializarlo a algún valor en

concreto, entonces añadimos un argumento más al constructor:
vector <int> vectorEnteros(10,-1);
De manera general las funciones miembro y operadores manejados por

vector mas utilizadas son:
size_type size() const; Devuelve el número de elementos

size
almacenados en el vector. El tipo size_type es un entero sin signo.
bool empty() const; Devuelve true si el número de elementos es cero y
empty
false en caso contrario.
void push_back(const T& x); Añade un elemento x al final del vector. T
push_back es el tipo de dato de los elementos del vector.
vector<int> a; a.push_back(5);

iterator begin(); Devuelve un iterador que referencia el comienzo del

begin
vector.
iterator end(); Devuelve un iterador que referencia la posición
end
siguiente al final del vector.
void erase(iterator first, iterator last); Borra los elementos del vector
que estén situados entre los iteradores first y last. Por ejemplo, para
erase borrar todos los elementos de un vector, se puede utilizar:
vector<int> a; a.erase(a.begin(),a.end()); // Se borran todos los
elementos entre la primera y la última posición.
capacity size_type capacity() const; Devuelve el número de elementos con que
se ha creado el vector. Siempre es mayor o igual que size.
void clear (); Borra todos los elementos de un vector.
clear
vector<int> a; a.clear(); // Se borran todos los elementos.
Algunos de los operadores de esta clase son:
El operador de asignación sustituye el contenido de un vector por el de otro.

vector<int> a;
vector<int> b;
a.push_back(5);
=
a.push_back(10);
b.push_back(3);
b = a; // El vector b contiene dos elementos: 5 y 10 (los mismos que contenía el
vector b).
Comprueba si dos vectores contienen los mismos elementos. Para ello lleva a
==
cabo una comparación elemento a elemento.
El operador de subíndice devuelve una referencia a un elemento del vector.
Una referencia con un subíndice igual a cero devuelve el primer elemento del
vector. Así, el rango del subíndice debe estar entre cero y size()-1.
vector<double> vec;
[]
vec.push_back(1.2);
vec.push_back(4.5);
vec[1] = vec[0] + 5.0; vec[0] = 2.7; // El vector contiene ahora los elementos
2.7, 6.2
Veamos algunos ejemplos. El siguiente programa muestra dos constructores

simples:

#include <iostream>
#include <cassert>
#include <vector>
int main()
{
cout << "Demostrando los constructores más simple del vector" << endl;
vector<char> vector1, vector2(3, 'x');
assert (vector1.size() == 0);
assert (vector2.size() == 3);
assert (vector2[0] == 'x' && vector2[1] == 'x' &&
vector2[2] == 'x');
assert (vector2 == vector<char>(3, 'x') &&
vector2 != vector<char>(4, 'x'));
cout << " --- Ok." << endl;
return 0;
}
Otro constructor, el de copia, crea un vector a partir de un "trozo" de un array u
otro vector, o de un vector completo. Veamos el siguiente ejemplo:
#include <iostream>
#include <cassert>
#include <vector>
int main()
{
cout << "Demostrando el constructor de copia del vector." << endl;
int numeros[] = {0,1, 2, 3, 4, 5, 6, 7, 8, 9};

vector<int> otroVector(&(numeros[0]),&(numeros[6]));
vector<int> tercerVector(otroVector.begin(), otroVector.end());

assert (tercerVector == otroVector);
vector<int> hijito1(otroVector);
assert (hijito1 == otroVector);
vector<int> hijito2 = otroVector;

assert (hijito2 == tercerVector);
return 0;
}
Este otro programa muestra el uso de algunas de las funciones miembro

anteriormente descritas:

#include <vector>
#include <iostream>
int main()
{
vector<int> v(5);
int x;
int cont = 0;
cout << "tam v:" <<

v.size() << " y tam.max.: " << v.capacity()
<< endl;
do {
cin >> x;
if (x!=-1) { // Lo añadimos
if (cont<v.size())
v[cont] = x;
else {
if (v.size()>=v.capacity()) //Hacemos v + grande
v.reserve(2*v.capacity());
v.push_back(x);
}
cont++;
cout << "Añadido: " << v[cont-1] << ", tam v:" <<
v.size() << " y tam.max.: " << v.capacity()
<< endl;
}
} while (x!=-1);
cout << "Vector: ";

for (vector<int>::const_iterator i= v.begin();
i!=v.end(); i++)
cout << *i << " ";
cout << endl;
return 0;
}
Por último, veamos algunos algoritmos que pueden ser útiles:
find -> Busca un elemento, pasado como tercer argumento, en los

elementos de un contenedor incluidos en el rango especificado por un iterador de
inicio y otro de fin (dos primeros argumentos).

#include <iostream>
#include <cassert>
#include <vector>
#include <algorithm> // Biblioteca para find
int main()
{
vector<char> vectorCar;
vectorCar.push_back('h');
vectorCar.push_back('o');
vectorCar.push_back('l');
vectorCar.push_back('a');
vectorCar.push_back(' ');
vectorCar.push_back('q');
vectorCar.push_back('u');
vectorCar.push_back('e');
vectorCar.push_back(' ');
vectorCar.push_back('t');
cout << "Demostración de la función find con un vector de caracteres. " << endl;
// Búsqueda del 5.:

vector<char>::iterator donde = find(vectorCar.begin(), vectorCar.end(), 'q');
assert (*donde == 'q' && *(donde + 1) == 'u');

cout << " --- Ok." << endl;
return 0;
}
reverse -> Invierte los elementos de un contenedor contenidos en un rango

determinado por dos iteradores, uno de inicio y otro de final.
#include <iostream>
#include <vector>
#include <cassert>
#include <algorithm> // reverse
int main()
{
vector<char> vectorCar;

vectorCar.push_back('h');
vectorCar.push_back('o');
vector<char> vectorCarAlReves;
vectorCarAlReves.push_back('a');
vectorCarAlReves.push_back('l');
vectorCarAlReves.push_back('o');
vectorCarAlReves.push_back('h');
cout << "Invirtiendo un vector. " << endl;
reverse(vectorCar.begin(), vectorCar.end());
assert (vectorCar == vectorCarAlReves);
cout << " --- Ok." << endl;
return 0;
}
sort -> ordena de manera creciente los elementos de un contenedor

incluidos en el rango establecido por un iterador inicial y otro final, pasados como
argumentos.
#include <iostream>
#include <algorithm>
#include <vector>
#include <cassert>
int main()
{
vector<int> v(1000);
for (int i = 0; i < 1000; ++i)
v[i] = 1000 - i - 1;
sort(v.begin(), v.end());
for (int i = 0; i < 1000; ++i)

assert (v[i] == i);
cout << " --- Ok." << endl;
return 0;
}
También tenemos la opción de ordenador en orden inverso de la siguiente

forma:

#include <iostream>
#include <vector>
#include <cassert>
bool descendente(int a, int b){ return a < b; }
int main()
{
vector<int> v(1000);
for (int i = 0; i < 1000; ++i)
v[i] = i;
sort(v.begin(), v.end(), descendente);
for (int i = 999; i >= 0; --i)

assert (v[i] == i);
cout << " --- Ok." << endl;
return 0;
}
copy -> Recibe tres argumentos: dos iteradores indicando principio y fin del
vector origen y un tercero que indica el inicio en el destino.
#include <iostream>
#include <cassert>
#include <vector>
#include <string>
#include <iostream>
int main()
{
cout << "Ejemplo de copia genérica." << endl;
string s("abcdefghihklmnopqrstuvwxyz");
vector<char> vector1(s.begin(), s.end());
vector<char> vector2(vector1.size()); //Con el mismo tamaño que vector1
// Copy vector1 to vector2:

copy(vector1.begin(), vector1.end(), vector2.begin());
assert (vector1 == vector2);

cout << " --- Ok." << endl;

return 0;
}
3 Listas
3.1 Definición de lista
Una lista es un conjunto de elementos del mismo tipo. Una propiedad

importante con la que se caracteriza a las listas es que su longitud puede
aumentar o disminuir, según se requiera. Es más, podemos insertar o eliminar
elementos en cualquier posición de una lista.
Las listas se pueden implementar de 2 modos distintos: mediante vectores o

mediante estructuras dinámicas enlazadas por apuntadores. El trabajo de listas
con vectores tiene una limitante: las listas tienen una longitud variable (dinámicas)
y los vectores tienen longitud estática. No podríamos definir un arreglo de tamaño
N donde solamente utilicemos los primero N-m cajones. O viceversa, declarar un
arreglo demasiado pequeño para nuestras necesidades. Esto es el porque de las
estructuras dinámicas de datos.
La forma más simple de estructura dinámica es la lista. En esta forma los

nodos se organizan de modo que cada uno apunta al siguiente, y el último no
apunta a nada, es decir, el puntero del nodo siguiente vale NULL.
En las listas abiertas existe un nodo especial: el primero. Normalmente

diremos que nuestra lista es un puntero a ese primer nodo y llamaremos a ese
nodo la cabeza de la lista. Eso es porque mediante ese único puntero podemos
acceder a toda la lista.
Cuando el puntero que usamos para acceder a la lista vale NULL, diremos
que la lista está vacía. El nodo típico para construir listas tiene esta forma:
struct nodo {
int dato;
struct nodo *siguiente;
};
En el ejemplo, cada elemento de la lista sólo contiene un dato de tipo

entero, pero en la práctica no hay límite en cuanto a la complejidad de los datos a
almacenar.
Normalmente se definen varios tipos que facilitan el manejo de las listas, la

declaración de tipos puede tener una forma parecida a esta:

typedef struct _nodo {

int dato;
struct _nodo *siguiente;
} tipoNodo;
typedef tipoNodo *pNodo;

typedef tipoNodo *Lista;
Donde:
tipoNodo es el tipo para declarar nodos.

pNodo es el tipo para declarar punteros a un nodo.
Lista es el tipo para declarar listas.
Como puede verse, un puntero a un nodo y una lista son la misma cosa. En
realidad, cualquier puntero a un nodo es una lista, cuyo primer elemento es el
nodo apuntado, por ejemplo:
Es muy importante que un programa nunca pierda el valor del puntero al

primer elemento, ya que si no existe ninguna copia de ese valor, y se pierde, será
imposible acceder al nodo y no podremos liberar el espacio de memoria que
ocupa.
3.2 Operaciones básicas con listas.
Con las listas tendremos un pequeño repertorio de operaciones básicas que

se pueden realizar:
 Añadir o insertar elementos.

 Buscar o localizar elementos.
 Borrar elementos.
 Moverse a través de una lista, anterior, siguiente, primero.
Cada una de estas operaciones tendrá varios casos especiales, por

ejemplo, no será lo mismo insertar un nodo en una lista vacía, o al principio de una
lista no vacía, o la final, o en una posición intermedia.
3.2.1 Insertar elementos en una lista.
Insertar un elemento en una lista vacía:
Este es, evidentemente, el caso más sencillo. Partimos de que ya tenemos

el nodo a insertar y, por supuesto un puntero que apunte a él, además el puntero a
la lista valdrá NULL:

El proceso es muy simple, bastará con que:
1. nodo->siguiente apunte a NULL.

2. Lista apunte a nodo.
Insertar un elemento en la primera posición de una lista:
Podemos considerar el caso anterior como un caso particular de éste, la

única diferencia es que en el caso anterior la lista es una lista vacía, pero siempre
podemos, y debemos considerar una lista vacía como una lista.
De nuevo partimos de un nodo a insertar, con un puntero que apunte a él, y

de una lista, en este caso no vacía:
El proceso sigue siendo muy sencillo:
1. Hacemos que nodo->siguiente apunte a Lista.

2. Hacemos que Lista apunte a nodo.
Insertar un elemento en la última posición de una lista:
Este es otro caso especial. Para este caso partimos de una lista no vacía:
El proceso en este caso tampoco es excesivamente complicado:

1. Necesitamos un puntero que señale al último elemento de la lista. La

manera de conseguirlo es empezar por el primero y avanzar hasta que
el nodo que tenga como siguiente el valor NULL.
2. Hacer que nodo->siguiente sea NULL.
3. Hacer que ultimo->siguiente sea nodo.
Insertar un elemento a continuación de un nodo cualquiera de una lista:
De nuevo podemos considerar el caso anterior como un caso particular de

este. Ahora el nodo "anterior" será aquel a continuación del cual insertaremos el
nuevo nodo:
Suponemos que ya disponemos del nuevo nodo a insertar, apuntado por

nodo, y un puntero al nodo a continuación del que lo insertaremos.
El proceso a seguir será:
1. Hacer que nodo->siguiente señale a anterior->siguiente.

2. Hacer que anterior->siguiente señale a nodo.
3.2.2 Localizar elementos en una lista.
Muy a menudo necesitamos recorrer una lista, ya sea buscando un valor

particular o un nodo concreto. Las listas abiertas sólo pueden recorrerse en un
sentido, ya que cada nodo apunta al siguiente, pero no se puede obtener, por
ejemplo, un puntero al nodo anterior desde un nodo cualquiera si no se empieza
desde el principio.
Para recorrer una lista procederemos siempre del mismo modo, usaremos
un puntero auxiliar como índice:

1. Asignamos al puntero índice el valor de Lista.

2. Abriremos un bucle que al menos debe tener una condición, que el
índice no sea NULL.
3. Dentro del bucle asignaremos al índice el valor del nodo siguiente al
índice actual.
Por ejemplo, para mostrar todos los valores de los nodos de una lista,
podemos usar el siguiente bucle:

int dato;
} tipoNodo;

typedef tipoNodo *Lista;
...
pNodo indice;
...
indice = Lista;
while(indice) {
printf("%d\n", indice->dato);
indice = indice->siguiente;
}
...
Supongamos que sólo queremos mostrar los valores hasta que

encontremos uno que sea mayor que 100, podemos sustituir el bucle por:
...
indice = Lista;
while(indice && indice->dato <= 100) {
printf("%d\n", indice->dato);
indice = indice->siguiente;
}
...
Si analizamos la condición del bucle, tal vez encontremos un posible error:

¿Qué pasaría si ningún valor es mayor que 100, y alcancemos el final de la lista?.
Podría pensarse que cuando indice sea NULL, si intentamos acceder a indice-
>dato se producirá un error.
En general eso será cierto, no puede accederse a punteros nulos. Pero en

este caso, este acceso está dentro de una condición y forma parte de una
expresión "and". Recordemos que cuando se evalúa una expresión "and", se
comienza por la izquierda, y la evaluación se abandona cuando una de las

expresiones resulta falsa, de modo que la expresión "indice->dato <= 100" nunca
se evaluará si indice es NULL.
Si hubiéramos escrito la condición al revés, el programa nunca funcionaría

bien. Esto es algo muy importante cuando se trabaja con punteros.
3.2.3 Eliminar elementos en una lista.
Nuevamente podemos encontrarnos con varios casos, según la posición del

nodo a eliminar.
Eliminar el primer nodo de una lista abierta:
Es el caso más simple. Partimos de una lista con uno o más nodos, y
usaremos un puntero auxiliar, nodo:
1. Hacemos que nodo apunte al primer elemento de la lista, es decir a

Lista.
2. Asignamos a Lista la dirección del segundo nodo de la lista: Lista-
>siguiente.
3. Liberamos la memoria asignada al primer nodo, el que queremos
eliminar.
Si no guardamos el puntero al primer nodo antes de actualizar Lista,

después nos resultaría imposible liberar la memoria que ocupa. Si liberamos la
memoria antes de actualizar Lista, perderemos el puntero al segundo nodo.
Si la lista sólo tiene un nodo, el proceso es también válido, ya que el valor

de Lista->siguiente es NULL, y después de eliminar el primer nodo la lista quedará
vacía, y el valor de Lista será NULL.
De hecho, el proceso que se suele usar para borrar listas completas es

eliminar el primer nodo hasta que la lista esté vacía.
Eliminar un nodo cualquiera de una lista abierta:

En todos los demás casos, eliminar un nodo se puede hacer siempre del
mismo modo. Supongamos que tenemos una lista con al menos dos elementos, y
un puntero al nodo anterior al que queremos eliminar. Y un puntero auxiliar nodo.
El proceso es parecido al del caso anterior:
1. Hacemos que nodo apunte al nodo que queremos borrar.

2. Ahora, asignamos como nodo siguiente del nodo anterior, el siguiente al
que queremos eliminar: anterior->siguiente = nodo->siguiente.
3. Eliminamos la memoria asociada al nodo que queremos eliminar.
Si el nodo a eliminar es el último, es procedimiento es igualmente válido, ya

que anterior pasará a ser el último, y anterior->siguiente valdrá NULL.
3.2.4 Moverse a través de una lista.
Sólo hay un modo de moverse a través de una lista abierta, hacia delante.
Aún así, a veces necesitaremos acceder a determinados elementos de una lista
abierta. Veremos ahora como acceder a los más corrientes: el primero, el último, el
siguiente y el anterior.
Primer elemento de una lista:
El primer elemento es el más accesible, ya que es a ese a que apunta el

puntero que define la lista. Para obtener un puntero al primer elemento bastará con
copiar el puntero Lista.
Elemento siguiente a uno cualquiera:
Supongamos que tenemos un puntero nodo que señala a un elemento de

una lista. Para obtener un puntero al siguiente bastará con asignarle el campo
"siguiente" del nodo, nodo->siguiente.

Elemento anterior a uno cualquiera:
Ya hemos dicho que no es posible retroceder en una lista, de modo que

para obtener un puntero al nodo anterior a uno dado tendremos que partir del
primero, e ir avanzando hasta que el nodo siguiente sea precisamente nuestro
nodo.
Último elemento de una lista:
Para obtener un puntero al último elemento de una lista partiremos de un

nodo cualquiera, por ejemplo el primero, y avanzaremos hasta que su nodo
siguiente sea NULL.
Saber si una lista está vacía:
Basta con comparar el puntero Lista con NULL, si Lista vale NULL la lista está
vacía.
3.2.5 Borrar una lista completa.
El algoritmo genérico para borrar una lista completa consiste simplemente

en borrar el primer elemento sucesivamente mientras la lista no esté vacía.
3.2.6 Ejemplo de lista ordenada.
Supongamos que queremos construir una lista para almacenar números

enteros, pero de modo que siempre esté ordenada de menor a mayor. Para hacer
la prueba añadiremos los valores 20, 10, 40, 30. De este modo tendremos todos
los casos posibles. Al comenzar, el primer elemento se introducirá en una lista
vacía, el segundo se insertará en la primera posición, el tercero en la última, y el
último en una posición intermedia.
Insertar un elemento en una lista vacía es equivalente a insertarlo en la

primera posición. De modo que no incluiremos una función para asignar un
elemento en una lista vacía, y haremos que la función para insertar en la primera
posición nos sirva para ese caso también.
Algoritmo de inserción:
1. El primer paso es crear un nodo para el dato que vamos a insertar.

2. Si Lista es NULL, o el valor del primer elemento de la lista es mayor que
el del nuevo, insertaremos el nuevo nodo en la primera posición de la
lista.
3. En caso contrario, buscaremos el lugar adecuado para la inserción,
tenemos un puntero "anterior". Lo inicializamos con el valor de Lista, y
avanzaremos mientras anterior->siguiente no sea NULL y el dato que

contiene anterior->siguiente sea menor o igual que el dato que

queremos insertar.
4. Ahora ya tenemos anterior señalando al nodo adecuado, así que
insertamos el nuevo nodo a continuación de él.
Algoritmo para borrar un elemento:
Después probaremos la función para buscar y borrar, borraremos los

elementos 10, 15, 45, 30 y 40, así probaremos los casos de borrar el primero, el
último y un caso intermedio o dos nodos que no existan.
Recordemos que para eliminar un nodo necesitamos disponer de un

puntero al nodo anterior.
1. Lo primero será localizar el nodo a eliminar, si es que existe. Pero sin

perder el puntero al nodo anterior. Partiremos del nodo primero, y del
valor NULL para anterior. Y avanzaremos mientras nodo no sea NULL o
mientras que el valor almacenado en nodo sea menor que el que
buscamos.
2. Ahora pueden darse tres casos:
3. Que el nodo sea NULL, esto indica que todos los valores almacenados
en la lista son menores que el que buscamos y el nodo que buscamos
no existe. Retornaremos sin borrar nada.
4. Que el valor almacenado en nodo sea mayor que el que buscamos, en
ese caso también retornaremos sin borrar nada, ya que esto indica que
el nodo que buscamos no existe.
5. Que el valor almacenado en el nodo sea igual al que buscamos.
6. De nuevo existen dos casos:
7. Que anterior sea NULL. Esto indicaría que el nodo que queremos borrar
es el primero, así que modificamos el valor de Lista para que apunte al
nodo siguiente al que queremos borrar.
8. Que anterior no sea NULL, el nodo no es el primero, así que asignamos
a anterior->siguiente la dirección de nodo->siguiente.
9. Después de 7 u 8, liberamos la memoria de nodo.
void Borrar(Lista *lista, int v) {

pNodo anterior, nodo;
nodo = *lista;
anterior = NULL;
while(nodo && nodo->valor < v) {
anterior = nodo;
nodo = nodo->siguiente;
}
if(!nodo || nodo->valor != v) return;
else { /* Borrar el nodo */
if(!anterior) /* Primer elemento */

*lista = nodo->siguiente;
else /* un elemento cualquiera */
anterior->siguiente = nodo->siguiente;
free(nodo);
}
}
3.2.7 Ejemplo de lista en C++ usando clases.
Usando clases el programa cambia bastante, aunque los algoritmos son los
mismos.
Para empezar, necesitamos dos clases, una para nodo y otra para lista. Además la
clase para nodo debe ser amiga de la clase lista, ya que ésta debe acceder a los
miembros privados de nodo.
class nodo {
public:
nodo(int v, nodo *sig = NULL) {
valor = v;
siguiente = sig;
}
private:
int valor;
nodo *siguiente;
friend class lista;

};
typedef nodo *pnodo;
class lista {
public:
lista() { primero = actual = NULL; }
~lista();
void Insertar(int v);

void Borrar(int v);
bool ListaVacia() { return primero == NULL; }
void Mostrar();
void Siguiente();
void Primero();
void Ultimo();
bool Actual() { return actual != NULL; }
int ValorActual() { return actual->valor; }

private:
pnodo primero;
pnodo actual;
};
Hemos hecho que la clase para lista sea algo más completa que la equivalente en
C, aprovechando las prestaciones de las clases. En concreto, hemos añadido
funciones para mantener un puntero a un elemento de la lista y para poder
moverse a través de ella.
3.3 La clase LIST de STL
El contenedor de decencia LIST cuenta con una eficiente combinación para las
operaciones de inserción y eliminación en cualquier posición del contenedor. La
clase LIST se implementa como una lista doblemente enlazada: cada nodo en una
lista contiene un apuntador al nodo anterior y al nodo siguiente de esta lista. Esto
permite a la clase LIST soportar iteradotes bidireccionales que permiten que el
contenedor se recorra tanto hacia delante como hacia atrás.
Además de las funciones miembro de todos los contenedores de la STL y de

las funciones miembro comunes de todos los contenedores de secuencia, la clase
LIST cuenta con otras ocho funciones miembro:
splice: elimina elementos de una estructura y los almacena en otra, utiliza

distintos formatos.
remove: elimina el elemento especificado de la lista.
unique: elimina elementos duplicados de una lista.
merge: elimina elementos de una estructura y los almacena en otra, de
manera ordenada.
reverse: invierte los elementos de una lista.
sort: ordena los elementos de la lista.
push_front: inserta un elemento en la parte frontal de la lista.
pop_front: elimina un elemento de la parte frontal de la lista.
4 Pilas
4.1 Definición de pilas
Una pila es un tipo especial de lista abierta en la que sólo se pueden

insertar y eliminar nodos en uno de los extremos de la lista. Estas operaciones se

conocen como "push" y "pop", respectivamente "empujar" y "tirar". Además, las

escrituras de datos siempre son inserciones de nodos, y las lecturas siempre
eliminan el nodo leído.
Estas características implican un comportamiento de lista LIFO (Last In First

Out), el último en entrar es el primero en salir. La más sencilla de las estructuras
dinámicas de datos es la pila, las pilas son utilizadas sobre todo por los sistemas
operativos y los controladores de los lenguajes de alto nivel. Una pila es dinámica:
crece y encoge a medida que es necesario.
Una manera de ver esta estructura es pensar en las pilas como si fuese una
pila de bandejas de un autoservicio. Las bandejas se ponen en la pila por arriba, la
bandeja de arriba se la lleva de la pila un cliente que este en la cola. Este
escenario se denomina modelo del último en llegar-primero en salir: la última
bandeja que se ponga en la pila será la primera que se lleven.
El nodo típico para construir pilas es el siguiente:
struct nodo {
int dato;
};
Los tipos que se definen normalmente para manejar pilas son casi los
mismos que para manejar listas, tan sólo se cambian algunos nombres de la
siguiente manera:

int dato;
} tipoNodo;

typedef tipoNodo *Pila;
Donde:
tipoNodo es el tipo para declarar nodos, evidentemente.

Pila es el tipo para declarar pilas.
Así una manera grafica de ver la estructura sería:

Es evidente, a la vista del gráfico, que una pila es una lista abierta. Así que
sigue siendo muy importante que un programa nunca pierda el valor del puntero al
primer elemento, igual que pasa con las listas abiertas.
Es necesario tener en cuenta que las inserciones y eliminaciones en una

pila se hacen siempre en un extremo, es decir, lo que consideramos como el
primer elemento de la lista es en realidad el último elemento de la pila.
4.2 Operaciones básicas con pilas.
Las pilas tienen un conjunto de operaciones muy limitado, sólo permiten las
operaciones de "push" y "pop":
 Push: Añadir un elemento al final de la pila.

 Pop: Leer y eliminar un elemento del final de la pila.
4.2.1. Push, insertar elemento:
Las operaciones con pilas son muy simples, no hay casos especiales, salvo
que la pila esté vacía.
Push en una pila vacía:
Partiremos de que ya tenemos el nodo a insertar y, por supuesto un puntero

que apunte a él, además el puntero a la pila valdrá NULL:

2. Pila apunte a nodo.
Push en una pila no vacía:
Podemos considerar el caso anterior como un caso particular de éste, la

única diferencia es que podemos y debemos trabajar con una pila vacía como con
una pila normal. De nuevo partiremos de un nodo a insertar, con un puntero que
apunte a él, y de una pila, en este caso no vacía:

1. Hacemos que nodo->siguiente apunte a Pila.

2. Hacemos que Pila apunte a nodo.
4.2.2. Pop, leer y eliminar un elemento.
Ahora sólo existe un caso posible, ya que sólo podemos leer desde un
extremo de la pila. Partiremos de una pila con uno o más nodos, y usaremos un
puntero auxiliar, nodo:
1. Hacemos que nodo apunte al primer elemento de la pila, es decir a Pila.

2. Asignamos a Pila la dirección del segundo nodo de la pila: Pila-
>siguiente.
3. Guardamos el contenido del nodo para devolverlo como retorno,
recuerda que la operación pop equivale a leer y borrar.
eliminar.
Si la pila sólo tiene un nodo, el proceso sigue siendo válido, ya que el valor
de Pila->siguiente es NULL, y después de eliminar el último nodo la pila quedará
vacía, y el valor de Pila será NULL.
4.3 Implementación de pilas.
Supongamos que queremos construir una pila para almacenar números

enteros.
Algoritmo de la función "push":
1. Creamos un nodo para el valor que colocaremos en la pila.

2. Hacemos que nodo->siguiente apunte a Pila.

3. Hacemos que Pila apunte a nodo.
void Push(Pila *pila, int v) {

pNodo nuevo;
/* Crear un nodo nuevo */

nuevo = (pNodo)malloc(sizeof(tipoNodo));
nuevo->valor = v;
/* Añadimos la pila a continuación del nuevo nodo */

nuevo->siguiente = *pila;
/* Ahora, el comienzo de nuestra pila es en nuevo nodo */
*pila = nuevo;
}
Algoritmo de la función "pop":
1. Hacemos que nodo apunte al primer elemento de la pila, es decir, a Pila.

2. Asignamos a Pila la dirección del segundo nodo de la pila: Pila-
>siguiente.
3. Guardamos el contenido del nodo para devolverlo como retorno.
eliminar.
int Pop(Pila *pila) {

pNodo nodo; /* variable auxiliar para manipular nodo */
int v; /* variable auxiliar para retorno */
/* Nodo apunta al primer elemento de la pila */

nodo = *pila;
if(!nodo) return 0; /* Si no hay nodos en la pila retornamos 0 */
/* Asignamos a pila toda la pila menos el primer elemento */
*pila = nodo->siguiente;
/* Guardamos el valor de retorno */
v = nodo->valor;
/* Borrar el nodo */
free(nodo);
return v;
}
4.3.1 Ejemplo de pila en C++ usando clases.
Las clases para pilas son versiones simplificadas de las mismas clases que
usamos para listas. Para empezar, necesitaremos dos clases, una para nodo y
otra para pila. Además la clase para nodo debe ser amiga de la clase pila, ya que
ésta debe acceder a los miembros privados de nodo.

class nodo {
public:
valor = v;
siguiente = sig;
}
private:
int valor;
nodo *siguiente;
friend class pila;

};
class pila {
public:
pila() : ultimo(NULL) {}
~pila();
void Push(int v);

int Pop();
private:
pnodo ultimo;
};
4.4 La clase STACK de STL
La clase STACK permite insertar a, y eliminar de, la estructura de datos

subyacente en un extremo. Una pila puede implementarse con cualquiera de los
contenedores de secuencia; vector, list y deque.
De manera predeterminada, una pila se implementa con un deque. Las

operaciones de la pila son: push para insertar un elemento en la parte superior,
pop para eliminar el elemento de la pila, top para obtener una referencia al
elemento de la pila, empty para determinar si la pila se encuentra vacía o no y size
para obtener el número de elementos de la pila.
Para poder hacer uso de la clase STACK es necesario incluir el archivo de

encabezado <stack>, por ejemplo, el siguiente codigo crea tres pilas de enteros
utilizando cada uno de los contenedores de secuencia de la STL como estructura
de datos subyacente para representar al adaptador STACK.

// Programa de prueba para el adaptador stack de la Biblioteca estándar.

#include <iostream>
using std::cout;
using std::endl;
#include <stack> // definición del adaptador stack

#include <vector> // definición de la plantilla de clase vector
#include <list> // definición de la plantilla de clase list
// prototipo de la plantilla de función sacarElementos

template< class T >
void sacarElementos( T &stackRef );
int main()
{
// pila con deque subyacente predeterminado
std::stack< int > intDequePila;
// pila con vector subyacente

std::stack< int, std::vector< int > > intVectorPila;
// pila con lista subyacente

std::stack< int, std::list< int > > intListaPila;
// meter los valores 0-9 en cada pila

for ( int i = 0; i < 10; ++i ) {
intDequePila.push( i );
intVectorPila.push( i );
intListaPila.push( i );
} // fin de instrucción for
// mostrar y eliminar elementos de cada pila

cout << "Sacando de intDequePila: ";
sacarElementos( intDequePila );
cout << "\nSacando de intVectorPila: ";
sacarElementos( intVectorPila );
cout << "\nSacando de intListaPila: ";
sacarElementos( intListaPila );
cout << endl;
return 0;
} // fin de main

// sacar elementos del objeto pila al que hace referencia stackRef

template< class T >
void sacarElementos( T &stackRef )
{
while ( !stackRef.empty() ) {
cout << stackRef.top() << ' '; // ver elemento superior
stackRef.pop(); // eliminar elemento superior
} // fin de instrucción while
} // fin de la función sacarElementos
5 Colas
5.1 Definición de colas
Una cola es un tipo especial de lista abierta en la que sólo se puede insertar
nodos en uno de los extremos de la lista y sólo se pueden eliminar nodos en el
otro. Además, como sucede con las pilas, las escrituras de datos siempre son
inserciones de nodos, y las lecturas siempre eliminan el nodo leído.
Este tipo de lista es conocido como lista FIFO (First In First Out), el primero
en entrar es el primero en salir.
Un ejemplo cotidiano es una cola para comprar, por ejemplo, las entradas
del cine. Los nuevos compradores sólo pueden colocarse al final de la cola, y sólo
el primero de la cola puede comprar la entrada.
El nodo típico para construir colas es el mismo para la construcción de listas

y pilas:
struct nodo {
int dato;
};
Los tipos que se definen normalmente para manejar colas son casi los
mismos que para manejar listas y pilas, tan sólo se cambian algunos nombres:

int dato;
} tipoNodo;


typedef tipoNodo *Cola;
Donde:
tipoNodo es el tipo para declarar nodos.

Cola es el tipo para declarar colas.
De manera similar a las pilas, una cola se puede representar gráficamente

como:
Es evidente que una cola es una lista abierta. Así que sigue siendo muy
importante que un programa nunca pierda el valor del puntero al primer elemento,
igual que pasa con las listas abiertas. Además, debido al funcionamiento de las
colas, también se debe mantener un puntero para el último elemento de la cola,
que será el punto donde insertemos nuevos nodos.
Teniendo en cuenta que las lecturas y escrituras en una cola se hacen

siempre en extremos distintos, lo más fácil será insertar nodos por el final, a
continuación del nodo que no tiene nodo siguiente, y leerlos desde el principio, hay
que recordar que leer un nodo implica eliminarlo de la cola.
5.2 Operaciones básicas con colas.
De nuevo nos encontramos ante una estructura con muy pocas operaciones
disponibles. Las colas sólo permiten añadir y leer elementos:
 Añadir: Inserta un elemento al final de la cola.

 Leer: Lee y elimina un elemento del principio de la cola.
5.2.1 Añadir un elemento.
Las operaciones con colas son muy sencillas, prácticamente no hay casos
especiales, salvo que la cola esté vacía.
Añadir elemento en una cola vacía:
Partimos de que ya tenemos el nodo a insertar y, por supuesto un puntero

que apunte a él, además los punteros que definen la cola, primero y ultimo que
valdrán NULL:


2. Y que los punteros primero y ultimo apunten a nodo.
Añadir elemento en una cola no vacía:
Nuevamente partimos de un nodo a insertar, con un puntero que apunte a

él, y de una cola, en este caso, al no estar vacía, los punteros primero y ultimo no
serán nulos:
1. Hacemos que nodo->siguiente apunte a NULL.

2. Después que ultimo->siguiente apunte a nodo.
3. Y actualizamos ultimo, haciendo que apunte a nodo.
Añadir elemento en una cola, caso general:
Para generalizar el caso anterior, sólo necesitamos añadir una operación:

2. Si ultimo no es NULL, hacemos que ultimo->siguiente apunte a nodo.
3. Y actualizamos ultimo, haciendo que apunte a nodo.
4. Si primero es NULL, significa que la cola estaba vacía, así que haremos
que primero apunte también a nodo.

5.2.2 Leer un elemento.
Ahora, también existen dos casos, que la cola tenga un solo elemento o que
tenga más de uno.
Leer un elemento en una cola con más de un elemento:
Usamos un puntero a un nodo auxiliar:
1. Hacemos que nodo apunte al primer elemento de la cola, es decir a

primero.
2. Asignamos a primero la dirección del segundo nodo de la pila: primero-
>siguiente.
eliminar.
Leer un elemento en una cola con un solo elemento:
También necesitamos un puntero a un nodo auxiliar:
1. Hacemos que nodo apunte al primer elemento de la pila, es decir a

primero.
2. Asignamos NULL a primero, que es la dirección del segundo nodo
teórico de la cola: primero->siguiente.
eliminar.
5. Hacemos que ultimo apunte a NULL, ya que la lectura ha dejado la cola
vacía.

Leer un elemento en una cola caso general:
1. Hacemos que nodo apunte al primer elemento de la pila, es decir a

primero.
2. Asignamos a primero la dirección del segundo nodo de la pila: primero-
>siguiente.
eliminar.
5. Si primero es NULL, hacemos que ultimo también apunte a NULL, ya
que la lectura ha dejado la cola vacía.
5.3 Implementación de colas.
Supóngase que construimos una cola para almacenar números enteros.
Algoritmo de la función "Añadir":
1. Creamos un nodo para el valor que colocaremos en la cola.

3. Si "ultimo" no es NULL, hacemos que ultimo->siguiente apunte a nodo.
4. Actualizamos "ultimo" haciendo que apunte a nodo.
5. Si "primero" es NULL, hacemos que apunte a nodo.
void Anadir(pNodo *primero, pNodo *ultimo, int v) {

pNodo nuevo;
/* Crear un nodo nuevo */

nuevo = (pNodo)malloc(sizeof(tipoNodo));
nuevo->valor = v;
/* Este será el último nodo, no debe tener siguiente */
nuevo->siguiente = NULL;
/* Si la cola no estaba vacía, añadimos el nuevo a continuación de ultimo */

if(*ultimo) (*ultimo)->siguiente = nuevo;

/* Ahora, el último elemento de la cola es el nuevo nodo */
*ultimo = nuevo;
/* Si primero es NULL, la cola estaba vacía, ahora primero apuntará también al
nuevo nodo */
if(!*primero) *primero = nuevo;
}
Algoritmo de la función "leer":
1. Hacemos que nodo apunte al primer elemento de la cola, es decir a

primero.
2. Asignamos a primero la dirección del segundo nodo de la cola: primero-
>siguiente.
eliminar.
5. Si primero es NULL, haremos que último también apunte a NULL, ya
que la cola habrá quedado vacía.
int Leer(pNodo *primero, pNodo *ultimo) {

pNodo nodo; /* variable auxiliar para manipular nodo */
int v; /* variable auxiliar para retorno */
/* Nodo apunta al primer elemento de la pila */

nodo = *primero;
if(!nodo) return 0; /* Si no hay nodos en la pila retornamos 0 */
/* Asignamos a primero la dirección del segundo nodo */
*primero = nodo->siguiente;
/* Guardamos el valor de retorno */
v = nodo->valor;
/* Borrar el nodo */
free(nodo);
/* Si la cola quedó vacía, ultimo debe ser NULL también*/
if(!*primero) *ultimo = NULL;
return v;
}
5.3.1 Ejemplo de cola en C++ usando clases.
Ya hemos visto que las colas son casos particulares de listas abiertas, pero
más simples. Como en los casos anteriores, veremos ahora un ejemplo de cola
usando clases.
Para empezar, y como siempre, necesitamos dos clases, una para nodo y
otra para cola. Además la clase para nodo debe ser amiga de la clase cola, ya que
ésta debe acceder a los miembros privados de nodo.

class nodo {
public:
valor = v;
siguiente = sig;
}
private:
int valor;
nodo *siguiente;
friend class cola;

};
class cola {
public:
cola() : ultimo(NULL), primero(NULL) {}
~cola();
void Anadir(int v);

int Leer();
private:
pnodo primero, ultimo;
};
5.4 La clase QUEUE de STL.
La clase QUEUE permite inserciones en la parte final de la estructura de datos

subyacentes y eliminaciones en la parte inicial de la misma. Una cola puede
implementarse con la estructura de datos list o deque de la STL, de manera
predeterminada una cola se implementa con deque.
Las operaciones comunes de un adaptador queue son push para insertar

un elemento en su parte final, pop para eliminar el elemento en la parte inicial de la
cola, front para obtener una referencia al primer elemento de la cola, back para
obtener una referencia al último elemento de la cola, empty para determinar si la
cola esta o no vacía y size para obtener el número de elementos de la cola.
El archivo de encabezado <queue> debe incluirse para poder utilizar esta

clase. Por ejemplo, el siguiente codigo muestra el uso de la clase queue.
// Programa de prueba para el adaptador queue de la Biblioteca estándar.

#include <iostream>

using std::cout;
using std::endl;
#include <queue> // definición del adaptador queue
int main()
{
std::queue< double > valores;
// meter elementos en la cola valores

valores.push( 3.2 );
cout << "Sacando de valores: ";
while ( !valores.empty() ) {
cout << valores.front() << ' '; // ver elemento inicial
valores.pop(); // eliminar elemento
} // fin de instrucción while
cout << endl;
return 0;
} // fin de main

6 Árboles
6.1 Definición de árboles
Un árbol es una estructura no lineal en la que cada nodo puede apuntar a uno o
varios nodos. También se suele dar una definición recursiva: un árbol es una
estructura en compuesta por un dato y varios árboles, la forma gráfica se puede
apreciar como sigue:
En relación con nodos se pueden definir conceptos como:
 Nodo hijo: cualquiera de los nodos apuntados por uno de los nodos del
árbol. En el ejemplo, 'L' y 'M' son hijos de 'G'.
 Nodo padre: nodo que contiene un puntero al nodo actual. En el
ejemplo, el nodo 'A' es padre de 'B', 'C' y 'D'.
En cuanto a la posición dentro del árbol, encontramos:
 Nodo raíz: nodo que no tiene padre. Este es el nodo que usaremos
para referirnos al árbol. En el ejemplo, ese nodo es el 'A'.
 Nodo hoja: nodo que no tiene hijos. En el ejemplo hay varios: 'F', 'H', 'I',
'K', 'L', 'M', 'N' y 'O'.
 Nodo rama: aunque esta definición apenas la usaremos, estos son los
nodos que no pertenecen a ninguna de las dos categorías anteriores.
En el ejemplo: 'B', 'C', 'D', 'E', 'G' y 'J'.
Un árbol en el que en cada nodo o bien todos o ninguno de los hijos existe,
se llama árbol completo. Los árboles se parecen al resto de las estructuras que
hemos visto: dado un nodo cualquiera de la estructura, podemos considerarlo
como una estructura independiente, es decir, un nodo cualquiera puede ser
considerado como la raíz de un árbol completo.

Existen otros conceptos que definen las características del árbol, en relación
a su tamaño:
 Orden: es el número potencial de hijos que puede tener cada elemento
de árbol. De este modo, diremos que un árbol en el que cada nodo
puede apuntar a otros dos es de orden dos, si puede apuntar a tres
será de orden tres, etc.
 Grado: el número de hijos que tiene el elemento con más hijos dentro
del árbol. En el árbol del ejemplo, el grado es tres, ya que tanto 'A'
como 'D' tienen tres hijos, y no existen elementos con más de tres
hijos.
 Nivel: se define para cada elemento del árbol como la distancia a la
raíz, medida en nodos. El nivel de la raíz es cero y el de sus hijos uno.
Así sucesivamente. En el ejemplo, el nodo 'D' tiene nivel 1, el nodo 'G'
tiene nivel 2, y el nodo 'N', nivel 3.
 Altura: la altura de un árbol se define como el nivel del nodo de mayor
nivel. Como cada nodo de un árbol puede considerarse a su vez como
la raíz de un árbol, también podemos hablar de altura de ramas. El
árbol del ejemplo tiene altura 3, la rama 'B' tiene altura 2, la rama 'G'
tiene altura 1, la 'H' cero, etc.
Los árboles de orden dos son bastante especiales, de hecho les

dedicaremos varios capítulos. Estos árboles se conocen también como árboles
binarios.
Frecuentemente, aunque no es estrictamente necesario, para hacer más

fácil el moverse a través del árbol, se añade un puntero a cada nodo que apunte al
nodo padre. De este modo podremos avanzar en dirección a la raíz, y no sólo
hacia las hojas.
Es importante conservar siempre el nodo raíz ya que es el nodo a partir del

cual se desarrolla el árbol, si perdemos este nodo, perderemos el acceso a todo el
árbol. El nodo típico de un árbol difiere de los nodos que hemos visto hasta ahora
para listas, aunque sólo en el número de nodos. Veamos un ejemplo de nodo para
crear árboles de orden tres:
struct nodo {
int dato;
struct nodo *rama1;
struct nodo *rama2;
struct nodo *rama3;
};
O generalizando más:
#define ORDEN 5
struct nodo {
int dato;
struct nodo *rama[ORDEN];

};
Para C y C++, y basándonos en la declaración de nodo que hemos visto

anteriormente, se pueden definir los siguientes tipos:

int dato;
struct _nodo *rama[ORDEN];
} tipoNodo;

typedef tipoNodo *Arbol;
Al igual que con las listas, declaramos un tipo tipoNodo para declarar
nodos, y un tipo pNodo para es el tipo para declarar punteros a un nodo. Arbol es
el tipo para declarar árboles de orden ORDEN.
El movimiento a través de árboles será siempre partiendo del nodo raíz

hacia un nodo hoja. Cada vez que lleguemos a un nuevo nodo podremos optar por
cualquiera de los nodos a los que apunta para avanzar al siguiente nodo.
Operaciones básicas con árboles
Salvo que trabajemos con árboles especiales, como los que veremos más
adelante, las inserciones serán siempre en punteros de nodos hoja o en punteros
libres de nodos rama. Con estas estructuras no es tan fácil generalizar, ya que
existen muchas variedades de árboles.
De nuevo tenemos casi el mismo repertorio de operaciones de las que

disponíamos con las listas:
 Añadir o insertar elementos.

 Buscar o localizar elementos.
 Borrar elementos.
 Moverse a través del árbol.
 Recorrer el árbol completo.

Los algoritmos de inserción y borrado dependen en gran medida del tipo de árbol
que estemos implementando, de modo que por ahora los pasaremos por alto y nos
centraremos más en el modo de recorrer árboles.
Recorridos por los árboles
El modo evidente de moverse a través de las ramas de un árbol es siguiendo los

punteros, del mismo modo en que nos movíamos a través de las listas.
Esos recorridos dependen en gran medida del tipo y propósito del árbol, pero hay
ciertos recorridos que usaremos frecuentemente. Se trata de aquellos recorridos
que incluyen todo el árbol.
Hay tres formas de recorrer un árbol completo, y las tres se suelen implementar
mediante recursividad. En los tres casos se sigue siempre a partir de cada nodo
todas las ramas una por una.
Supongamos que tenemos un árbol de orden tres, y queremos recorrerlo por

completo.
Partiremos del nodo raíz:
RecorrerArbol(raiz);
La función RecorrerArbol, aplicando recursividad, será tan sencilla como invocar

de nuevo a la función RecorrerArbol para cada una de las ramas:
void RecorrerArbol(Arbol a) {
if(a == NULL) return;
RecorrerArbol(a->rama[0]);
}
Lo que diferencia los distintos métodos de recorrer el árbol no es el sistema de

hacerlo, sino el momento que elegimos para procesar el valor de cada nodo con
relación a los recorridos de cada una de las ramas.

Los tres tipos son:
Pre-orden:
En este tipo de recorrido, el valor del nodo se procesa antes de recorrer las ramas:
void PreOrden(Arbol a) {
Procesar(dato);
}
Si seguimos el árbol del ejemplo en pre-orden, y el proceso de los datos es

sencillamente mostrarlos por pantalla, obtendremos algo así:
ABEKFCGLMDHIJNO
In-orden:
En este tipo de recorrido, el valor del nodo se procesa después de recorrer la

primera rama y antes de recorrer la última. Esto tiene más sentido en el caso de
árboles binarios, y también cuando existen ORDEN-1 datos, en cuyo caso
procesaremos cada dato entre el recorrido de cada dos ramas (este es el caso de
los árboles-b):
void InOrden(Arbol a) {
Procesar(dato);
}

Si seguimos el árbol del ejemplo en in-orden, y el proceso de los datos es

KEBFALGMCHDINJO
Post-orden:
En este tipo de recorrido, el valor del nodo se procesa después de recorrer todas
las ramas:
void PostOrden(Arbol a) {
Procesar(dato);
}
Si seguimos el árbol del ejemplo en post-orden, y el proceso de los datos es

KEFBLMGCHINOJDA
Eliminar nodos en un árbol
El proceso general es muy sencillo en este caso, pero con una importante
limitación, sólo podemos borrar nodos hoja:
El proceso sería el siguiente:
1. Buscar el nodo padre del que queremos eliminar.

2. Buscar el puntero del nodo padre que apunta al nodo que queremos borrar.
3. Liberar el nodo.
4. padre->nodo[i] = NULL;.
Cuando el nodo a borrar no sea un nodo hoja, diremos que hacemos una "poda", y
en ese caso eliminaremos el árbol cuya raíz es el nodo a borrar. Se trata de un
procedimiento recursivo, aplicamos el recorrido PostOrden, y el proceso será
borrar el nodo.
El procedimiento es similar al de borrado de un nodo:
1. Buscar el nodo padre del que queremos eliminar.

2. Buscar el puntero del nodo padre que apunta al nodo que queremos borrar.
3. Podar el árbol cuyo padre es nodo.
4. padre->nodo[i] = NULL;.

En el árbol del ejemplo, para podar la rama 'B', recorreremos el subárbol 'B' en
postorden, eliminando cada nodo cuando se procese, de este modo no perdemos
los punteros a las ramas apuntadas por cada nodo, ya que esas ramas se borrarán
antes de eliminar el nodo.
De modo que el orden en que se borrarán los nodos será:
KEFyB
Árboles ordenados
A partir del siguiente capítulo sólo hablaremos de árboles ordenados, ya que son
los que tienen más interés desde el punto de vista de TAD, y los que tienen más
aplicaciones genéricas.
Un árbol ordenado, en general, es aquel a partir del cual se puede obtener una
secuencia ordenada siguiendo uno de los recorridos posibles del árbol: inorden,
preorden o postorden.
En estos árboles es importante que la secuencia se mantenga ordenada aunque

se añadan o se eliminen nodos.
Existen varios tipos de árboles ordenados, que veremos a continuación:
 árboles binarios de búsqueda (ABB): son árboles de orden 2 que mantienen

una secuencia ordenada si se recorren en inorden.
 árboles AVL: son árboles binarios de búsqueda equilibrados, es decir, los
niveles de cada rama para cualquier nodo no difieren en más de 1.
 árboles perfectamente equilibrados: son árboles binarios de búsqueda en
los que el número de nodos de cada rama para cualquier nodo no difieren
en más de 1. Son por lo tanto árboles AVL también.
 árboles 2-3: son árboles de orden 3, que contienen dos claves en cada
nodo y que están también equilibrados. También generan secuencias
ordenadas al recorrerlos en inorden.
 árboles-B: caso general de árboles 2-3, que para un orden M, contienen M-
1 claves.
6.2 Árboles binarios.
Un árbol binario esta vacío o consta de un nodo denominado raíz junto con
dos árboles binarios llamados subárbol izquierdo y subárbol derecho de la raíz.
Además de que los árboles binarios se emplean para búsquedas, la

recuperación de información es una de las aplicaciones más importantes, y para
ello existen los árboles de búsqueda binaria.

La única manera de construir un árbol binario con un nodo consiste en

hacer que el nodo sea su raíz y que estén vacíos sus subárboles izquierdo y
derecho (representan un apuntador a NULL), esto significa que se trata de un árbol
ordinario.
Con dos nodos en el árbol, uno de ellos será la raíz y el otro estará en un
subárbol. Así, uno de los subárboles de la izquierda o derecha debe estar vacío y
el otro contendrá un nodo. De ahí que haya dos árboles binarios diferentes con dos
nodos.
En el caso de un árbol binario con tres nodos, uno de estos será la raíz y los
otros dos se dividirán entre los subárboles de la izquierda y derecha en una de las
siguientes formas: 2 + 0, 1 + 1 y 0 + 2.
Como hay dos árboles binarios con dos nodos y solo un árbol vacío, en el
primer caso da dos árboles binarios. El tercero también lo hace. En el segundo
caso, los subárboles izquierdo y derecho tienen un nodo, y solo hay un árbol
binario con un nodo y por eso hay uno en el segundo. Así pues, en total existen
cinco árboles binarios con tres nodos.
Un árbol binario tiene una representación natural en el almacenamiento de

listas ligadas.
6.3 Árboles de búsqueda binaria (ABB).
Se trata de árboles de orden 2 en los que se cumple que para cada nodo, el
valor del nodo raíz del subárbol izquierdo es menor que el valor del nodo raíz y que
el valor del nodo raíz del subárbol derecho es mayor que el valor del nodo raíz.

6.3.1 Operaciones en ABB.
El conjunto de operaciones que se pueden realizar sobre un ABB es similar

al que se realiza sobre otras estructuras de datos, más alguna otra propia de
árboles:
 Buscar un elemento.
 Insertar un elemento.
 Eliminar un elemento.
 Movimientos a través del árbol:
o Izquierda.
o Derecha.
o Raíz.
 Información:
o Comprobar si un árbol está vacío.
o Calcular el número de nodos.
o Comprobar si el nodo es hoja.
o Calcular la altura de un nodo.
o Calcular la altura de un árbol.
6.3.1.1 Buscar un elemento.
Partiendo siempre del nodo raíz, el modo de buscar un elemento se define

de forma recursiva como:
 Si el árbol está vacío, terminamos la búsqueda: el elemento no está en

el árbol.
 Si el valor del nodo raíz es igual que el del elemento que buscamos,
terminamos la búsqueda con éxito.
 Si el valor del nodo raíz es mayor que el elemento que buscamos,
continuaremos la búsqueda en el árbol izquierdo.
 Si el valor del nodo raíz es menor que el elemento que buscamos,
continuaremos la búsqueda en el árbol derecho.

El valor de retorno de una función de búsqueda en un ABB puede ser un

puntero al nodo encontrado, o NULL, si no se ha encontrado.
6.3.1.2 Insertar un elemento.
Para insertar un elemento nos basamos en el algoritmo de búsqueda. Si el

elemento está en el árbol no lo insertaremos. Si no lo está, lo insertaremos a
continuación del último nodo visitado. Para ello, se necesita un puntero auxiliar
para conservar una referencia al padre del nodo raíz actual. El valor inicial para
ese puntero es NULL.
 Padre = NULL
 nodo = Raiz
 Bucle: mientras actual no sea un árbol vacío o hasta que se encuentre el
elemento.
o Si el valor del nodo raíz es mayor que el elemento que buscamos,
continuaremos la búsqueda en el árbol izquierdo:
Padre=nodo, nodo=nodo->izquierdo.
o Si el valor del nodo raíz es menor que el elemento que buscamos,

continuaremos la búsqueda en el árbol derecho:
Padre=nodo, nodo=nodo->derecho.
 Si nodo no es NULL, el elemento está en el árbol, por lo tanto salimos.

 Si Padre es NULL, el árbol estaba vacío, por lo tanto, el nuevo árbol sólo
contendrá el nuevo elemento, que será la raíz del árbol.
 Si el elemento es menor que el Padre, entonces insertamos el nuevo
elemento como un nuevo árbol izquierdo de Padre.
 Si el elemento es mayor que el Padre, entonces insertamos el nuevo
elemento como un nuevo árbol derecho de Padre.
Este modo de actuar asegura que el árbol sigue siendo ABB.
6.3.1.3 Eliminar un elemento.
Para eliminar un elemento también nos basamos en el algoritmo de

búsqueda. Si el elemento no está en el árbol no lo podremos borrar. Si está, hay
dos casos posibles:
1. Se trata de un nodo hoja: en ese caso lo borraremos directamente.

2. Se trata de un nodo rama: en ese caso no podemos eliminarlo, puesto que
perderíamos todos los elementos del árbol de que el nodo actual es padre.
En su lugar buscamos el nodo más a la izquierda del subárbol derecho, o el
más a la derecha del subárbol izquierdo e intercambiamos sus valores. A
continuación eliminamos el nodo hoja.

Necesitamos un puntero auxiliar para conservar una referencia al padre del

nodo raíz actual. El valor inicial para ese puntero es NULL.
 Padre = NULL
 Si el árbol está vacío: el elemento no está en el árbol, por lo tanto salimos
sin eliminar ningún elemento.
 (*) Si el valor del nodo raíz es igual que el del elemento que buscamos,
estamos ante uno de los siguientes casos:
o El nodo raíz es un nodo hoja:
 Si 'Padre' es NULL, el nodo raíz es el único del árbol, por lo
tanto el puntero al árbol debe ser NULL.
 Si raíz es la rama derecha de 'Padre', hacemos que esa rama
apunte a NULL.
 Si raíz es la rama izquierda de 'Padre', hacemos que esa rama
apunte a NULL.
 Eliminamos el nodo, y salimos.
o El nodo no es un nodo hoja:
 Buscamos el 'nodo' más a la izquierda del árbol derecho de
raíz o el más a la derecha del árbol izquierdo. Hay que tener
en cuenta que puede que sólo exista uno de esos árboles. Al
mismo tiempo, actualizamos 'Padre' para que apunte al padre
de 'nodo'.
 Intercambiamos los elementos de los nodos raíz y 'nodo'.
 Borramos el nodo 'nodo'. Esto significa volver a (*), ya que
puede suceder que 'nodo' no sea un nodo hoja.
6.3.2 Ejemplos de eliminación en un ABB.
Ejemplo 1: Eliminar un nodo hoja
En el árbol de ejemplo, eliminar el nodo 3.
1. Localizamos el nodo a borrar, al tiempo que mantenemos un puntero a

'Padre'.
2. Hacemos que el puntero de 'Padre' que apuntaba a 'nodo', ahora apunte a
NULL.
3. Borramos el 'nodo'.

Ejemplo 2: Eliminar un nodo rama con intercambio de un nodo hoja.
En el árbol de ejemplo, eliminar el nodo 4.
1. Localizamos el nodo a eliminar (nodo raíz).

2. Buscamos el nodo más a la derecha del árbol izquierdo de 'raíz', en
este caso el 3, al tiempo que mantenemos un puntero a 'Padre' a 'nodo'.
3. Intercambiamos los elementos 3 y 4.
NULL.
Ejemplo 3: Eliminar un nodo rama con intercambio de un nodo rama.
Para este ejemplo usaremos otro árbol. En éste borraremos el elemento 6.

1. Localizamos el nodo a eliminar (nodo raíz).

2. Buscamos el nodo más a la izquierda del árbol derecho de 'raíz', en
este caso el 12, ya que el árbol derecho no tiene nodos a su izquierda, si
optamos por la rama izquierda, estaremos en un caso análogo. Al mismo
tiempo que mantenemos un puntero a 'Padre' a 'nodo'.
4. Ahora tenemos que repetir el bucle para el nodo 6 de nuevo, ya que
no podemos eliminarlo.
5. Localizamos de nuevo el nodo a eliminar (nodo raíz).

6. Buscamos el nodo más a la izquierda del árbol derecho de 'raíz', en
este caso el 16, al mismo tiempo que mantenemos un puntero a 'Padre' a
'nodo'.
NULL.

Este modo de actuar asegura que el árbol sigue siendo ABB.
Movimientos a través de un árbol
No hay mucho que contar. Nuestra estructura se referenciará siempre mediante un

puntero al nodo Raíz, este puntero no debe perderse nunca.
Para movernos a través del árbol usaremos punteros auxiliares, de modo que
desde cualquier puntero los movimientos posibles serán: moverse al nodo raíz de
la rama izquierda, moverse al nodo raíz de la rama derecha o moverse al nodo
Raíz del árbol.
Información
Hay varios parámetros que podemos calcular o medir dentro de un árbol. Algunos
de ellos nos darán idea de lo eficientemente que está organizado o el modo en que
funciona.
Comprobar si un árbol está vacío.
Un árbol está vacío si su raíz es NULL.
Calcular el número de nodos.
Tenemos dos opciones para hacer esto, una es llevar siempre la cuenta de nodos
en el árbol al mismo tiempo que se añaden o eliminan elementos. La otra es,
sencillamente, contarlos.
Para contar los nodos podemos recurrir a cualquiera de los tres modos de recorrer
el árbol: inorden, preorden o postorden, como acción sencillamente
incrementamos el contador.
Comprobar si el nodo es hoja.

Esto es muy sencillo, basta con comprobar si tanto el árbol izquierdo como el
derecho están vacíos. Si ambos lo están, se trata de un nodo hoja.
Calcular la altura de un nodo.
No hay un modo directo de hacer esto, ya que no nos es posible recorrer el árbol
en la dirección de la raíz. De modo que tendremos que recurrir a otra técnica para
calcular la altura.
Lo que haremos es buscar el elemento del nodo de que queremos averiguar la

altura. Cada vez que avancemos un nodo incrementamos la variable que
contendrá la altura del nodo.
 Empezamos con el nodo raíz apuntando a Raiz, y la 'Altura' igual a cero.

 Si el valor del nodo raíz es igual que el del elemento que buscamos,
terminamos la búsqueda y el valor de la altura es 'Altura'.
 Incrementamos 'Altura'.
Calcular la altura de un árbol.
La altura del árbol es la altura del nodo de mayor altura. Para buscar este valor
tendremos que recorrer todo el árbol, de nuevo es indiferente el tipo de recorrido
que hagamos, cada vez que cambiemos de nivel incrementamos la variable que
contiene la altura del nodo actual, cuando lleguemos a un nodo hoja
compararemos su altura con la variable que contiene la altura del árbol si es
mayor, actualizamos la altura del árbol.
 Iniciamos un recorrido del árbol en postorden, con la variable de altura igual

a cero.
 Cada vez que empecemos a recorrer una nueva rama, incrementamos la
altura para ese nodo.
 Después de procesar las dos ramas, verificamos si la altura del nodo es
mayor que la variable que almacena la altura actual del árbol, si es así,
actualizamos esa variable.
7.8 árboles degenerados
Los árboles binarios de búsqueda tienen un gran inconveniente. Por ejemplo,

supongamos que creamos un ABB a partir de una lista de valores ordenada:
2, 4, 5, 8, 9, 12
Difícilmente podremos llamar a la estructura resultante un árbol:

Esto es lo que llamamos un árbol binario de búsqueda degenerado, y en el

siguiente capítulo veremos una nueva estructura, el árbol AVL, que resuelve este
problema, generando árboles de búsqueda equilibrados.
6.4 Aplicaciones de árboles.
Un ejemplo de estructura en árbol es el sistema de directorios y ficheros de

un sistema operativo. Aunque en este caso se trata de árboles con nodos de dos
tipos, nodos directorio y nodos archivo, podríamos considerar que los nodos hoja
son archivos y los nodos rama son directorios.
Otro ejemplo podría ser la tabla de contenido de un libro, por ejemplo de

este mismo manual, dividido en capítulos, y cada uno de ellos en subcapítulos.
Aunque el libro sea algo lineal, como una lista, en el que cada capítulo sigue al
anterior, también es posible acceder a cualquier punto de él a través de la tabla de
contenido.
También se suelen organizar en forma de árbol los organigramas de mando

en empresas o en el ejército, y los árboles genealógicos.

BIBLIOGRAFIA
Como programar C++

Deitel & Deitel
4ª Ed. Pearson/Prentice Hall
Desarrollo de algoritmos y sus aplicaciones en Basic, Cobol y C.

Guillermo Correa Uribe.
3ª Ed. McGraw Hill.
Estructuras de datos y algoritmos.

Alfred V. Aho, John E. Hopcroft, Jeffrey D. Ullman
Addison-Wesley Iberoamericana.
Estructuras de datos. Algoritmos, abstracción y objetos.

Luis Joyanes Aguilar, Ignacio Zahonero Martínez.
McGraw Hill.
Guia de Autoenseñanza C++

Herbert Schildt
McGraw Hill.
Manual de Estructuras dinámicas de datos.

Salvador Pozo.

MD Estructuras de Datos

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

MD Estructuras de Datos

Transféré par

Droits d'auteur :

Formats disponibles

ESTRUCTURA DE DATOS I MANUAL DEL DOCENTE

MANUAL DEL DOCENTE

SECRETARÍA DE EDUCACIÓN PÚBLICA

LIC. IVAN ANTONIO FLORES

Dr. Reyes Taméz Guerra

Estructuras de Datos D.R.  2005

ESTA OBRA, SUS CARACTERÍSTICAS Y DERECHOS SON PROPIEDAD DE LA: COORDINACIÓN

Estructura de Datos. UTIM

Estructura de Datos. UTIM

6.2. Árboles binarios…………………………………………………………………...75

Estructura de Datos. UTIM

Todos los compiladores incluyen, además del ANSI, ciertas características no

Probablemente este es el lugar más adecuado para explicar cómo se obtiene un

Para empezar necesitamos un poco de vocabulario técnico. Veremos algunos

Archivos fuente y programa o código fuente:

Archivos objeto, código objeto y compiladores:

Estructura de Datos. UTIM

equivalente a nuestro programa fuente comprensible para el ordenador, este

Junto con los compiladores de C y C++, se incluyen ciertos ficheros llamados

Archivos ejecutables y enlazadores:

Cuando obtenemos el fichero objeto, aún no hemos terminado el proceso. El

1. Nuestros programas usaran, en general, funciones que estarán incluidas en

Estructura de Datos. UTIM

Una vez terminada la fase de enlazado, ya podremos ejecutar nuestro programa.

Errores de sintaxis: son errores en el programa fuente. Pueden deberse a palabras

Avisos: además de errores, el compilador puede dar también avisos (warnings).

Errores de enlazado: el programa enlazador también puede encontrar errores.

Errores de ejecución: incluso después de obtener un fichero ejecutable, es posible

¿Qué clase de programas y aplicaciones se pueden crear usando C y C++?

Estructura de Datos. UTIM

La respuesta es muy sencilla: TODOS.

Tanto C como C++ son lenguajes de programación de propósito general. Todo

Una de las propiedades de C y C++ es la reutilización del código en forma de

Otra ventaja importante, C tiene más de 30 años de vida, y C++ casi 20 y no

Por último, existen varios compiladores de C y C++ gratuitos, o bajo la norma

Estructura de Datos. UTIM

1.1. Introducción a la orientación a objetos.

La programación orientada a objetos (POO) es una nueva manera de

Mediante un lenguaje de alto nivel, un programador estaba capacitado para

Los programas estructurados se basan en estructuras de control bien

Aunque la programación estructurada nos ha llevado a excelentes

Estructura de Datos. UTIM

Todos los lenguajes de POO comparten tres características: encapsulación,

La encapsulación es el mecanismo que agrupa el código y los datos que

Polimorfismo (del Griego, cuyo significado es “muchas formas”) es la

Estructura de Datos. UTIM

El tipo de datos utilizado para llamar a la función determina que versión

De manera general, el concepto de polimorfismo es la idea de “una interfaz,

El polimorfismo se puede aplicar tanto a funciones como a operadores,

La herencia es el proceso mediante el cual un objeto puede adquirir las

Sin embargo, mediante el uso de la herencia, es posible describir un objeto

1.2 Tipos de datos abstractos.

Los tipos de datos abstractos (TDA) encapsulan datos y funciones que

Estructura de Datos. UTIM

dato abstracto y el acceso a los datos es exclusivamente bajo el llamado a

1.3 Definición de estructuras de datos.

En programación, una estructura de datos es una forma de organizar un

Una estructura de datos define la organización e interrelacionamiento de

 Alta, adicionar un nuevo valor a la estructura.

Otras operaciones que se pueden realizar son:

 Ordenamiento, de los elementos pertenecientes a la estructura.

Cada estructura ofrece ventajas y desventajas en relación a la simplicidad y

Algunas estructuras de datos utilizadas en programación son:

Estructura de Datos. UTIM