Apuntes Estructuras2009

UNIVERSIDAD AUTONOMA GABRIEL RENE MORENO
FACULTAD DE CIENCIAS EXACTAS Y TECNOLOGIA

CARRERA DE INGENIERIA INFORMTICA

MATERIA DE ESTRUCTURA DE DATOS

~Aprendiendo Estructuras de Datos con C/C++

Grupo #19

Alumnas: Arggiro Soruco Liliana

Santa Cruz, Diciembre de 2001

2
Indice

Introduccin

CAPITULO 1

Arreglos.

1.1. DeIinicion de Arreglos en C..........................................................................37
1.2. Declaracion de Arreglos ...............................................................................37
1.3. Arreglos bidimensionales..............................................................................38
1.4. Inicializacion de Arreglos..............................................................................38

CAPITULO 2

Cadena de Caracteres

2.1. Introduccion a Cadenas de Caracteres...........................................................43
2.2. Funciones de Manejo de Cadenas..................................................................44
2.3. Entrada de Cadenas por teclado..................................................................46
2.4. Recorrer Cadenas con punteros.....................................................................48
2.5. Funciones de busqueda de Cadenas...............................................................49

CAPITULO 3

Programacin Orientada a Objetos

3.1. DeIinicion de Clase.......................................................................................53
3.2. EspeciIicadotes de Acceso............................................................................53
3.3. DeIinicion de Objeto...............................................................................................54
3.4. Metodos....................................................................................................................54
3.5. Herencia de Clase.....................................................................................................54
3.6. PolimorIismo............................................................................................................55
3.7. Encapsulado..............................................................................................................55

3

CAPITULO 4

Listas

4.1. DeIinicion de Listas ...................................................................................61
4.2. Representacion de Listas.............................................................................61
4.3. Listas en Arreglos Estaticos......................................................................62
4.4. Representacion de Listas en Arreglos Dinamicos.......................................65
4.5. Aplicaciones de Listas.................................................................................66

CAPITULO 5

Listas Parametrizadas

5.1. Plantillas.......................................................................................................75
5.2. DeIinicion de Listas Parametrizadas............................................................75
5.3. Implementacion de una Clase Parametrizada..............................................76

CAPITULO 6

Bicola , Pila , colas

6.1. DeIinicion de Bicola......................................................................................79
6.2. Listas en Arreglos Circulares........................................................................79
6.3. Representacion Interna de Bicola.................................................................81
6.4. DeIinicion de Pila..........................................................................................84
6.5. Representacion de una Pila...........................................................................85
6.6. DeIinicion de Cola.........................................................................................85
6.7. Representacion de Cola.................................................................................85
6.8. Implementacion de Pila y Cola......................................................................86

CAPITULO 7

Estructuras ,Uniones ,Enumeraciones

7.1. DeIinicion de Estructura...............................................................................91
7.2. Inicializacion de Estructuras..........................................................................91
7.3. Acceso a miembros de Estructuras...............................................................91
7.4. Como utilizar Estructuras con Iunciones......................................................91
7.5. Uniones..........................................................................................................92
7.6. Enumeraciones..............................................................................................93

4

CAPITULO 8

Listas ennlazadas

8.1. DeIinicion de Listas encadenadas...........................................................97
8.2. Implementacion de Listas Encadenadas.................................................97
8.3. Desventajas de Listas Encadenadas Simples.........................................100

CAPITULO 9

Listas Doblemente enlazadas

9. 1. DeIinicion de una lista doblemente encadenada.......................................103
9. 2. Estructura................................................... ..............................................103
9. 3. Insercion y eliminacion en una lista doble. .............................................104

CAPITULO 10

rboles

10. 1. DeIinicion de arbol...................................................................................107
10. 2. Arboles binarios........................................................................................107
10. 3. Conceptos Iundamentales sobre arboles...................................................108
10. 4. Propiedades de los arboles........................................................................108
10. 5. Recorridos en un arbol binario...............................................................109
10. 6. Arboles binarios de busqueda...................................................................110
10. 7. Representacion interna de un ABB...........................................................112
10. 8. Inserciones en un ABB.............................................................................113
10. 9. Aplicaciones de arboles............................................................................115

CAPITULO 11

Tipos Abstractos de Datos

11.1 DeIinicion de TDA........................................................................................119
11.2 Caracteristicas de tipos abstractos de dato....................................................119
11.3 ClasiIicacion..................................................................................................119
11.4 Implementacion.............................................................................................120
11.5 Componentes de un tipo de dato abstracto....................................................120

5

CAPITULO 12

Grafos

12. 1. DeIinicion de GraIo..................................................................................135
12. 2. Representacion interna de un graIo..........................................................135
12. 3. Tipos de graIos.........................................................................................137
12. 4. Navegar sobre los nodos de un graIo........................................................139
12. 5. Caso de navegar sobre un arbol general...................................................139
12. 6. Recorridos sobre un graIo.........................................................................140
12. 7. La clase GraIo...........................................................................................141
12. 8. Aplicaciones de graIos..............................................................................142
12. 9. Algoritmo de coloreado de graIos............................................................142

Bibliografa

Conclusiones y Recomendaciones

6
Introduccin

El presente trabajo esta dirigido principalmente a los estudiantes de 4 semestre de la
carrera de ingenieria de sistemas, principalmente a los alumnos que estan cursando la
materia de Estructura de Datos.

El proposito Iundamental de este trabajo es servir como material de lectura y consulta
para los subsiguientes cursos de la carrera de sistemas.

Se encuentra dividido 12 capitulos:

Una descripcion detallada de los diIerentes capitulos se proporciona a continuacion:

Capitulo 1: Los arreglos tienen su tratamiento especial, en este capitulo se aprendera su
manejo.

Capitulo 2: Este capitulo trata a cadenas desde el punto de vista de un arreglo, en este
capitulo se enseara su tratamiento.

Capitulo 3: Una parte de mucha importancia es conocer los conceptos y tecnicas
orientadas a objetos, en este capitulo se introduce al lector en este concepto.

Capitulo 4: En este capitulo se aprendera la estructura de datos Lista, usando para ellos
listas en arreglos estaticos, dinamicos.

Capitulo 5: En este capitulo trata sobre el uso de plantillas, en este capitulo se utiliza ese
concepto aplicado a listas.

Capitulo 6: En este capitulo se tocan las estructuras de datos mas tipicas en estructuras
de datos pila cola y una mezcla de ambas, la bicola.

Capitulo 7: Este capitulo ensea las estructuras uniones y enumeraciones.

Capitulo 8: Una estructura de datos mas avanzada son las listas encadenadas, en este
capitulo se ensea su deIinicion e implementacion.

Capitulo 9: Otro enIoque de la estructura de datos lista son las listas doblemente
encadenadas.

7
Capitulo 10: Una estructura de datos muy util en la construccion de programas mas
eIiciente es la ED arbol, en este capitulo se introduce al lector al estudio de esta
estructura.

Capitulo 11: en este capitulo se enIoca lo que son los ADTs y su importancia en la
implementacion de los problemas.

Capitulo 12: Los graIos son una de las estructuras de datos mas clasicos y de mayor
utilidad en el diseo de problemas complejos. La implementacion de esta ED se estudia
en este capitulo.

8

Captulo 1

Arreglos

Sinopsis

1.1.DeIinicion de arreglos en C.
1.2.Declaracion de arreglos.
1.3.Arreglos bidimensionales.
1.4.Inicializacion de arreglos.

Los arreglos son estructuras estaticas, debido a que conservan su
tamao a lo largo de toda la ejecucion del programa.
Este capitulo sirve como una pequea introduccion a la tematica
base que son las estructuras de datos.

9

1.1. Definicin de Arreglos

Los arreglos son estructuras de datos que tienen elementos de datos relacionados del mismo tipo.

En otras palabras un arreglo es una coleccion de posiciones de memoria relacionadas entres si,
para reIerirnos a un elemento particular lo haremos mediante el nombre del arreglo y la posicion
del elemento dentro del arreglo.

Es decir:
Arreglo| posicion |

1.2. Declaracin de Arreglos

Un arreglo declaramos de la siguiente manera:

int A|MAX|;

A es un arreglo de MAX elementos.
En memoria:

MEM

Tipo de dato Nombre|dimension|;

int vec|10|; //0-9

Tambien podemos inicializarlos:

int vec|3|2,5,6};

0 1 2 3............................MAX-1

A

Arreglos
10

1.3. Arreglos Bidimensionales.-

Las matrices en C son arreglos bidimensionales cuya declaracion es:

int Mat|Iila||columna|;

Para saber cuanto espacio de memoria ocupan nuestros arreglos se lo puede calcular de acuerdo
a la siguiente Iormula:

Iila*columna*sizeoI(tipo de dato)bytes

Unidimensional Bidimensional Tridimensional

1.4. Inicializacin de Arreglos

Se pueden inicializar los arrays al declararlos igual que haciamos con las variables. Recordemos
que se podia hacer:

int hojas 34;

Con arrays se puede hacer:

int temperaturas|24| 15, 18, 20, 23, 22, 24, 22, 25, 26, 25, 24, 22,
21, 20, 18, 17, 16, 17, 15, 14, 14, 14, 13, 12 };

Ahora el elemento 0 (que sera el primero), es decir temperaturas|0| valdra 15. El
elemento 1 (el segundo) valdra 18 y asi con todos. Vamos a ver un ejemplo:

Arreglos
11

#include <stdio.h>

void main()
{
int hora;
int temperaturas[24] = { 15, 18, 20, 23, 22, 24, 22, 25, 26,
25, 24,
22, 21, 20, 18, 17, 16, 17, 15, 14,
14, 14, 13, 12 };

for (hora=0 ; hora<24 ; hora++ )
{
printf( "La temperatura a las %i era de %i
grados.\n", hora, temperaturas[hora] );
}
}

Hemos indicado al compilador que nos reserve memoria para un array de 24 elementos de tipo
int. Que ocurre si introducimos menos de los reservados? , los elementos que Ialten valdran
cero.

Ejemplo

void leer arreglo ( int *a ; int * n )
{
scanf ( % d , n );

for ( int i=0; i<= *n; i++)
{
printf ( elem [% d] = , I );
scanf ( % d ,& a[i ]);
// scanf ( %d , a+i ); es vlido
}
}

void mostrar arreglo ( int *a ; int n)
{
for ( int i =0; i<=n ; i++)
printf ( [%5d ], a[i]);
printf ( \n );
}

Arreglos
12

Cevallos- Javier 'Curso de programacion con C '
Fuente dedicada a la enseanza del lenguaje C, principalmente dirigida a programadores con
cierto grado de conocimiento en C.

Pginas Web

http://www.abcdatos.com /tutoriales/
Pagina dedicada a la inIormatica, programacion , tutoriales de programas.

http://www.laIacu.com /tutoriales/
Pagina dedicada al campo de la inIormatica, provee a los usuarios de una extensa gama de
tutoriales y cursos desde los mas basicos hasta los mas avanzados temas.

Arreglos: Referencias
13

Captulo 2

Cadenas de Caracteres

Sinopsis

2.1.Introduccion a cadenas.
2.2.Funciones de manejo de cadenas.
2.3.Entrada de cadena por teclado.
2.4.Recorrer cadenas con punteros.
2.5.Funciones de busqueda de cadenas

En este capitulo se presentan las Iunciones de biblioteca
estandar para el manejo de cadenas de caracteres.
Las Iunciones que les permiten a los programas procesar
caracteres y cadenas de caracteres, lineas de texto y bloques de
memoria.

14

2.1. Introduccin a cadenas

En C no existe un tipo string como en otros lenguajes. No existe un tipo de datos para almacenar
texto, se utilizan arrays de chars. Funcionan igual que los demas arrays con la diIerencia que
ahora jugamos con letras en vez de con numeros.
Se les llama cadenas, strings o tiras de caracteres. A partir de ahora les llamaremos cadenas.
Para declarar una cadena se hace como un array:

a` b` c` \0 ...........................

Indicador de Iin de linea

char texto|20|;

Al igual que en los arrays no podemos meter mas de 20 elementos en la cadena. Vamos
a ver un ejemplo para mostrar el nombre del usuario en pantalla:

#include <stdio.h>

void main()
{
char nombre[20];

printf( "Introduzca su nombre (20 letras mximo): " );
scanf( "%s", nombre );
printf( "\nEl nombre que ha escrito es: %s\n", nombre );
}

Algo interesante como por ejemplo que en el scanI no se usa el simbolo &. No hace Ialta porque
es un array, es equivalente a poner &nombre|0|.

Es interesante saber como Iunciona una cadena por dentro, por eso vamos a ver primero como se
inicializa una cadena.

#include <stdio.h>

void main()
{
char nombre[] = "abcdefg";

printf( "Texto: %s\n", nombre );
printf( "Tamao de la cadena: %i bytes\n", sizeof (nombre) );
}

15

resultado :8bytes

La cadena es "abcdeIg", sin embargo nos dice que ocupa 8 bytes. Como cada elemento (char)
ocupa un byte eso quiere decir que la cadena tiene 8 elementos. al Iinal de una cadena se pone un
simbolo

'\0' que signiIica "Fin de cadena". De esta Iorma cuando queremos escribir la cadena basta con
usar s y el programa ya sabe cuantos elementos tiene que imprimir, hasta que encuentre '\0'.
El programa anterior seria equivalente a:

#include <stdio.h>

void main(int argc,char *argv[])
{
char nombre[] = { 'a', 'b', 'c', 'd', 'e',f,g, '\0' };

}

Aqui ya se ve que tenemos 8 elementos. Pero, Que pasaria si no pusieramos '\0' al Iinal?

#include <stdio.h>

void main()
{
char nombre[ ] = { 'a', 'b', 'c', 'd', 'e',f,g, '\0' };

}

Despues de "abcdeIg puede aparecer cualquier cosa. Lo que aqui sucede es que no encuentra el
simbolo '\0' y no sabe cuando dejar de imprimir. Cuando metemos una cadena se hace de la
primera Iorma y el C se encarga de poner el simbolo al Iinal.
Es importante no olvidar que la longitud de una cadena es la longitud del texto mas el simbolo
de Iin de cadena. Por eso cuando deIinamos una cadena tenemos que reservarle un espacio
adicional.

2.2. Funciones de manejo de cadenas

Existen unas cuantas Iunciones en la biblioteca estandar de C para el manejo de cadenas:
Para usar estas Iunciones hay que aadir la directiva:

16

#include <strings.h>
strcpy

#include <string.h>

char *strcpy(char *cadena1, const char *cadena2);

Copia el contenido de cadena2 en cadena1. cadena2 puede ser una variable o una cadena directa
(por ejemplo "hola"). Debemos tener cuidado de que la cadena destino (cadena1) tenga espacio
suIiciente para albergar a la cadena origen (cadena2).

#include <stdio.h>

void main()
{
char textocurso[] = "Este es una prueba.";
char destino[50];

strcpy( destino, textocurso );
printf( "Valor final: %s\n", destino );
}

strcat

#include <string.h>
char *strcat(char *cadena1, const char *cadena2);

Copia la cadena2 al Iinal de la cadena1.

#include <stdio.h>

void main()
{
char nombre_completo[50];
char nombre[]="Liliana";
char apellido[ ]="Arggiro";

strcpy( nombre_completo, nombre );
strcat( nombre_completo, " " );
strcat( nombre_completo, apellido );

printf( "El nombre completo es: %s.\n", nombre_completo );
}

17

Como siempre tenemos que asegurarnos que la variable en la que colocamos las demas cadenas
tenga el tamao suIiciente. Con la primera linea colocamos el nombre en nombrecompleto.
Usamos strcpy para asegurarnos de que queda borrado cualquier dato anterior. Luego usamos un
strcat para aadir un espacio y Iinalmente colocamos el apellido.

sprintf

#include <stdio.h>

int sprintf(char *destino, const char *format, ...);

Funciona de manera similar a printI, pero en vez de mostrar el texto en la pantalla lo guarda en
una variable (destino). El valor que devuelve (int) es el numero de caracteres guardados en la
variable destino.

Con sprintI podemos repetir el ejemplo de strcat de manera mas sencilla:

#include <stdio.h>

void main()
{
char nombre_completo[50];
char nombre[]="Practica";
char apellido[]="C++";

sprintf( nombre_completo, "%s %s", nombre, apellido );
printf( "El nombre completo es: %s.\n", nombre_completo );
}

2.3. Entrada de cadenas por teclado (scanf y gets)

scanf

scanI almacena en memoria (en un buIIer) lo que vamos escribiendo. Cuando pulsamos ENTER
(o Intro o return) lo analiza, comprueba si el Iormato es correcto y por ultimo lo mete en la
variable que le indicamos.

#include <stdio.h>

18

void main()
{
char cadena[30];
printf( "Escribe una palabra: " );
scanf( "%s", cadena );
printf( "He guardado: \"%s\" \n", cadena );
}

Es importante siempre asegurarse de que no vamos a almacenar en cadena mas letras de las que
caben. Para ello debemos limitar el numero de letras que le va a introducir scanI. Si por ejemplo
queremos un maximo de 5 caracteres usaremos 5s:

#include <stdio.h>

void main()
{
char cadena[6];

scanf( "%5s", cadena );
}

Si metemos una palabra de 5 letras (no se cuenta '\0') o menos la recoge sin problemas y la
guarda en cadena.

Si metemos mas de 5 letras nos cortara la palabra y nos dejara solo 5.

scanI tiene mas posibilidades (consulta la ayuda), entre otras permite controlar que caracteres
entramos. Supongamos que solo queremos las letras mayusculas:

#include <stdio.h>

void main()
{
char cadena[30];

scanf( "%[A-Z]s", cadena );
}

Guarda las letras mayusculas en la variable hasta que encuentra una minuscula:
Escribe una palabra: Hola
He guardado: "H"

19

Escribe una palabra: HOLA
He guardado: "HOLA"
Escribe una palabra: AMigOS
He guardado: "AM"
gets
Esta Iuncion nos permite introducir Irases enteras, incluyendo espacios.

#include <stdio.h>

char *gets(char *buffer);

Almacena lo que vamos tecleando en la variable buIIer hasta que pulsamos ENTER. Si se ha
almacenado algun caracter en buIIer le aade un '\0' al Iinal y devuelve un puntero a su
direccion. Si no se ha almacenado ninguno devuelve un puntero NULL.

#include <stdio.h>

void main()
{
char cadena[30];
char *p;

p = gets( cadena );
if (p) printf( "He guardado: \"%s\" \n", cadena );
else printf( "No he guardado nada!\n" );
}

Esta Iuncion es un poco peligrosa porque no comprueba si nos hemos pasado del espacio
reservado (de 29 caracteres en este ejemplo: 29letras'\0').

2.4. Recorrer cadenas con punteros

Las cadenas se pueden recorrer de igual Iorma que haciamos con las matrices, usando punteros.
Este sencillo programa cuenta los espacios y las letras 'e' que hay en una cadena.

#include <stdio.h>

void main()
{
char cadena[ ]="Esta es una prueba";
char *p;
int espacios=0, letras_e=0;

20

p = cadena;
while (*p!='\0')
{
if (*p==' ') espacios++;
if (*p=='e') letras_e++;
p++;
}
printf( "En la cadena \"%s\" hay:\n", cadena );
printf( " %i espacios\n", espacios);
printf( " %i letras e\n", letras_e);
}

Para recorrer la cadena necesitamos un puntero p que sea de tipo char. Debemos hacer que p
apunte a la cadena (pcadena. Asi p apunta a la direccion del primer elemento de la cadena. El
valor de *p seria por tanto 'G'. Comenzamos el bucle.

La condicion comprueba que no se ha llegado al Iinal de la cadena (*p!'\0'), recordemos que '\0'
es quien marca el Iinal de esta. Entonces comprobamos si en la direccion a la que apunta p hay
un espacio o una letra e. Si es asi incrementamos las variables correspondientes. Una vez
comprobado esto pasamos a la siguiente letra (p).
Dos cosas muy importantes: primero no debemos olvidarnos nunca de inicializar un puntero, en
este caso hacer que apunte a cadena. Segundo no debemos olvidarnos de incrementar el puntero
dentro del bucle (p), sino estariamos en un bucle inIinito siempre comprobando el primer
elemento.
En la condicion del bucle podiamos usar simplemente: while (!*p), que es equivalente a
(*p!'\0')

2.5.- Funciones de bsqueda de la biblioteca de manejo de cadenas

char ` strchr (const char* S , int C) Localiza la primera instancia del caracter c en
la cadena S , si lo encuentra regresa un apuntador a
C de lo contrario regresa un apuntador NULL

Size-t strcspn (const char *S1 , const char *S2 ) Determina y regresa la longitud del
segmento inicial de la cadena S1
consistiendo de caracteres no contenidos
en la cadena S2.

Size-t strspn (const char *S1 , const char *S2 ) Determina y regresa la longitud del
segmento inicial de la cadena S1
que consiste solo de caracteres
contenidos
en la cadena S2.

21

char ` strpbrkr (const char* S1 ,const char*S2) Localiza la primera ocurrencia en la
cadena S1de cualquier caracter de la cadena
S2 si lo encuentra regresa un apuntador al
caracter en la cadena S1 de lo contrario
regresa un apuntador NULL

char ` strrchr (const char* S , int C) Localiza la ultima instancia del caracter C en
la cadena S , si lo encuentra regresa un apuntador a
C en la cadena S de lo contrario regresa
Un puntador NULL

char ` strstr (const char* S1 , const char*S2 ) Localiza la primera ocurrencia en la cadena
S1 de la cadena S2, si lo encuentra regresa
un apuntador a la cadena en S1 de lo
contrario regresa un puntador NULL

char ` strstok (const char* S1 , const char*S2 ) Divide la cadena S1 en tokens que estan
separados por caracteres contenidos en la
cadena S2 si no hay mas tokens regresa un
puntador NULL

22

Deitel/Deitel 'Como programar en C/ C '
Libro base para la enseanza del lenguaje C/C, una Iuente importante de inIormacion para
principiantes en C.

Joyanes- Luis 'Programacion Orientada a Objetos
Libro altamente dedicado a lo que es la programacion orientada a objetos, sus conceptos, sus
herramientas, todo lo que se debe saber sobre la tecnica OO.

Pginas Web

Pagina dedicada a la inIormatica, en ella se pueden encontrar un sin Iin de cursos, tutoriales,
programas que Iacilitan el aprendizaje de la materia en especial.

http:// www.lawebdelprogramador.com
Pagina dedicada a los programadores, en ella se encuentran programas, soItware de ultima, y
trucos que hacen mas rapida la programacion.

Cadenas de Caracteres : Referencias
23

Captulo 3

Principios de Programacin Orientada a
Objetos

Sinopsis

3.1.DeIinicion de clase.
3.2.EspeciIicadores de Acceso.
3.3.DeIinicion de objeto.
3.4.Metodos.
3.5.Herencia de clase.
3.6.PolimorIismo.
3.7.Encapsulado.

La programacion orientada a objetos se basa en la idea natural
de la existencia de un mundo lleno de objetos, de modo que la
resolucion de un problema se realiza en terminos de objetos.
Este concepto no es nuevo lenguajes como Smalltalk se basan en
la POO y muchos optros con IilosoIia estructurada han aadido
propiedades de objetos tales como el mismo C.
El objeto es la extension natural del tipo de dato y la POO
aquella que se basa en el objeto como componente Iundamental.

24

3.1. Definicin Clase

Es un tipo de dato deIinido por el usuario que tiene un estado ( su representacion) y metodos u
operaciones (comportamiento. una clase tiene datos y metodos internos en Iorma de
procedimientos o Iunciones puede tener algunos miembros que sean privados y a los que no
se puede acceder desde el exterior de la clase.

Clase es la implantacion de un tipo de objeto. EspeciIica la estructura de datos y los metodos
operativos permitidos que se aplican a cada uno de sus objetos.
La clase especiIica la estructura de datos de cada uno de sus objetos y las operaciones que se
utilizan para tener acceso a los objetos. La especiIicacion de como se llevan a cabo las Iunciones
de una clase se llama metodos.
Declaracin de una Clase

3.2. Especificadores de Acceso

La directiva private:

Indica campos y metodos de una clase que no es accesible desde Iuera de la unidad ( el
archivo de codigo Iuente) que declara la clase.

La directiva public:

Indica campos y metodos a los que se puede acceder libremente desde cualquier parte del
programa, asi como en la unidad en que estan deIinidos.

class nombre

private:
// miembros privados ( Iunciones y
datos)
public:
// mirembros publicos ( Iunciones y
datos)
protecte:
// miembros protegidos ( Iunciones y
datos)

Programacion Orientada a Obfetos
25

La directiva protected.

Se utiliza para indicar metodos y campos con visibilidad limitada. Solamente la clase actual y
sus subclases pueden acceder a elementos que esten protegidos con esta directiva.

3.3. Definicin de Objeto

Es una instancia de una clase o una variable del tipo de dato deIinido por la clase, los objetos
son entidades reales cuando se ejecuta un programa los objetos ocupan memoria para su
representacion interna.

Una instancia de una clase, almacena sus datos dentro de el. Se tiene acceso a los datos y se les
modiIica solo mediante operaciones permisibles.
Para representar una instancia de una clase:

3.4. Mtodos
Los metodos de una clase controlan solamente a los objetos de esa clase. No pueden tener acceso
directo a las estructuras de datos de un objeto en una clase distinta. Para utilizar las estructuras
de datos en una clase diIerente, deben enviar una solicitud a ese objeto.

3.5. Herencia de Clase.

La herencia de clase (que solo se conoce como herencia) es una implantacion de la
generalizacion. La generalizacion establece que las propiedades de un tipo se aplican a sus
subtipos.

La herencia de clase hace que la estructura de datos y operaciones sean disponibles para su
reutilizacion por parte de sus subclases. La herencia de las operaciones de una superclase
permite que las clases compartan codigo. La herencia de la estructura de datos permite la
reutilizacion de la estructura.

26

3.6. Polimorfismo.

Uno de los objetivos principales de las tecnicas OO es utilizar otra vez el codigo. Sin
embargo, algunas de las operaciones requieren adaptacion para resolver necesidades
particulares.
Esta necesidad, se da generalmente entre superclases y subclases, donde una subclase es una
especializacion de su superclase, y puede requerir alcanzar los mismos objetivos, pero con
distintos mecanismos. Por ejemplo, una superclase rectangulo podria tener una operacion area
cuyo objetivo es calcular el area del rectangulo, deIinida como la multiplicacion de los largos de
dos lados contiguos. A su vez, la clase cuadrado es una subclase de rectangulo que tambien tiene
una operacion area cuyo objetivo es calcular el area del cuadrado, pero que esta deIinida
especialmente para los objetos del tipo cuadrado como la multiplicacion del largo de uno de sus
lados por si mismo.

El Ienomeno recien descrito se conoce como polimorIismo, y se aplica a una operacion que
adopta varias Iormas de implantacion segun el tipo de objeto, pero cumple siempre el mismo
objetivo.
Una de las ventajas del polimorIismo es que se puede hacer una solicitud de una operacion sin
conocer el metodo que debe ser llamado. Estos detalles de la implantacion quedan ocultos para
el usuario; la responsabilidad descansa en el mecanismo de seleccion de la implantacion OO.

3.7. Encapsulado

El encapsulado oculta los detalles de su implantacion interna a los usuarios de un objeto. Los
usuarios se dan cuenta de las operaciones que puede solicitar del objeto, pero desconocen los
detalles de como se lleva a cabo la operacion. Todos los detalles especiIicos de los datos del
objeto y la codiIicacion de sus operaciones estan Iuera del alcance del usuario.

27



Pginas Web

Pagina dedicada a la inIormatica, en ella se encuentra importante material de la tecnica orientada
a objetos, y demas.

Pagina dedicada a los programadores, desde ella se puede acceder a un sin Iin de tutoriales para
Iacilitar el aprendizaje, especialmente del lenIuaje C.

POO : Referencias
28

Captulo 4

Listas

Sinopsis

4.1.DeIinicion de lista..
4.2.Representacion de listas..
4.3.Representacion de Listas en arreglos estaticos.
4.4. Representacion de Listas en arreglos dinamicos.
4.5.Aplicaciones de listas

Las listas son una estructura de datos clasica.
En este capitulo enIocaremos el estudio de lista desde 2 puntos,
ambos en arreglos pero una en arreglos estaticos y otra en
arreglos dinamicos.
Asi como tambien algunas aplicaciones Iaciles de comprender
como son los numeros extremadamente grandes.

29

4.1. Definicin de Lista

Una lista es una secuencia de elementos:

a
1
, a
2
, ............,a
n

1 2

3

Si n1; Lista unitaria.
Si n0; lista vacia;

Los elementos de la lista tienen un orden de aparicion.
Es decir si se tienen 2 listas:

Lista 1: a, b, c.
Lista 2: b, a, c.

Son listas distintas.
En Iorma general: sobre los elementos de una lista, se puede aplicar un conjunto de operaciones
Irecuentemente utilizadas, tales como insertar, eliminar, etc.

4.2. Representacin de listas.-

Las listas se pueden representar de 2 Iormas basicas.

En arreglo:

Lista :

Lista encadenada:

Lista

Estudiaremos el conjunto de operaciones sobre una lista, dicho conjunto se aplica a listas con
diIerentes representaciones internas.

a
1
a
2
............,a
n

a
1
a
1

a
1

Listas
30

La leccion de la representacion de una lista depende de las caracteristicas del dominio de
problema, todas las representaciones tienen sus ventajas y desventajas.

Estudiaremos otras representaciones de listas sobre representaciones basicas:

Arreglos Asignacion estatica de memoria.
Listas Asignacion dinamica de memoria.

4.3.Representacin de Listas en arreglos estticos.-

Definicin

DeIiniremos una lista con elementos de un solo tipo de dato, inicialmente usaremos asignacion
estatica de memoria, es decir, debemos reservar espacio de memoria siempre, de acuerdo a la
constante MAX.

#deIine MAX 100

hay que tener muy en cuenta que los arreglos ocupan espacios de memoria adyacentes:

La clase lista con arreglos estaticos quedaria deIinida de la siguiente manera:

typedef int tipo_elem;
typedef int boolean;

#define true 1
#define false 0
#define MAX 100

class Lista
{

private :
tipo_elem Arreglo[MAX];
int CantElem;

public:

Lista( void )
{
CantElem=0;

Listas
31

}

boolean Vacia(void)
{
return ( CantElem= =0);
}

boolean Llena(void)
{
return ( CanElem= = MAX) ;
}

void inicializar(void)
{
CantElem=0;
}

-----------------
-----------------
.......................
......................
};

Notese que en la deIinicion de la class lista hacemos la implementacion de algunas Iunciones
dentro de ella, a esto llamamos Iunciones inline o Iunciones en linea.

void Lista::Leer(void);
void Lista::Mostrar(void);

void Lista::InsertarIesimo(tipo_elem x, int i);
void Lista::InsertarPrimero( tipo_elem x);
void Lista::InsertarUltimo(tipo_elem x);
void Lista::InsertarLugar(tipo_elem x);

void Lista::EliminarIesimo( int i);
void Lista::EliminarPrimero( void);
void Lista::EliminarUltimo(void);

Hay Iunciones que se implementan sin pensar en la estructura que las va a invocar, es decir hay
Iunciones que sirven para cualquier estructura de datos, tal es el caso de Lee de lista que se
implementa a continuacion:

void Lista::Leer(void)
{

int n;
tipo_elem x;

cout<<Cantidad de elementos.<<endl;
cin>>n;

int i=1;
while( i<= n)
{

Listas
32

cout<<elemento;
cin>>x;

InsertarUltimo(x);
//InsertarPrimero(x);
//InsertarLugar(x);

i=i+1;
}
}

A continuacion..algunas implementaciones importantes para la class lista:

void Lista :: LeerLista (void)
{
int n;
TipoElem x;
cout << "Introduzca la cantidad de elementos de la lista : ";
cin >> n;

for (int i = 1; i <= n; i++)
{
cout << "Elemento : "<< i;
cin >> x;
InsertarUltimo (x);
}
}

void Lista :: MostrarLista (void)
{
for (int i = 0; i < cantElem; i++ )
{
cout << Arreglo [i] << " ";
}
cout << endl;
}

void Lista :: InsertarIesimo (TipoElem x, int i)
{
int k = cantElem - 1;
while (k >= i)
{
Arreglo [k+1] = Arreglo [k];
k--;
}
Arreglo [i] = x;
cantElem = cantElem + 1;
}

Listas
33

void Lista :: EliminarIesimo (int i)
{
int k = i + 1;
while (k < cantElem)
{
Arreglo [k-1] = Arreglo [k];
k++;
}
cantElem = cantElem - 1;
}

4.4. Representacin de Listas en arreglos dinmicos.-

Hemos observado una gran desventaja de la representacion de listas con arreglos estaticos.

a) Todas las listas se crean con un mismo tamao.
b) Todas las listas que se crean son unicamente para elementos de un solo tipo de dato.

Para dar solucion a la desventaja especiIicada en el inciso a), utilizaremos arreglos dinamicos.

La asignacion dinamica la realizaremos mediante la clausula new.

La representacion interna de la class lista seria:

class lista
{
private:
tipo_elem *Arreglo;
int CantElem;
int Max;

public:
lista(int n=200)
{
Max=0;
CantElem=0;

Arreglo= new tipo_elem[Max];
}

};

Una Iorma para la realizacion de listas se da utilizando punteros como enlace para los
elementos. En esta representacion, una lista esta Iormada por celdas o nodos, cada nodo esta
Iormado por la inIormacion y un puntero que apunta al siguiente nodo.

Las listas enlazadas pueden mantenerse en orden haciendo inserciones en el lugar que
corresponde.

Listas
34

La longitud de la lista puede aumentarse o reducirse conIorme el usuario crea necesario.

No existen limitaciones en lo que se reIiere al tamao de una lista dinamica, esta solamente
sujeta a la cantidad de espacio de memoria que tengamos disponible.

Es importante hacer notar que cuando no estemos haciendo uso de la memoria asignada debemos
liberarla con free, para regresar esta al sistema operativo.

4.5. Aplicaciones de Listas.-

Hemos analizado de una Iorma generica las propiedades de una lista. Es decir hemos deIinido
las operaciones mas Irecuentemente utilizadas sobre una lista. Sin embargo las aplicaciones de
listas tienen caracteristicas propiamente deIinidas sobre estos.

En programacion orientada a objetos para describir esta caracteristica de construccion
utilizaremos la propiedad de herencia.

Lista
Aplicacion1 Aplicacion2 Aplicacion n
Aplicacion 1.1 Aplicacion1.2

Listas
35

Aplicacin 1

Numeros Extremadamente grandes

Con esta representacion se entiende que los digitos extremadamente grande se
almacenan en una lista
Con esta representacion podemos manipular enteros positivos de 10, 100, 1000 o mas digitos

Ejemplo N 3456789

Listas

void main (void) // Program Principal
{
Numero Grande N1, N2, N3, N4;
N1. Leer ();
N2. Leer ( );
N3.sumar ( N1, N2);
N4.multiplicar(N1, N2);
N3. Mostrar ( );
N4.mostrar( );
}

class NumeroGrande : protected Lista
{

void Leer ( void);
void mostrar ( void)
void sumar (Numero Grande &, Numero Grande &)
void multiplicar ( Numero Grande & , Numero Grande & )

};

3 4 5 6 7 8 9 .......
Listas
36

Algunas Implementaciones de operaciones con nmeros grandes

void NumeroGrande::sumar ( NumeroGrande &N1 ,NumeroGrande &N2 )
{

int i= N1.CantElem() 1;
int j=N2.CantElem() -1;

Inicializar();

int Acarreo=0;

while ( i >=0 && j>=0 )
{
int Dig = (N1.Elem[I]+N2.Elem[j] + acarreo)% 10;
Acarreo= (N1.Elem[I]+N2.Elem[j] + acarreo)/10;
Insertar Primero(Dig );

i=i-1;
j=j-1;

}

while ( i >=0 )
{
Dig=(N1.Elem[I]+N2.Elem[j] + acarreo)% 10;
Acarreo=(N1.Elem[I]+N2.Elem[j] + acarreo)/10;
InsertarPrimero(Dig);

i= i-1;
}

while ( j>=0)
{
Dig =(N1.Elem[I]+N2.Elem[j] + acarreo)% 10;
Acarreo =(N1.Elem[I]+N2.Elem[j] + acarreo) /10;
Insertar Primero (Dig);
j=j-1;
}

if ( Acarreo >0 )

InsertarPrimero (Acarreo);

}

Listas
37

void NumeroGrande::Multiplicar(NumeroGrande &N1 , NumeroGrande & N2 )
{
int i=N2.CantElem()-1;

while ( i>=0)
{
Inicializar();
Acarreo =0;
J=N1.CantElem()-1;

while (j >=0)
{
Numero=N2.Elem(i)*N1.Elem(j)+Acarreo;
N3.InsertarPrimero(num % 10);
Acarreo =num/10;
j=j-1;
}

if (Acarreo!=0)
N3.InsertarPrimero(Acarreo);

i=i-1;

}

NumeroGrande=N3;
CantCeros=0;
i=N2.CantElem()-1;

while(i >=0)
{
N3.MultiplicarDig(N1,N2.Elem(i));
N3.AdicionarCeros (CantCeros); // Adiciona ceros al final de N3
CantCeros= CantCeros+1;

Sumar (N3);

i=i-1;
}

}

Listas
38

Aplicacin 2

Polinomios

Un entero grande se puede considerar como un polinomio con restricciones en los
coeIicientes Por ejemplo
El entero de 10 ciIras

2312020334
podria corresponder al polinomio

X
12
2X
20
3X
15
X
10
4X
8

El numero es el valor del polinomio en X10 todo polinomio de grado N-1 con coeIicientes
positivos menores que 10 corresponde precisamente a un entero de N ciIras

Se pueden utilizar las operaciones polinomicas para manipular numeros grandes
Se representan simplemente como arrays y se utilizan rutinas de manipulacion polinomica
desarrolladas como si los arrays representaran polinomios.

Para Sumar un entero positivo y uno negativo , hay que restar el de menor valor absoluto del
mayor valor y darle al resultado el signo del ultimo .

Por lo tanto se necesita saber cual tiene el valor mayor el primer criterio que se utiliza para
identiIicar un entero mayor es el de la longitud de los enteros . La lista con mas nodos
representa el entero con mayor valor, sin embargo el conteo real del numero de nodos implica
un recorrido extra de la lista.
En lugar de contar el numero de nodos, el conteo podria guardarse como parte del nodo
cabecera y reIerenciarse cuando Iuese necesario.

Sin embargo si las dos listas tienen el mismo numero de nodos, el entero de mayor valor sera
aquel cuyo digito mas signiIicativo sea mayor si los primeros digitos son iguales en ambos
enteros ,habra que recorrer la lista del digito mas signiIicativo al menos signiIicativo para
determinar que numero es mayor
Para este caso se debe utilizar listas doblemente enlazadas porque se debe recorrerla lista en
ambas direcciones.

Listas
39


Schildt- Herbert 'Manual de ReIerencia de C '
Fuente dedicada al aprendizaje del lenguaje en C, con todas las herramientas necesarias que
Iacilitan el aprendizaje, indica claramente cuales son las principales diIerencias que hacen al
lenguaje C, un lenguaje idoneo para las estructuras como punteros, listas..etc.

Listas : Referencias
40

Captulo 5

Listas Parametri:adas

Sinopsis

5.1.Plantillas
5.2.DeIinicion de listas Parametrizadas
5.3.Implementacion de una clase parametrizada

La evolucion de los lenguajes de programacion ha permitido la
aparicion de otros mecanismos para la abstraccion de control,
tales como las plantillas o templates, tambien llamado patrones.
Estas construcciones son soportadas solo por lenguajes
orientados a objetos.

41

5.1. Plantillas ( Template )

Las plantillas de clases permiten deIinir clases genericas que pueden manipular diIerentes
tipos de datos .Una aplicacion importante es la implementacion de contenedores, clases que
contienen objetos de un tipo dato tales como las listas y arreglos en esencia los contenedores
manejan estructura de datos.
Usamos plantillas para crear estructuras de datos de propositos generales.

5.2. Definicin de lista parametrizada

Es una clase parametrizada y que utilizara tipoElem como el tipo generico con esta deIinicion
se pueden crear listas de diIerentes tipos de datos.

Sea el siguiente programa:

void main ( void)

lista lista enteros;
lista lista float;
lista lista char;
}

En este programa aparentemente se crean tres listas

Una lista que contiene elementos enteros otra que contiene Ilotantes y otra que contiene char.
En realidad se esta creando 3 listas que contienen elementos de un mismo tipo de dato de tipo
elem
como deIinir la lista tal que sean deIinidas para cualquier tipo de dato?

Utilizando listas parametrizadas

void main (void)
{
lista <int > L1;
lista<float>L2;
lista <char>L3;

L1.leer();
L2.leer();
L3.leer();
}

42

Podemos utilizar listas que tengan tamao y tipos de datos diIerentes
Es decir

void main (void)
{
lista <int > L1; L1 (100);
lista<float>L2; L2(1000);
lista <char>L3; L3 (10.000);

L1.leer();
L2.leer();
L3.leer();

}

Utilizando esta representacion el tipoelem deIinido con typedeI ya no existe

5.3.Implementacin de una clase parametrizada

template<class tipoElem >

class lista //clase lista parametrizada

{
private:
tipoElem arreglo [max];
int cantElem,

public:

//funciones

}

Lista Parametrizada
Dinamica
43


Listas Parametrizadas : Referencias
44

Captulo 6

Bicola, Pila v Cola

Sinopsis

6.1.DeIinicion de bicola.
6.2.Listas en arreglos circulares.
6.3.Representacion interna de bicola.
6.4.DeIinicion de Pila.
6.5.Representacion de una Pila.
6.6. DeIinicion de una cola.
6.7. Representacion de una cola.
6.8.Implementacion de Pila y Cola.

La pila, la cola y una variacion de ambas, la bicola son
estructuras Iundamentales para el manejo de grandes problemas.
Una pila es una ED en la que todas las inserciones y
eliminaciones de elementos se realizan por un extremo
denominado cima de la pila.
Conceptos como este son tratados a lo largo del capitulo los
cuales nos ayudaran a entender mejor el tratamiento de estas
EDs.

45

6.1. Definicin de Bicola

Son Listas en donde se pueden aadir y quitar por ambos extremos . se les llama DEQUE
(Double Ended QUEue). Para representar las bicolas lo podemos hacer con un array circular con
Inicio Fin que apunten a cada uno de los extremos.
Es decir solo podemos aplicar un subconjunto de operaciones de una lista sobre una bicola, en
una bicola se inserta y se elimina por ambos extremos de la lista

6. 8.Listas en Arreglos Circulares

Una lista circular se deIine a aquella lista en el cual la posicion anterior a la posicion 0,
es la posicion max-1 , y la posicion siguiente a la ultima posicion es la posicion 0.

BICOLA
Insertar
Eliminar
Insertar
Eliminar
.............................
0 1 2 3 4 ..................................max-1
0
1
2
3
Max-1
Max-2
.
.
.
.

Bicola Pila v Colas
46

Sea el siguiente estado de una Bicola

Insertar por derecha D

Eliminar por Izquierda A

Eliminar por Izquierda

Eliminar por Izquierda

A B C
Primero Ultimo
A B C D
Primero ultimo
B C D
Primero ultimo
C D
Primero ultimo
D
Primero ultimo
Bicola Pila v Colas
47

Eliminar Por Izquierda

Como se aprecia el ultimo estado de la bicola esta vacia en el cual los indicadores de primero y
ultimo se encuentran en los extremos de la lista. (estado ideal para inicializar bicola en vacio)

-Para insertar un elemento por el extremo izquierdo ' primero recorre a la posicion anterior y
se
inserta el elemento en esa posicion.

-Para eliminar un elemento del extremo izquierdo 'primero se recorre a la posicion siguiente

-Para insertar un elemento por el extremo derecho 'Ultimo se recorre a la siguiente posicion y
el
elemento se inserta en esa posicion.

-Para eliminar un elemento por el extremo derecho 'Ultimo se recorre a la posicion anterior

6.3. Representacin interna de bicola.-

Una bicola representamos en un Arreglo de asignacion dinamica de memoria.

class Bicola
{

private:
tipoElem * Arreglo;
int CantElem;
int prim;
int Ult;
int Max;

public:
Bicola ( int n=20) // constructor
{
Arreglo= new tipoElem[n];
if (Arreglo==NULL)
Error (No existe espacio de Memoria.. );
CantElem=0;
prim=0;

Primero ultimo
Bicola Pila v Colas
48

Ult=n-1;
Max=n;
}

void InsertarIzq(tipoElem);
void InsertarDer(tipoElem);
void EliminarIzq(void);
void EliminarDer(void);

tipoElem FrenteIzq( void);
tipoElem FrenteDer( void);

void MostrarIzqDer(void);
void MostrarDerIzq(void);

void Inicializar(void);
Boolean vacia (void);
Boolean Llena (void);
};

void Bicola::InsertarIzq(tipoElem x)
{
if (Llena())
error (Bicola Llena....);
if (prim==0)
prim=max-1;
else
prim=prim-1;
Arreglo[prim]=x;
CantElem=cantElem+1;
}

void Bicola::EliminarIzq(void)
{
if (vacia())
error (Bicola Vacia...);
if (prim==max-1)
prim=0;
else
prim=prim+1;
CantElem=CantElem-1;

}

tipoElem Bicola::frenteIzq(void)
{
if (vacia())
error (Bicola Vacia...);
return(Arreglo[prim]);

}

Bicola Pila v Colas
49

void Bicola::MostarIzqDer (void)
{
if( vacia() )
{
tipoElem x=frenteIzq();
cout<<x;
EliminarIzq();
MostrarIzqDer();
InsertarIzq();

}
}

Utilizando las Operaciones de Bicola y otras Bicolas Hacer:

Ordenar(B1): Procedimiento que ordena los elementos de la bicola B1.

Iguales(B1,B2): Iuncion logica que devuelve verdadero si los elementos de la bicola B1 y B2
son iguales

Simetrico(B1): Iuncion logica que devuelve verdadero si los elementos de la Bicola B1 son
simetricos por los extremos.

Algunas Implementaciones

Boolean Iguales( Bicola B1,Bicola B2)
{
while( ! B1.vacia() && ! B2.vacia() &&B1.frenteIzq()==B2.frenteIzq())
{
B1.EliminarIzq();
B2.EliminarIzq();
}

return(B1.vacia() &&B2.vacia());

}

Boolean Simtrico(Bicola &B1)
{
if (B1.vacia())
return (true);
if (B1.frenteIzq!=B1.frenteDer())
return(False);

Bicola Pila v Colas
50

tipoElem X=B1.frenteIzq();
tipoElem Y=B1.frenteDer();

B1.EliminarIzq();
if ( !B1.vacia())
{

B1.eliminarDer();

Boolean Valor=Simetrico (B1);
B1.insertarIzq(X);
B1.InsertarDer(Y);

}

else
{

Boolean Valor=Simtrico(B1);
B1.InsertarDer(X);
}

return( Valor);

}

6.4. Definicin de Pila

Una Pila es una estructura de datos que permite almacenar datos de modo que el ultimo dato en
entrar en la pila es el primero en salir, una estructura de tipo LIFO (last In First Out).

La pila es una estructura con numerosas analogias en la vida real, una pila de platos, una pila de
documentos, una pila de monedas. Dado que la operacion de insertar y eliminar se realizan por
un solo extremo (superior) los elementos solo pueden eliminarse en un orden inverso al que se
insertan en la pila.

Las pilas se usan comunmente para indicar en que punto se encuentra un programa cuando
contiene procedimientos que se llaman a si mismos. Estos procedimientos se conocen como
procedimientos recursivos.

Bicola Pila v Colas
51
Pila

6.5. Representacin de una Pila.-

Una pila es un tipo de lista lineal en la que la insercion y Eliminacion de nuevos elementos solo
se
pueden realizar por un extremo que se denomina tope o cima.

6.6.Definicin de una Cola.-

En las colas el elemento primero en entrar es tambien el primero en salir por ello se conocen
como listas FIFO (First in First out).

En una Cola se Inserta por un extremo y se Elimina por otro extremo por ello las colas se usan
para almacenar datos que necesiten ser procesados segun el orden de llegada.

6.7. Representacin de una Cola.-

Tope
Insertar Eliminar
Dato
n

.
.
.
.
Dato2

Dato 1

Bicola Pila v Colas

PILA
52

Pueden representarse como estructuras dinamicas o arrays.

ESTRUCTURA DINAMICA

Dado que hemos desarrollado las operaciones de una Bicola restringiendo este conjunto de
operaciones encontramos operaciones para pilas y cola ,es decir podemos utilizar el concepto
de herencia.

6.8. Implementaciones de Pila y Cola

class Pila: protected Bicola
{
public:
void inicializar(void) { Bicola::Inicializar();}

Boolean Vacia(void) { return (Bicola::vacia());}
BooleanLlena(void) { return (Bicola:: Llena());}
void Insertar(tipoElem X){Bicola::InsertarDer(X);}

100 234 456 325
Inicio
Final
100 234 325 456
Inicio Final
Bicola
Pila Cola
Bicola Pila v Colas
53

};

class Cola: protected Bicola
{
public:
void Inicializar(void) {Bicola:: Inicializar();}
Bolean Vacia(void) { return (Bicola::vacia());}

BooleanLlena(void) { return (Bicola:: Llena());}
void Insertar(tipoElem X){Bicola::InsertarDer(X);}
void Eliminar(void) {Bicola:: EliminarDer (X);}
tipoElemFrente(void){ return (Bicola:: frenteIzq();}

};

Ejercicio

Sea un Editor de linea ,en el cual se utiliza los sgte caracteres especiales
borrar toda la linea
# borrar el caracter anterior

void main (void)
{
Pila <char> pila (81);
Char ch;

while( ch=getchat!=\n)
{
switch (ch)
{
case @: pila inicilizar();
Break;
case #: if ( ! pila vacia())
Pila Eliminar();
Break;
default: pila Insertar(ch);

}
pila.mostar(); // Bicola MostrarIzqDer

}

}

Bicola Pila v Colas

54


Kruse- Robert 'Estructura de datos y Diseo de programas
Fuente dedicada al diseo de programas utilizando las estructuras de datos, muy util en el
campo de la enseanza de las principales estructuras de datos.

Pginas Web

a objetos, y demas.


Bicola Pila y Cola : Referencias
55

Captulo 7

Estructuras Uniones Enumeraciones

Sinopsis

7.1.DeIinicion de una estructura.
7.2.Inicializacion de estructuras.
7.3.Acceso a miembros de estructuras.
7.4. Como utilizar Estructuras con Iunciones
7.5.Uniones
7.6.Enumeraciones

Las estructuras son colecciones de variables relacionadas a
veces denominadas agregados bajo un nombre. Las estructuras
pueden contener variables de muchos tipos diIerentes de datos, a
diIerencia de los arreglos.
En este capitulo se explicara que son estas estructuras, uniones y
enumeraciones.

56

7.1.Definicin de Estructura.-

Las Estructuras son tipos de datos derivados pueden tener variables de muchos tipos de datos
En C las Estructuras y Uniones son Clases.
DeIinicion de una estructura:

struct mensaje
{
char* nombre;
char* c;
};

7.2.Inicializacin de Estructuras.-

Pueden ser inicializadas mediante listas de inicializacion como con los arreglos
Los inicializadores deben estar entre llaves y separados por comas.

struct mensaje p= (Ingrid , Hola);

7.3. Acceso a los miembros de estructuras.-

Para tener acceso a miembros de una estructura se utilizan dos operadores
El operador de miembro de estructura (.)
El operador de apuntador de estructura -~

Ejemplo

printf( %s,p.nombre );
printf( %s, aptr-> c);

7.4. Como utilizar Estructuras con funciones

Las estructuras pueden ser pasadas a Iunciones pasando miembros de estructuras individuales,
o pasando toda la estructura. Cuando se pasan estructuras o miembros a una Iuncion se pasan
En llamadas por valor.
Para pasar una estructura en llamada por reIerencia se pasa la direccion de la variable de
estructura.

Para pasar una estructura en llamada por reIerencia se pasa la direccion de la variable de
estructura.

typedef

Estructuras Uniones v Enumeraciones

57

typedef

La palabra reservada typedef proporciona una Iorma de crear nombres de tipo mas breve
Ejemplo

typedef struct card card;

DeIine el nuevo nombre de tipo card.
typedef se utiliza a menudo para crear seudonimos para los tipos de datos basicos

7.5. Uniones

Las uniones es un tipo de dato derivado estan construidas utilizando objetos de otros tipos
cuyos miembros comparten el mismo espacio de almacenamiento .Los miembros de una union
pueden ser de cualquier tipo de dato el numero de bytes utilizados para almacenar una union
deben ser por lo menos suIicientes para contener el miembro mas grande.

En C una union es una posicion de memoria que es compartida por varias variables de diferentes
tipos

Declaracion de una union:

union number
{
int x;
float y;

};

Para declarar una variable de union se escribe:

union number Valor;

Para acceder a un elemento de la union se utiliza la misma sintaxis que se utiliza para
estructuras.

Las operaciones que pueden ser ejecutadas en una union son: asignar una union a otra union
del mismo tipo, tomar la direccion (&) de una union y tener acceso a los miembros de una union
Utilizando el operador de miembro de estructura y el operador de apuntador de estructura. Las
Uniones no pueden ser comparadas entre si .

58

Ejemplo

union prueba
{

int x;
float y;
double z;
};

void main (void)
{
union prueba acceso;

acceso.x= 21;
acceso.y=432.23;
acceso.z=7.467;
}

7.6 Enumeraciones

Una enumeracion introducida por la palabra reservada enum es un conjunto de constantes
enteras representadas por identiIicadores. Estas constantes de enumeracion son , en eIecto
constantes simbolicas cuyos valores pueden ser deIinidos automaticamente .

Los valores de un enum se inician con 0 a menos de que se deIina de otra manera, y se
incrementan en 1 .

enum Dia{ lunes, martes,mircoles, jueves, viernes, sabado, domingo };

enum Dia { lunes=1, martes, mircoles , jueves, viernes , sabado ,
domingo };

El primer valor de la enumeracion anterior se deIine explicitamente en 1 , los valores
subsiguientes se incrementan en 1 dando como resultado los valores hasta 7 , los identiIicadores
en una enumeracion deben ser unicos,
59

Ejemplo

# include <stdio.h >

enum Months { Jan=1, Feb, Mar,Apr, May , Jun, Jul, Aug, Sep, Oct, Nov, Dec );

void main ( void)
{
enum Months months;

char * monthName[]= { ,Enero , Febrero, Marzo , Abril,
Mayo, junio,Julio,Agosto, Septiembre
, Octubre, Noviembre, Diciembre};

for (months=Jan; months<= Dec; months++)
printf( %2d%11s\n,months, monthName[months]);

return ();

}

60

principiantes en C.


Estructuras-Uniones y Enumeraciones :Referencias
61

Captulo 8

Listas Encadenadas

Sinopsis

8.1.DeIinicion de una lista encadenada.
8.2.Implementacion de una lista encadenada.
8.3.Desventajas de las listas encadenadas simples

En este capitulo estudiaremos las listas encadenadas, una lista
encadenada es basicamente una estructura de datos dinamica
cuyos nodos generalmente son registros, y que pueden variar
segun los requerimientos.
A lo largo del capitulo se desarrollaran las implementaciones
sobre la class lista.

62

8.1. Definicin de lista encadenada

Una lista encadenada necesita que cada elemento de inIormacion contenga un enlace al
siguiente elemento de la lista . cada elemento consiste en una estructura que contiene campos de
informacion y un puntero de enlace.

LISTA ENLAZADA: Es una estructura de datos lineal con un numero no limitado de elementos
homogeneos llamados NODOS, a los cuales se accede mediante punteros.

Que es un NODO?:

Es un elemento Iormado por 2 partes, la parte de la Izquierda es el INFO, es donde guarda el
dato y el de la Derecha, es el SIG, me da la direccion de memoria del siguiente NODO.

inIo sig NULL

Lista

En las listas en arreglos , los elementos ocupan espacios de memoria adyacentes en las listas
enlazadas los elementos se encuentran en cualquier lugar de la memoria ( no necesariamente
contiguas)

Basicamente existen dos Iormas de construir una lista simplemente enlazada la primera
sencillamente aade cada nuevo elemento al Iinal de la lista y la otra aade elementos en
lugares especiIicos de la lista

8.2. Implementacin de Listas Enlazadas

class Lista // Nodo Cabecera
{
private:
nodo* prim;
nodo*Ulti;

public:
void Lista (void)
{
prim=NULL;
}
Boolean Lista::vacia(void)
{
return (prim=NULL);
}
Listas Encadenadas

63

Boolean Lista::Llena (void)
void Inicializar(void);
void Leer(void);
void Mostar(void);
void InsertarPrim(tipoElem);
void InsertarUlti(tipoEelm);
void InsertarIesimo(tipoElem);
void InsertarLugar(tipoElem);
void EliminarPrim(void);
void EliminarUlti(void);

};

class Nodo
{
private:
tipoElem elem;
Nodo * prox;

public:

Nodo(tipoElem X, Nodo* ptr)
{
elem=X;
prox=ptr;
}

void Elem (tipoElem X);
{
elem=x;
}

tipoElem elem(void)
{
return (elem);
}

};

Implementaciones Bsicas

Nodo* Lista ::crearNodo (tipoElem X, Nodo* ptr)
{

Nodo* q = new Nodo (X,ptr),

if (q== NULL )
Error ( No existe espacio.... );

return (q);

}
Listas Encadenadas
64

void Lista:: InsertarPrim(tipoElem X)
{
Nodo* q = crearNodo ( X, prim);
Prim= q;
}

void Lista::Mostrar (void)
{
Nodo *q=prim;

while (q!=NULL)
{
cout<< q->elem ();
q=q-> prox();
}

}

void Lista :: EliminarPrim(void)
{

if (vacia())
Error( No esiste Elementos ....);

Nodo* q= prim;
Prim=q-> prox();
delete q;
}
void lista ::EliminarIesimo (int i)
{
int k=1;
Nodo*p=prim;
*ap=NULL;

while ( p!=NULL && K< i )
{
ap=p;
p=p->prox();
k=k+1;
}
if (p! =NULL)
{
if (ap==NULL)
EliminarPrim();
else
{
ap-> Prox(p->prox());
delete p;
}
}
}
Listas Encadenadas
65

Las listas enlazadas se utilizan para dos propositos principales crear un arrays de tamao
desconocido tambien se utilizan en el almacenamiento en discos de base de datos ,las listas
enlazadas permiten insertar y eliminar elementos rapida y Iacilmente sin volver a reorganizar
todo el archivo.

8.3. Desventajas de las listas encadenadas simples.-

En la estructura de datos utilizada para representar una lista encadenadas simple,
utilizamos un Nodo cabecera que contiene unicamente un puntero que apunta al
primer nodo de la lista tiene las siguientes desventajas:

Navegar la lista para conocer la cantidad de elementos
Navegar la lista para insertar al ultimo

Estas dos desventajas se puede eliminar totalmente utilizando la siguiente estructura:

Nodo Cabecera

Listas Encadenadas
66


Sedgewick- Robert ' Algoritmos en C
Fuente bastante interesante en el tema de algoritmos de toda clase que se pueden implementar en
el lenguaje C, es una libro muy util en estructuras.

Pginas Web

a objetos, y demas.


Listas Encadenadas : Referencias
67

Captulo 9

Listas Doblemente Encadenadas

Sinopsis

9. 1. DeIinicion de una lista doblemente encadenada
9. 2. Estructura
9. 3. Insercion y eliminacion en una lista doble.

Las listas enlazadas se recorren en un solo sentido, generalmente
en un sentido ya establecido.
En muchos casos es conveniente avanzar en cualquiera de los
dos sentidos. Estas listas se denominan listas doblemente
enlazadas.
En este capitulo estudiaremos las listas doblemente
encadenadas, asi como su implementacion.

68

9.1. Definicin de Lista doblemente encadenada

Las listas encadenadas simples tienen la desventaja de no poder recorrer los elementos de la lista
del ultimo al primer nodo eIicientemente.

Existen aplicaciones en las cuales esta operacion se repite con mucha Irecuencia, para tal
proposito podemos utilizar las listas doblemente enlazadas. Sin embargo tiene un costo de
adicionar un espacio de memoria en cada nodo el cual apunta al nodo anterior.

La representacion de la estructura de datos podria ser:

Nodo cabeza

9.2. Estructura

class Lista
{
private:

Nodo *prim;
int CantElem;
Nodo *Ult;

public:

};

Un nodo de una lista doblemente enlazada puede ser considerado como un registro con tres
campos: un campo inIormacion y dos campos de enlace.

Como estamos trabajando con clases la class nodo queda redeIinida de la siguiente manera.


69

class Nodo{

private:
Nodo *ant;
tipoelem elem;
Nodo *ult;
public:

};

9. 3. Insercin y eliminacin en una lista doble.

Algunas implementaciones de la class lista doblemente encadenada, como ser, la insercion y
eliminacion de elementos:

void Lista::InsertarPrim( tipoElem x ): Metodo de la clase lista que inserta el elemento x en la
primera posicion de la lista.

void Lista::InsertarUlt( tipoElem x ) : Metodo de la clase lista que inserta el elemento x en la
ultima posicion de la lista.

void Lista::EliminarPrim( void ) : Metodo de la clase lista que elimina el primer elemento de
la lista.

void Lista::EliminarUlt( void ) : Metodo de la clase lista que elimina el ultimo elemento de
la lista.


70



Listas Doblemente Encadenadas : Referencias
71

Captulo 10

Arboles

Sinopsis

10. 1. DeIinicion de arbol.
10. 2. Arboles binarios.
10. 3. Conceptos Iundamentales sobre arboles.
10. 4. Propiedades de los arboles
10. 5. Recorridos en un arbol binario.
10. 6. Arboles binarios de busqueda.
10. 7. Representacion interna de un ABB.
10. 8. Inserciones en un ABB.
10. 9. Aplicaciones de arboles.

En este capitulo se centra la atencion sobre una estructura de
datos, el arbol, cuyo uso esta muy extendido y es muy util en
numerosas aplicaciones.
Los arboles junto con los graIos son estructuras no lineales.
Las estructuras de datos organizadas como arboles seran muy
valiosas en una gama grande de aplicaciones, sobre todo
problemas de recuperacion de inIormacion

72

10. 1. Definicin de rbol

Un arbol se deIine como un conjunto de nodos de los cuales existe un nodo especial llamado
nodo raiz del arbol y existe k-subconjunto disjuntos, que tambien son arboles (deIinicion
recursiva: arbol se deIine en Iuncion de arbol).

10. 2 .rboles binarios

Los arboles de grado 2 tienen una especial importancia. Se les conoce con el nombre de arboles
binarios. Se deIine un arbol binario como un conjunto Iinito de elementos (nodos) que bien esta
vacio o esta Iormado por una raiz con dos arboles binarios disjuntos, llamados subarbol
izquierdo y derecho de la raiz.

Arboles
Nodo Raiz
Arbol binario
73

10. 3 .Conceptos fundamentales sobre rboles

Algunos conceptos que debemos tener en cuenta en arboles son los siguiente:

Nodo: Se denomina nodo a cada uno de los elementos de un arbol.

Rama: Una rama es cada uno de los enlaces que existe entre los nodos de un arbol.

Antecesor o padre: Es un nodo del que cuelga algun otro, llamado descendiente o
hijo.

Descendiente directo o antecesor directo: Un nodo es descendiente directo de otro,
llamado antecesor directo si se puede acceder a el recorriendo unicamente una rama.

Raz: La raiz de un arbol es aquel nodo que no tiene antecesores, es decir, todos son
descendientes directos o indirectos de el.

Nivel, profundidad, altura, longitud o longitud de camino de un nodo: Es el
numero de ramas que hay que recorrer para llegar a el desde la raiz, tendiendo en cuenta
que la raiz tiene nivel uno.

Nodo terminal u hoja: Es aquel que tiene grado cero, es decir, que no tiene ningun
descendiente.

10.4.Propiedades de los rboles

1.- Dados dos nodos cualesquiera de un arbol existe exactamente un camino que los
conecta. Cualquier nodo puede ser la raiz ya que dado cualquier nodo de un arbol
existe exactamente un camino que lo conecta con cualquier otro nodo del arbol.
2.- Un arbol con N nodos tiene N-1 aristas
esto es ya que cada nodo tiene un unico padre y toda arista conecta a un nodo con su
padre.
3.- Un arbol binario con N nodos internos tiene N1 nodos Externos.
Esta propiedad se veriIica para N0 N~0 , cualquier arbol binario con N nodos internos
tienen K nodos internos en el subarbol de la izquierda y N-1-K nodos internos en el
subarbol de la derecha para K entre 0 y N-1 , ya que la raiz es un nodo interno.

4.- La Longitud del camino externo de cualquier arbol binario con N nodos internos es 2N
mayor que la longitud del camino interno.

5.- La altura de un arbol binario lleno con N nodos internos es aproximadamente
log
2
N
si la altura es N se debe tener

2
n-1
N1 2
n

Arboles
74

10. 5. Recorridos en un rbol binario

Existen 3 Iormas de visitar los nodos de un arbol binario.
El pre-orden, in-orden y pos-orden.

Recorrido pre-orden.-

Procesar el elemento del nodo raiz.
Recorrer el subarbol izquierdo en pre-orden.
Recorrer el subarbol derecho en pre-orden.

Recorrido in-orden.-

Recorrer el aubarbol izquierdo en in-orden, luego procesar el elemento del nodo raiz.
Recorrer el subarbol derecho en in-orden.

Recorrido pos-orden.-

Recorrer el subarbol izquierdo en pos-orden.

Recorrer el subarbol derecho en pos-orden.
Procesar el elemento del nodo raiz.

Pre-orden : 20 - 12 - 5 - 2 - 7 - 13 - 15 - 40 - 30 - 35 - 47
In-orden : 2 - 5 - 7 - 12 - 13 - 15 - 20 - 30 - 35 - 40 - 47
Pos-orden : 2 - 7 - 5 - 15 - 13 - 12 - 35 - 30 - 47 - 40 - 20

Arboles
75

Recorrer pre-orden, in-orden y pos-orden.

Pre-orden : BCAGDEFH
In-orden : AGCBEFDH
Pos-orden : GACFEHDB

10. 6. rboles binarios de bsqueda

Un ABB, es un arbol binario de busqueda , es aquel que dado un nodo, todos los datos del
subarbol izquierdo son menores que los datos de ese nodo, mientras que todos los datos del
subarbol derecho son mayores que los datos del nodo.

Los arboles binarios se utilizan Irecuentemente para representar conjuntos de datos cuyos
elementos se identiIican por una clave unica. Si el arbol esta organizado de tal manera que la
clave de cada nodo es mayor que todas las claves su subarbol izquierdo, y menor que todas las
claves del subarbol derecho se dice que este arbol es un arbol binario de busqueda.

B
C D
A
G
E H
F
Arboles
Arboles
76

Un ABB se crea a partir de una secuencia cualquiera de elementos por ejemplo:

50 30 80 70 90 40 20 10

Pre-orden : 50 30 20 10 40 80 70 90
In-orden : 10 20 30 40 50 70 80 90
Pos-orden : 10 20 40 30 70 90 80 50

Observar cuando se realiza el recorrido in-orden los elementos del arbol binario de busqueda se
encuentran ordenados de menor a mayor.

Es decir, cuando necesitemos manejar los elementos ordenados una alternativa muy importante
es el de poder utilizar un ABB.

Hay que tener en cuenta que en un arbol binario de busqueda, la rama elegida en un nodo
depende del resultado de una comparacion de la clave buscada y de la clave almacenada en el
nodo. Si la clave buscada es menor que la clave almacenada, se elige la rama de la izquierda; si
es mayor, se sigue por la rama de la derecha.
Algunos ejemplos de arboles BB.

50
0
30 80
20
10
70 90 40
77

10. 7. Representacin interna de un ABB

Al igual que las listas encadenadas utilizaremos un nodo cabecera para representar el arbol BB,
el cual contendra un puntero que apunta a la raiz del arbol utilizaremos tambien una clase para
representar un nodo del ABB.

class Arbol{

private:

Nodo *raiz;
public:

Arbol(void) {raiz=NULL;}
void Insertar( tipoElem );
void Preorden( void );
void Inorden( void );
void Posorden( void );

};

class Nodo{

private:

Nodo *izq;
tipoElem elem;

Nodo *der;

public:
Nodo( tipoElem x )

elem =x;
izq=der=NULL;
}
};

Arboles
78

10. 8. Inserciones en un ABB

void Arbol::Insertar( tipoElem x )
{
raiz = Insertar ( x, raiz );
}

Nodo *Arbol ::Insertar( tipoElem x, Nodo *q )
{
if( q = = NULL )
{
Nodo *q = CrearNodo( x );
retun ( q );
}

if( x = = qElem() )
return ( q );

if( x < qElem() )
qIzq( Insertar ( x, qIzq() ) );

else
qDer( Insertar ( x, qDer() ) );

return ( q );
}

Insertar Nodo Recursivo

Al igual que los recorridos de preorden ,Inorden ,posorden utilizaremos una mascara o
envoltura para deIinir una Iuncion recursiva.

void Arbol:: Insertar( tipoElem x)
{
raiz = Insertar ( x, raiz )
}

Nodo* Arbol:: Insertar (tipoElem x, Nodo*q )
{

if ( q = = NULL)
{

Nodo* q = CrearNodo (x);
return (q);
}
if (x= = q->elem ( ) )
{
return (q );

Arboles
79

}
if (x<q -> elem ( ) )
{
q-> Izq (Insertar (x, q->Izq ( ) );
else
q->Der ( Insertar (x;q->Der ( ) );
return ( q ) ;
}

}

Hacer un metodo logico buscar x metodo que devuelve verdadero si x se encuentra en ABB.

Boolean Arbol:: Se_Encuentra ( tipoelem x )
{
Nodo* p = raiz;
while (p! = NULL && p->elem ()!= x )
{
if ( p->elem ( ) > x )
p= p->Izq ( );
else
p= p ->Der ( ) ;
}

return ( false );

}

Boolean Arbol :: Se _encuentra ( tipoelem x, Nodo * p ) // Recursivo
{
if ( p = = NULL )
return ( false );
if ( p->elem ( ) = = x )
return ( true );
if (p->elem ( ) >x )
return ( se_encuentra ( x , p->Izq ( ) );
else
return ( Se_encuentra (x , p->Der ( ) );

}

10
20
30 40
50

Arboles
80

Recorrido por niveles

Para realizar recorrido por niveles se debe utilizar una cola que contenga las direcciones de
memoria de los nodos.
Este algoritmo se aplica sobre ABB y o cualquier otro tipo de arbol binario

Ejemplo

10.9 Aplicaciones de los rboles

Evaluacin de expresiones

Una aplicacion muy util de los arboles es en la evaluacion de expresiones, en este caso
evaluacion de expresiones aritmeticas, una expresion aritmetica esta Iormada por operando y
operadores aritmeticos, asi la expresion :

E ( x y )* z x * y / z

E, esta escrita en Iorma habitual, el operador en medio de los operando, esto se conoce como
notacion inIija.

Notacin postfija: ( notacin polaca)

Ya que el uso de la notacion inIija muchas veces lleva a una equivocada interpretacion de las
expresiones y obliga a utilizar parentesis, es que es necesario utilizar otra clase de notacion, la
postIija.

C
B
H
A
D
G E
F
Arboles
81

Por ejemplo:

a*b/(ac) (inIija) a*b/ac *abac (postIija)

una vez que se tiene la expresion en postIija, se Iorma el arbol correspondiente, primero se
crean dos nodos del arbol con sus respectivos operando que se enlazan como una rama izquierda
y rama derecha del nodo operador. Por ejemplo:

Expr a*b-c*dh (inIija)

TransIormando la expresion en postIija:

Expr ab*cd*-h se tiene el arbol:

h
*
a
*
b c d
Arboles
82


Sedgewick- Robert ' Algoritmos en C
Fuente bastante interesante en el tema de algoritmos de toda clase que se pueden implementar en
el lenguaje C, es una libro muy util en estructuras.

rboles : Referencias
83

Captulo 11

1ipo Abstracto de datos

Sinopsis

11.1 DeIinicion de TDA
11.2 Caracteristicas de tipos abstracto de dato
11.3 ClasiIicacion
11.4 Implementacion
11.5 Componentes de un tipo de dato abstracto

Algunos lenguajes de programacion tienen caracteristicas que
nos permiten ampliar el lenguaje aadiendo sus propios tipos de
datos.
Un tipo de dato deIinido por el programador se denomina tipo
abstracto de datos para diIerenciarlo del tipo Iundamental de
datos.

84

11.1.- Definicin de Tipo Abstracto de dato (TDA )

Es un modelo (estructura ) con un numero de operaciones que aIectan a ese modelo es un tipo
deIinido por el usuario tiene un conjunto de valores y un conjunto de operaciones cumple con
los principios de abstraccion y ocultacion de la inIormacion y se puede manejar sin conocer la
representacion interna.

Un TAD es una estructura algebraica, o sea, un conjunto de objetos con ciertas operaciones
deIinidas sobre ellos. Piense, por ejemplo, en la calculadora: los elementos que maneja son
cantidades numericas y las operaciones que tiene deIinidas sobre estas son las operaciones
aritmeticas. Otro ejemplo posible es el TAD matriz; los elementos que maneja son las matrices y
las operaciones son aquellas que nos permiten crearlas, sumarlas, invertirlas, etc.

Al hablar de ADTs se dice que se usa Abstraccion de Datos porque al deIinir un ADT el
programador especiIica cuales son las estructuras de datos que su programa utiliza. Se dice que
se usa Encapsulamiento de Datos porque junto al tipo de datos tambien se deIinen las rutinas que
permitiran utilizarlo. Por medio del Ocultamiento de Datos se evita que un programador-usuario
del Tipo de Datos Abstracto cambie de Iorma impropia el valor de una variable.

11.2.- Caractersticas de los Tipos Abstractos de datos

La caracteristica generica de un tipo de dato abstracto es que nada que sea externo a la
deIinicion de las estructuras de datos y los algoritmos que operan sobre ellas debe hacer
reIerencia a cualquier cosa interna, excepto a traves de llamadas a Iunciones y procedimientos

De las operaciones Iundamentales.
El motivo Iundamental para el desarrollo de TDA ha sido establecer un mecanismo para la
organizacion de grandes programas.

Los tipos de TDA proporcionan una manera de limitar el tamao y la complejidad de la interIaz
entre algoritmos, las estructuras asociadas y los programas que utilizan los algoritmos y las
estructuras de datos ,esto hace mas Iacil comprender los grandes programas y mas conveniente
los cambios o mejoras de los algoritmos Iundamentales.

11.3.- Clasificacin

Hay operaciones que nos sirven para crear nuevos objetos abstractos, otras para obtener
inIormacion acerca de ellos, y algunas para construir nuevos elementos a partir de otros ya
existentes. De esta Iorma las operaciones las podemos clasiIicar de esta manera:

Tipo Abstracto de datos
TDA Representacion ( Datos ) Operaciones ( Funciones y Procedimientos)
85

Operaciones para crear objetos
Iniciales. Se utilizan para crear objetos del TAD, en cuya creacion no se requieren
ningunos objetos abstractos del mismo tipo.
Constructores. Utilizadas para crear objetos del TAD cuya creacion depende de objetos
del mismo tipo.

Operaciones para transformar objetos de TAD

Simplificadoras. Son operaciones cuyo codominio es el TAD que se deIine, pero que
dan como resultado objetos que pueden ser descritos utilizando unicamente operaciones
iniciales y constructoras.

Operaciones para analizar los elementos del TAD

Anali:adoras. Son operaciones cuyo codominio no es el TAD que se deIine, sino otro ya
conocido. El proposito de este tipo de operaciones es obtener inIormacion concerniente
a cualquiera de los objetos abstractos de tipo.

Las operaciones simpliIicadoras y analizadoras inducen una nocion de equivalencia entre los
elementos de TAD que se deIine; si dos objetos abstractos son indistinguibles mediante
operaciones simpliIicadoras y analizadoras, el observador deberia concluir que se trata del
mismo objeto.

11.4.- Implementacin

Cuando ya se tiene bien diseado un Tipo Abstracto, el siguiente paso es decidir una
implementacion para el mismo. Esto implica escoger unas estructuras de datos para representar
cada uno de los objetos abstractos y escribir una rutina(Procedimiento o Iuncion) en un lenguaje
de programacion, que simule el Iuncionamiento de cada una de las operaciones de acuerdo con
su especiIicacion. La seleccion de las estructuras de datos determina, en muchos casos, la
complejidad del algoritmo que implementa una operacion y es, por esta razon, de gran
importancia su escogencia. Existen estructuras de datos muy dependientes de un lenguaje de
programacion y debido a esto deben trata de evitarse cuando el TAD se quiere hacer portable.

11. 5. Componentes de un Tipo de Dato abstracto

Se tiene que tomar en cuenta que el TAD es observado desde 2 puntos de vistas o escenarios:

- la vision del usuario del TAD
- la vision del implementador del TAD

para el usuario el TAD le oIrece un tipo y una interIase de operaciones para manipularlo.
Para el implementador se plantean 2 problemas

86

1 representar el tipo (estructura )
2 escribir la implementacion de las operaciones

En C provee automaticamente un constructor para cada clase, sin embargo este constructor
no realiza accion alguna, por ello vamos a implementar explicitamente este constructor.

Ejemplo

class complejo
{
float pr,pi ;

public:
complejo ( float a, float b ); // constructor
void set parteReal ( float a );

};

complejo:: complejo ( float a , float b )
{
pr= a;
pi = b;
}

87

principiantes en C.


Tipo Abstracto de datos : Referencias
88

Captulo 12

Crafos

Sinopsis

12. 1. DeIinicion de GraIo.
12. 2. Representacion interna de un graIo.
12. 3. Tipos de graIos.
12. 4. Navegar sobre los nodos de un graIo
12. 5. Caso de navegar sobre un arbol general.
12. 6. Recorridos sobre un graIo.
12. 7. La clase GraIo.
12. 8. Aplicaciones de graIos.
12. 9. Algoritmo de coloreado de graIos.

Este capitulo introduce al lector a conceptos matematicos
llamados graIos. Los graIos tienen aplicaciones en diversos
campos como sociologia, quimica..etc
Los graIos se estudian como ED, o tipos abstractos de datos.
En este capitulo se estudiaran los algoritmos mas comunes para
procesar graIos.

89

12. 1. Definicin de Grafo.

Un graIo G se describe como un conjunto de nodos y un conjunto de arcos o aristas que
relacionan pares de nodos :
Se denota por:

G( N, A )

Donde:

N n1, n2, ......n
m
} , conjunto de nodos
A ( ni, nj), ( np, nq ), .......}, conjunto de aristas

( ni, nj ): signiIica que existe un arco o arista entre los nodos ni, nj.

Los arcos y/o aristas de un graIo pueden tener o no etiquetas.

12. 2. Representacin interna de un grafo.

Existen dos Iormas de mantener un graIo 'G en la memoria de una computadora, una se llama
Representacion secuencial de G, la cual se basa en la matriz de adyacencia A; la otra Iorma, es la
llamada Representacion enlazada de G y se basa en listas enlazadas.

Independientemente de la Iorma en que se mantenga un graIo G en la memoria de una
computadora, el graIo G normalmente se introduce en la computadora por su deIinicion Iormal:
Un conjunto de nodos y un conjunto de aristas

ni nj
ni nj
e1, e2,.........
Grafos
90

Representacion secuencial de un graIo:

y supongase que los nodos se mantienen en memoria en un array DATOS tal como sigue:

DATOS: X, Y, Z, W
La matriz de adyacencia A de G seria la siguiente:

Representacion enlazada de un graIo:

Un graIo 'G se guarda en memoria como sigue:

Grafos
91

12. 3. Tipos de grafos

Grafos Dirigidos.- Los vertices apuntan unos a otros, los arcos estan dirigidos o tienen
Direccion unica.
Grafos No Dirigidos.- Los vertices estan relacionados o tienen direccion.
Grafo Isomorfo .-Dos GraIos son IsomorIos si existe una correspondencia biunivoca entre
sus vertices tal que dos vertices quedan unidos por una arista en uno de los graIos, si y solo
si, los vertices correspondientes del otro graIo quedan unidos por una arista.
Grafo Plano .-Se dice que un GraIo es Plano, si y solo si, existe una representacion plana
del mismo, es decir, las curvas que representan las aristas se cortan solo en los puntos que
representan a los vertices. (No hay cruces).
Grafo Conectado. Existe siempre un camino que une dos vertices cualquiera.
Grafo Desconectado Existen vertices que no estan unidos por un camino.
Grafo Completo.- Es aquel que cada nodo esta conectado con todos y cada uno de los
restantes nodos.

Grafos
92

grafo sencillo

Un graIo se denomina sencillo si cumple las siguientes condiciones:

1.- No tiene bucles o lazos, es decir no existe un arco de la Iorma (A, A)
2.- No existe mas que un arco para unir dos nodos
En la Iigura se representa un GraIo sencillo.

Grafos bipartidos

Son los graIos en los que todas las aristas enlazan dos conjuntos de nodos, los nodos
se dividen en dos conjuntos y ninguna arista conecta dos nodos del mismo conjunto.
En su representacion por matriz se puede obtener una ganancia obvia al incluir
solamente Iilas en un conjunto y en otro solo columnas.
La representacion en listas parece que no tiene ventajas por si misma, excepto nombrar
cuidadosamente los vertices porque asi es Iacil decir a que conjunto de vertices
pertenece cada uno.

B
C
D
A
Grafo Bipartido
1
2 3
A B
C
Grafos
93

12. 4. Navegar sobre los nodos de un grafo

Para navegar sobre una lista visitamos solo 1 vez los nodos de la lista , tienen 1 sola direccion:

(Navegacion lineal: existe un solo camino)

para navegar sobre un arbol binario el proceso es diIerente, para este caso existe la necesidad de
volver hacia atras y seguir navegando el arbol.

(Navegacion con vuelta hacia atras: existen multiples caminos)

Cuando realizamos el recorrido de pre-orden, in-orden y post.orden llamamos recursivamente al
procedimiento 2 veces en el codigo de programa, para recorrer todos los caminos posibles.

12. 5. Caso de navegar sobre un rbol general.

Grafos
94

Asumiendo que en un arbol general en nodo tiene n-hijos, de que manera se podria navegar este
arbol ??

Esta Iorma de recorrido sobre arboles generales tiene una particularidad a medida que se va
navegando en el camino actual de recorrido todos los nodos son diIerentes, en ningun caso van a
existir en el camino actual de recorrido nodos iguales( porque un arbol general es un graIo
aciclico).

Analizando el recorrido sobre un graIo, durante el recorrido en el camino actual de recorrido se
puede volver a visitar un nodo.

12. 6. Recorridos sobre un grafo.

Existen diIerentes Iormas de navegar un graIo dirigido como
ser.

Por ProIundidad ( Pre Orden o Post Orden )
Por Amplitud ( Niveles )

a) Recorrido en anchura(Amplitud ): Este metodo comienza visitando el vertice de partida A
para a continuacion visitar los adyacentes que no estuvieran ya visitados. Asi sucesivamente
con los adyacentes. Este metodo utiliza una cola como estructura auxiliar en la que se
mantienen los vertices que se vayan a procesar posterior mente.
Para realizar este tipo de recorrido se deben de seguir las siguientes reglas:

1. Visitar el vertice de partida.
2. Meter en la cola el vertice de partida y marcarlo como procesado.
3. Repetir los pasos 4 y 5 hasta que la cola este vacia.
4. Retirar el nodo Irente (W ) de la cola, visitar W.
5. Meter en la cola todos los vertices adyacentes a W que no esten procesados y marcarlos
como procesados.

b) Recorrido en profundidad: El recorrido en proIundidad persigue el mismo objetivo que el
recorrido en anchura: visitar todos los vertices del graIo alcanzable desde un vertice dado.
La busqueda en proIundidad empieza por un vertice J del graIo G. J se marca como
visitado, despues se recorre en proIundidad cada vertice adyacente a J no visitado ; asi
hasta que no haya mas vertices adyacentes no visitados. Esta tecnica se denomina en
proIundidad.

La deIinicion recursiva del recorrido en proIundidad ya nos indica que tenemos que realizar una
pila como estructura para guardar los vertices adyacentes no visitados a uno dado.
Grafos
95

De igual Iorma que en el recorrido de anchura hacemos uso de una lista de vertices para
controlar los ya visitados.

12. 7. La clase Grafo.

La clase graIo esta deIinida por dos subclases, la clase nodo y la clase arco, deIinidas a
continuacion:

class Nodo
{
private:
Nodo *prox;
char nombre;
Arco *primero;
public:

};

class Arco
{
private:
Nodo *ptrNodo;
int costo;
Arco *prox;
public:

};

class Grafo
{
private:
Nodo *primero;
public:

};

Grafos
96

12. 8. Aplicaciones de grafos.

El semforo
Dada una interseccion de n calles. Cada calle es de 1 o 2 vias.
Disear un semaIoro que utilice la menor cantidad de colores tales que cuando el semaIoro se
encuentra en una color circulen vehiculos por las vias simultaneamente y que no exista colision.

Vias posibles

AE, AB
CB, CA, CE
DE, DA, DB
EA, EB

15. 9. Algoritmo de coloreado de grafos.

Existen muchas teorias sobre coloreado de graIos, aplicables al problema del semaIoro, se puede
buscar una solucion buena a este problema pero no necesariamente optima:

Uno de los muchos algoritmos de coloreado de graIos es el siguiente:
A
B
E
D
C
AE
EB
CA DA
DB CE DE
Grafos
97

Primero se intenta colorear tantos vertices como sea posible con el primer color, luego todos los
vertices que sea posibles con el segundo color, y asi sucesivamente. Para dar a los vertices un
color se procede:

1. Seleccionar un vertice no coloreado y se le asigna un nuevo color.
2. Examinar la lista de vertices no coloreados. Para cada uno de ellos se determina si existe
alguna arista que lo una con un vertice que ya este coloreado, si no existe, se le asigna un
nuevo color al vertice.

Grafos
98



Pginas Web


Grafos : Referencias
99

CASO DE ESTUDIO

PROYECTO EL 1UEGO DE LA
VIDA

100

EL 1UEGO DE LA VIDA

Vida Artificial

...es el campo de estudio dedicado a la comprension de la vida, intentando abstraer los
principios dinamicos fundamentales que subvacen a los fenomenos biologicos v recreando esas
dinamicas en otros medios fisicos - como ordenadores - haciendolos accesibles a nuevos tipos
de manipulacion experimental v de pruebas. Chris Langton
`` La Biologia estudia la ``vida'' aunque en la practica solo se estudia los seres vivos de la Tierra
que estan basados en la quimica del Carbono. En principio no hay que impidiera la existencia de
otras Iormas de vida basadas en otros elementos. La Biologia teorica se encuentra en la
diIicultad de que es imposible deducir principios generales a partir de ejemplos simples ya que
no tenemos otros seres ``vivos'' con los que compararnos. Cuales son las caracteristicas
Iundamentales de los seres vivos y cuales son accesorias?. Para obtener alguna teoria general
sobre la vida necesitamos un conjunto de seres vivos sobre las que podremos hacer alguna
generalizacion.
Como es poco probable que se nos presente algun marciano para que lo estudiemos ( a no ser
que Scully y Mudler sean capaces de demostrar que la CIA tiene ADN alienigena ), nuestra
unica opcion consiste en crear Iormas de vida alternativas. La ``Vida ArtiIicial'' ( AliIe, en ingles
) es una disciplina que estudia la ``vida natural'' recreando los Ienomenos biologicos en
ordenadores y otros medios artiIiciales. AliIe complementa el estudio teorico de la biologia pero
en lugar de tomar organismos aislados y analizar su comportamiento lo que se intenta es colocar
juntos organismos que actuan como los seres vivos.
La Vida ArtiIicial es una ``biologia sintetica'' en analogia con las sintesis quimicas. El intento
por recrear Ienomenos biologicos en un medio alternativo nos llevara a una mejor comprension
de los procesos biologicos asi como a la implementacion de los principios biologicos en
aplicaciones practicas como en el diseo de ordenadores ( hardware y soItware ), robots moviles,
medicina, etc. Extendiendo los horizontes de la investigacion empirica de la Biologia mas alla
del territorio de la vida-como-la-conocemos, la Vida ArtiIicial nos da acceso al dominio de la
vida-como-deberia-ser y es en este dominio en el que podremos construir teorias generales a
cerca de la Biologia y en el que descubriremos aplicaciones practicas y utiles de las herramientas
de los seres vivos en la resolucion de problemas.''
( Texto adaptado de Chris Langton ).
Algunos problemas que intentan abordar los estudiosos de la ``Vida ArtiIicial'' son:
La deIinicion de ``vida'' y de sistema vivo. Vida y computacion.
Sistemas autoorganizados. Autoreplicacion.
Aprendizaje evolutivo. Tecnicas de optimizacion. Algoritmos geneticos.

101

Adaptacion. Dinamica de los Sistemas Complejos.

En Septiembre de 1987 se celebro en Los Alamos (NM) el primer congreso sobre vida artiIicial
y de el podemos extraer algunas de las conclusiones Iundamentales.
AliIe es la Biologia de lo posible: La Biologia que conocemos es la biologia de la vida
actual en la Tierra que esta basada en la Quimica del Carbono. La vida artiIicial se
ocupa de todas las Iormas de vida posible, de como podria ser la vida.
Sintesis: AliIe intenta sintetizar los procesos vitales al contrario que la Biologia clasica
que ha puesto el enIasis en el analisis de los seres vivos.
Vida Real-ArtiIicial: En AliIe tenemos unas ``criaturas'' que se comportan como los
seres vivos que conocemos. Lo que hay de artiIicial en ellos son los componentes de los
que se construyen ( los chips de silicio, programas de ordenador y cosas por el estilo )
pero su conducta es identica a la del resto de los organismos vivos.
La Iorma: La Vida es un proceso y es la Iorma de este proceso y no la materia lo que
constituye la esencia de la vida. Se puede abstraer lo material y mostrar la logica que
gobierna el proceso.
Al igual que en todos los sistemas complejos, la construccion de sistemas en los que se pone de
maniIiesto vida artiIicial se hace siguiendo tres pautas:
Se parte de unidades simples con interaccion local.
Procesamiento en paralelo.
Aparicion de comportamientos emergentes.

INTRODUCCIN AL 1UEGO DE LA VIDA

En 1970, John Comway publico su libro "The Game oI LiIe". El creo el Juego de laVida como
una Iorma de representar un sistema biologico. Utilizo una matriz bidimensional booleana (Es
decir, una cuadricula en la que en cada cuadro suyo solo podia haber dos estados: verdadero y
Ialso). Si una posicion de la matriz era verdadera, esta se consideraba como una "celula", y si era
Ialsa, como un espacio vacio. Utilizo simples reglas para el juego: si alrededor de una celula (de
sus ocho vecindades) habia menos de dos celulas, esta moria. Si tenia mas de tres, tambien
moria, al haber una sobrepoblacion de celulas. Ahora bien, si alrededor de un cuadro vacio habia
tres celulas, en el espacio vacio nacia una nueva celula. A esto se le llamo reproduccion
trisomica. Al proponer estas simples reglas, no creo que se imaginara que se iban a desarrollar
"organismos" tan sorprendentes como los que se desarrollaron.

Creemos que es necesario aclarar que este proyecto no es un juego
como cualquier otro, en realidad es una simulacion de la teoria
celular de conways.
102

Reglas del juego de la vida

La estructura del juego que en realidad es una simulacion, no un juego con personas
Es una rejilla rectangular abierta, en la cual cada celdilla puede estar ocupada o no por un
microorganismo. las celdillas vivas cambian de una generacion a otra, segun el numero de
celdillas vecinas que estan vivas, en la siguiente:

1. Los vecinos de una celda son los ocho que la tocan vertical, horizontal o
diagonalmente.

2. Si una celdilla esta viva pero no tiene celdillas vecinas vivas o solamente una viva,
muere de soledad en la siguiente generacion.

3. Si una celdilla esta viva y tiene cuatro o mas vecinas tambien vivas, en la siguiente
generacion muere por hacinamiento.

4. Una celdilla viva con dos o tres vecinas permanece viva en la siguiente generacion.

5. Si una celdilla esta muerta , en la siguiente generacion recuperara la vida si tiene
exactamente tres vecinas, ni una mas ni una menos, que ya esten vivas. Todas las
otras celdillas muertas permanecen asi en la siguiente generacion

6. Todos los nacimientos y muertes tienen lugar exactamente al mismo tiempo, de
manera que las que mueren ayudan a producir otras ; pero no pueden impedir la
muerte de otras reduciendo el hacinamiento , ni las que nacen pueden preservar o
destruir a las que tienen vida en la generacion.

El juego de la vida se trata de uno de los primeros automatas celulares construidos y es sin lugar
a dudas el mas conocido y estudiado de todos ellos. Se trata de un automata celular binario (i.e
las celulas toman solo los valores 0 o muerta y 1 o viva), bidimensional con entornos de Moore.
La actualizacion de la celula central puede realizarse mediante muchas Iamilias de reglas; la
cantidad de variantes que se ha introducido es muy extensa.

El juego de la vida clasico se trata de las reglas originales introducidas por John Horton Comway
en ScientiIic American en octubre de 1970. La idea consiste en modelar una situacion en la cual
ocurrieran las siguientes condiciones:

No debe existir ninguna conIiguracion inicial a partir de la cual se pueda probar de
modo simple que la poblacion crece sin control.
Deben existir conIiguraciones iniciales que aparentemente provoquen un crecimiento
descontrolado.
Deben existir conIiguraciones iniciales simples que crecen y cambian durante un
periodo considerable de tiempo para llegar a uno de los siguientes estados:

103

i. Desaparicion completa (por superpoblacion).
ii. Situacion estacionaria.
iii. ConIiguracion ciclica estable Iormada por dos o mas estados que se van repitiendo.

Algunas iteraciones celulares:

Las estructuras clasicas del juego de la vida son:

Blinkers: Estructura oscilante con dos periodos.

104

Glider: Se trata de una estructura que sigue un ciclo, moviendose una celda diagonalmente cada
vez que lo completa.

Spaceship: Un numero Iinito de celdas que despues de varias generaciones vuelve a aparecer
con identica conIiguracion en otro punto de la pantalla. Esto causa el eIecto a ojos del espectador
de una nave que se mueve, de ahi el nombre

Glider gun: Se trata de una estructura oscilante que emite Gliders periodicamente. El
descubrimiento de la Glider gun probo la Ialsedad de una de las conjeturas basicas de conway,
que ninguna poblacion Iinita podria crecer sin limite.

105

ESTRUCTURA DE DATOS

La estructura Iundamental usada es una lista simple encadenada.

Se uso dos clases

Clase Nodo
Clase Celda

Cada Nodo representa una celula viva

Los procedimientos Iundamentales de esta implementacion son 'void SumarVivas(), este
procedimiento suma los vecino que tiene la celulas vivas;

El procedimiento 'SumasMuertas() VeriIica si existe celulas muertas que cumpla con la
condicion de sobrevivencia para luego insertar en la lista de celulas vivas;

El procedimiento 'vivir.vivificar() Elimina los elementos de la lista viva a todos los elementos
que no cumpla con las condiciones de sobrevivencia en la proxima generacion.

106

REPRESENTACIN GRFICA

CONSIDERACIONES DE ESPACIO EN LA MEMORIA

Podriamos llevar el control de todas las celdas hasta que la memoria se llene, y luego eliminar
aquellas que no sean necesaria. Pero esto requeriria recalculo de direccion del arreglo completo,
lo cual seria lento y penoso, con encadenamiento podemos Iacilmente deshacernos de celdas
(celulas vivas) tan pronto como sean necesarias, y asi reducir en lo posible el numero de celdas,
claro que obviamente, va ha llegar a una etapa que se llenara la memoria.

107

Libros

|Kruse- Robert| 'Estructura de datos y Diseo de programas

Pginas

http://www.unet.univie.ac.at/~a9521349/java/documentacion.html
Juego de la vida

http://www.google.complex.us.es/~jimenez/CA/ac/node19.html
Teoria de la vida artiIicial

Personas

Roy Ramos (Universidad Catlica Boliviana)

Bibliografa del proyecto ~El juego de la vida
108

BIBLIOGRAFIA

|Cevallos- Javier| 'Curso de programacion con C '
Editorial Ra-Ma/ Madrid 1991

|Deitel/Deitel | 'Como programar en C/ C '
Editorial Prentice Hall hispanoamericana
2 Edicion.

|Joyanes98| 'Programacion Orientada a Obfetos`
Editorial Mc-Graw-Hill
2 Edicion, 1998

|Joyanes94| 'C a su alcance, un enfoque OO`
1994

|Joyanes99| 'Estructura de datos, algoritmos abstraccion v obfetos`
1999

|Joyanes96| 'Fundamentos de programacion, algoritmos v ED`
1996

|Kruse- Robert| 'Estructura de datos v Diseo de programas

|Tenenbaum/Langsan
/Moche A.aug. | ' Estructura de Datos en C`

|Ullman | ' Estructura de datos`

Apuntes Estructuras2009

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Apuntes Estructuras2009

Cargado por

Copyright:

Formatos disponibles

UNIVERSIDAD AUTONOMA GABRIEL RENE MORENO

FACULTAD DE CIENCIAS EXACTAS Y TECNOLOGIA

También podría gustarte