Documentos de Académico
Documentos de Profesional
Documentos de Cultura
POPAYAN
Enero de 2012
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
INDICE DE CONTENIDO
Lección 4: Análisis del código propuesto para implementar una pila ................. 70
Lección 10: Aplicación de una cola en un entorno real planificador de citas ..... 93
LISTADO DE TABLAS
Tabla 1………………………………………………………………………………….30
Tabla 2………………………………………………………………………………….31
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Figura 51 Interfaz gráfica del compilador Borland C++ 5.5. ................................ 138
Figura 74 Árbol binario como aplicación a los tres recorridos ............................. 154
Figura 75 Borrado de un nodo rama con intercambio de nodo hoja .................... 157
Figura 77 Borrado de un nodo rama con intercambio de nodo rama .................. 158
Figura 78 Intercambio de un nodo rama con intercambio de nodo rama ............ 159
La versión uno del presente módulo fue diseñado en el año 2004 por el Ing.
Iván Arturo López, docente de la UNAD, ubicado en el CEAD de Popayán, el Ing.
López es Ingeniero de Sistemas, Especialista en Pedagogía Para el Desarrollo del
Aprendizaje Autónomo y Magister en Educación y TIC’s, se ha desempeñado
como Tutor y Docente de la UNAD desde el año 2000.
La versión dos del presente módulo fue desarrollada por el Ing. Hermes
Mosquera Angulo en el año 2007, quien ha sido Tutor de la UNAD en el CEAD
Popayán, desde el año 2006, se desempeña actualmente como Director del cuso
a nivel nacional desde el año 2007.
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
INTRODUCCIÓN
UNIDAD 1
12
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
13
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
14
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
CAPITULO 1: APUNTADORES
Introducción
Tambien son utiles para pasarle parametros a las funciones de tal modo que les
permiten modificar y regresar valores a la rutina o función que hace el llamado.
Cuando se utilizan incorrectamente, pueden producir algunos problemas de
esrtabilidad en el sistema o también pueden presentar fallas en el programa en
ejecución.
Definición de Apuntadores
objeto: un char, un int, un float, un array, una estructura, una función u otro
puntero. Serán los programadores los responsables de decidir ese contenido.
Declaración de apuntadores
Ejemplo: int *apunt; se declara el apuntador apunt de tipo entero. Se dice que:
"apunt va a apuntar a variables de tipo int" donde apunt es el nombre del
apuntador y (*) es el operador de indirección que indica que apunt es un
apuntador.
Ejemplos:
16
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Progra1.cpp
#include <iostream.h>
#include <conio.h>
void main(void)
{
int x, y; //Define x, y variables enteras.
int *p, *q; //Define p y q variables tipo apuntador.
p = &x; //asigna a p la dirección de x. (p apunta a x).
q = &y; //asigna a q la dirección de y. (q apunta a y).
*p = 10; //almacena en x el valor 10.
*q = *p * 2; //almacena en y el valor de x multiplicado por 2 (20).
y = y + *p; //a la variable y le suma el valor en x (20+10).
cout<<”El contenido de X es:” <<*p <\n; //imprime el contenido de x (10).
cout<<,”El contenido de Y es:” <<*q; //imprime el contenido de y (30).
getch();
}
17
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Progra2.cpp
#include <iostream.h>
#include <conio.h>
void main()
{
int automatica ;
int *apunt ;
automatica = 100 ;
apunt = &automatica ;
clrscr();
cout << "VALOR=" << automatica << " \n";
*apunt= 200 ;
cout << "VALOR=" << automatica << " \n";
getch();
}
Análisis de Progr2.cpp
En la línea 3, se define la función principal main() de tipo void, lo que indica que no
retorna ningún valor.
18
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
En la línea 11, se asigna el valor 200 al objeto apuntado por apunt. Es decir a la
variable automática.
Un apuntador es una variable que solo puede contener un valor a la vez, por lo
que solo puede apuntar a un objeto al mismo tiempo.
Por otro lado, una variable cualquiera puede ser apuntada (referenciada) por
varios apuntadores, ya que su dirección de memoria puede ser almacenada en
distintas variables a la vez.
19
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Progra3.cpp
#include <iostream.h>
#include <conio.h>
void main()
{
int entero=1 ;
float decimal=1.1 ;
void *apvarios=&entero;
// apvarios APUNTA A entero *(int *)apvarios="1"
// ASIGNA 1 AL OBJETO APUNTADO POR apvarios
cout << "El valor de entero es: "<<entero<<"\n" ;
apvarios=&decimal ;
// apvarios APUNTA A decimal *(float *)apvarios="1.1"
// ASIGNA 1.1 AL OBJETO APUNTADO POR apvarios
cout << "El valor de decimal es: "<<decimal ;
getch();
}
Análisis de Progra3.cpp
Analicemos la siguiente instrucción:
*(int *)apvarios = 1 ;
En donde:
20
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Una cadena se puede definir como un arreglo de caracteres cuyo último elemento
es el caracter nulo. Utilizando la nomenclatura de arreglos, podemos declarar un
arreglo llamado nombre[ ] de tipo carácter asignándole la frase COMERCIO:
En este caso se define a nombre como un apuntador que apunta a datos de tipo
char, al que se le asigna la frase COMERCIO.
Progra4.cpp
#include <iostream.h>
#include <conio.h>
#include <stdio.h>
void main()
{
char *nombre = "COMERCIO" ;
clrscr();
gotoxy(30,12);
cout<< "!! HOLA, " ;
puts(nombre);
gotoxy(43,12);
cout << " !!";
getch();
}
21
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Arreglos de apuntadores
Progra5.cpp
#include <iostream.h>
#include <conio.h>
#include <string.h>
void main()
{
char *nombres[ ] = { "HUGO", "PACO", "LUIS" } ;
22
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
char invitado[11];
int bandera;
clrscr();
gotoxy(20,5);
cout << "CUAL ES SU NOMBRE ?: " ;
gotoxy(50,10);
cin>> invitado ;
gotoxy(20,7);
for( int x = 0 ; x <3 ; x++ )
if(strcmp(invitado, nombres[x])== 0)
bandera=0;
if(bandera== 0)
cout << "!! SIGA AMIGO ES BIENVENIDO " << invitado << " !!";
else cout << "!! USTED NO ES BIENVENIDO, " << invitado << " !!";
getch();
}
Un arreglo puede pasarse como parámetro a una función. Si tuviera que pasarse
por valor un arreglo muy grande, sería un desperdicio de memoria y que es
función de los programadores optimizar este recurso. En el Lenguaje C++, el paso
23
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Progra6.cpp
#include <iostream.h>
#include <conio.h>
#include <stdio.h>
#include <string.h>
void valor(char *);
void main()
{
char cadena[81];
clrscr();
gotoxy(10,10);
cout << "INGRESE UNA FRASE CORTA: ";
gets(cadena); gotoxy(10,12);
valor(cadena); getch();
}
24
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Progra7.cpp
#include <iostream.h>
#include <conio.h>
#include <stdio.h>
#include <string.h>
Toda función tiene asociada una dirección de inicio de código, la cual puede
pasarse un apuntador como parámetro cuando se llama o se invoca a otra
función. He aquí un ejemplo como aplicación al paso de funciones como
parámetros a funciones.
Progra8.cpp
#include <iostream.h>
#include <string.h>
#include <conio.h>
int cmpcad(char*, char*);
void compara(char*, char*, int(*)(char*, char*));
void main()
{
char cadenax[80], cadenay[80];
clrscr();
gotoxy(10,5);
cout << "ESCRIBA UNA CADENA : " ; cin>> cadenax;
gotoxy(10,7);
cout << "ESCRIBA OTRA CADENA : " ; cin>> cadenay;
gotoxy(10,9);
compara(cadenax, cadenay, cmpcad);
gotoxy(1,24);
}
void compara(char *cadena1, char *cadena2, int (*cmpcad)(char*, char*))
{
if(!(*cmpcad)(cadena1,cadena2))
26
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Explicando la expresión que puede ser un tanto desconocida del listado anterior, la
expresión:
int(*cmpcad)(char*, char*).
Esto puede difundirse para dos o más variables, como se observa en el ejemplo
siguiente de apuntadores a apuntadores.
27
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Progra9.cpp
#include <iostream.h>
#include <conio.h>
void main()
{
int x, *a, **b, ***c ; // 1
clrscr();
a = &x ; // 2
*a = 100 ; // 3
b = &a ; // 4
**b += *a ; // 5
c = &b ; // 6
***c += **b + *a ; // 7
cout << " *a=" << *a << " \n" ;
cout << " **b=" << **b << " \n" ;
cout << "***c=" << ***c << " \n" ;
getch();
}
28
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
q = &a;
p = q; /* se asigna la dirección que contiene q a p */
cout<<p; /* imprime la dirección almacenad en p. */
Progra10.cpp
#include <iostream.h>
#include <conio.h>
int main()
{
clrscr();
int a; //a es un puntero
int * ap; //ap es un apuntador a un puntero
a = 7;
ap= & a; //ap toma la dirección de a
cout <<"la dirección de a es " <<&a;
cout<<" \n el Valor de ap es " << ap;
cout <<"\n el valor de a es" <<a;
cout<<"\n el valor de *ap es " << *ap;
cout<<"\n\n\n Mostrando los valores de * y &" ;
cout <<"\n &* ap = " <<&*ap;
cout <<"\n *& ap = " << *≈
getch();
return 0;
}
29
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Análisis de Progra10.cpp
30
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Introducción
Por otro lado se aborda la temática relacionada con los tipos de varibles, variables
estáticas y dinámicas. Así como también el uso y la aplicabilidad del operador
sizeof en la gestión dinámica de memoria.
Para darse una idea de que tantos bytes se necesitan para guardar determinados
tipos de datos se pone a disposición la tabla 2.1donde se muestran los espacios
requeridos para guardar datos en la memoria del computador.
32
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Progra11.cpp
#include <iostream.h>
#include <conio.h>
int main ()
{
cout<<"TIPOS DE DATOS Y TAMANO EN BITS\n\n";
cout<< "El tamano del tipo de dato int es :"<<sizeof(int)*8<<" bits\n";
cout<< "El tamano del tipo de dato short es :"<<sizeof(short)*8<<" bits\n";
cout<< "El tamano del tipo de dato long es :"<<sizeof(long)*8<<" bits\n";
cout<< "El tamano del tipo de dato char es :"<<sizeof(char)*8<<" bits\n";
cout<< "El tamano del tipo de dato float es :"<<sizeof(float)*8<<" bits\n";
cout<< "El tamano del tipo de dato double es:"<<sizeof(double)*8<<" bits\n";
getch();
return 0;
}
33
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
34
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Dependiendo del uso que se le dé a las variables por parte del programador en
una rutina o tarea específica, se pueden identificar dos tipos de variables, las
variables dinámicas y variables estáticas.
Variables estáticas
Las variables estáticas tal como se recuerda en los inicios de los fundamentos de
programación, son aquellas que el programador les asigna memoria antes de la
ejecución del programa o de una función. Las variables estáticas se llaman
mediante el nombre de la misma, que ha sido declarada por el programador y su
función principal dentro de un programa es almacenar información dependiendo
del tipo de dato con que se haya declarado.
Progra12.cpp
#include <stdio.h>
#include <iostream.h>
#include <stdlib.h>
#include <conio.h>
Análisis de Progra12.cpp
En el código del programa se hace uso de tres variables de tipo entero que son
variables estáticas ellas son: priNumero que se le asigna el valor 136, mientras
35
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Las variables dinámicas deben su nombre al hecho de que pueden ser creadas y
destruidas durante el tiempo de ejecución de un módulo.
Progra13.cpp
#include <iostream.h>
#include <conio.h>
void main()
{
int x, *a, **b, ***c ; // 1
clrscr();
a = &x ; // 2
*a = 100 ; // 3
36
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
b = &a ; // 4
**b += *a ; // 5
c = &b ; // 6
***c += **b + *a ; // 7
cout << " *a=" << *a << " \n" ;
cout << " **b=" << **b << " \n" ;
cout << "***c=" << ***c << " \n" ;
getch();
}
Análisis de Progra13.cpp
37
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
memoria que no se usa por ningún programa es lo que se conoce como "heap" o
montón.
Progra14.cpp
#include <iostream.h>
#include <conio.h>
void main()
{
char P;
short R;
int I;
long L;
float F;
double D;
long double LD;
clrscr();
gotoxy(1,2);
cout<<"valores utilizando sizeof para cada una de la varibles \n\n";
cout<<" variable P = " <<sizeof P;
cout<<"\t tipo char = " <<sizeof (char);
cout<<"\n variable R = " <<sizeof R;
cout<<"\t tipo short = " <<sizeof (short);
cout<<"\n variable I = " <<sizeof I;
cout<<"\t tipo int = " <<sizeof (int);
cout<<"\n variable L = " <<sizeof L;
cout<<"\t tipo int = " <<sizeof (long);
38
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Análisis de Progra14.cpp
39
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Introducción
El lenguaje C++ cuenta con dos operadores preconstruidos, ellos son: New y
Delete, por esta razón no se requiere incluir ninguna librería o archivo de
cabecera para utilizarlos.
Este operador hace una petición al sistema operativo para que se le asigne un
espacio en memoria, con el tamaño acorde al tipo de datos (vale la pena recordar
la función sizeof), si este espacio está disponible, la operación regresa la dirección
real que se otorga, en caso de no haber espacio regresa el valor de NULL (0),
delete apuntador;
40
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
La ejecución de este operador provoca que se libere espacio, dejando como valor
indefinido, es decir el sistema operativo lo considera como memoria disponible.
Hay una regla de oro utilizada por algunos autores, se refiere a que cuando se usa
memoria dinámica, toda la memoria que se reserve durante el programa hay que
liberarla antes de salir del programa. No seguir esta regla es una actitud muy
irresponsable, y en la mayor parte de los casos tiene consecuencias desastrosas
que atentan con la estabilidad de su sistema. No es bueno fiarse de lo que diga el
compilador, de que estas variables se liberan solas al terminar la ejecución del
programa, no siempre puede ser así.
“En el listado se declaran las variables index de tipo entero y los apuntadores
point1 y point2 ambos de tipo entero.
Progra15.cpp
# include <iostream.h>
# include <conio.h>
main()
{
clrscr();
int index, *point1, *point2;
point1 = &index;
*point1 = 77;
point2 = new int;
*point2 = 173;
cout <<"SALIDA DE LAS VARIABLES index, *point1 Y *point2\n\n";
cout <<"Los valores son " << index <<" " << *point1 << " "<< *point2 <<'\n';
point1 = new int;
point2 = point1;
*point1 = 999;
cout <<"Los valores son " << index <<" " << *point1 << " "<< *point2 <<'\n';
delete point1;
float *float_point1, *float_point2 = new float;
float_point1 = new float;
*float_point2 = 3.14159;
*float_point1 = 2.4 * (*float_point2);
delete float_point2;
delete float_point1;
char *c_point;
41
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Análisis de Progra15.cpp
En las primeras líneas del programa, se hace uso de los punteros tal como
se hacen también en C.
42
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
43
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
operadores, ya que se han construido como parte del lenguaje en sí, más
que añadirse, y por tanto son más eficientes”1.
Cuando se utiliza new para reservar memoria para un vector, el tamaño del
vector se sitúa entre corchetes, siguiendo al tipo:
int *intvector;
intvector = new int [20];
y se libera:
delete [ ] intvector;
Progra16.cpp
#include <iostream.h> //1
#include <conio.h> //2
void main() //3
{ //4
clrscr(); //5
int *numero; //6
numero = new int ; //7
*numero = 10 ; //8
cout <<"VALOR DE NUMERO\n\n"; //9
cout <<"El resultado de numero es:" <<*numero ; //10
delete numero ; //11
getch(); //12
} //13
1
Tomado de: http://www.pablin.com.ar/computer/cursos/c1/allocate.html
44
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
En la línea 12 se incluye la función getch(), la cual hace una parada del programa
a la espera que se presione una tecla para finalizar la ejecución del programa.
Finalmente la línea 13, se incluye la llave que cierra las instrucciones que hacen
parte de la función principal.
Pero ¿quién asegura que el espacio requerido por new está disponible?. Para
controlar esta situación y evitar un mensaje de error por parte del sistema en
tiempo de ejecución, en el listado siguiente se propone una nueva versión del
programa.
Progra17.cpp
#include <iostream.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
int *numero;
45
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
El valor retornado por new es la dirección del inicio de un bloque de memoria del
tamaño requerido para almacenar 25 elementos de tipo double.
46
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
La función Malloc()
La función Free()
Ejemplos de aplicación
Ejemplo 1
Asigna memoria para un arreglo de 50 enteros
Int *numero;
numero = (int * ) malloc (50 * sizeof (int));
Ejemplo 2
Asigna memoria para un arreglo de 10 valores float
float *numero;
numero = (float * ) malloc (10 * sizeof (float));
47
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Progra18.cpp
#include <iostream.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
int main()
{
clrscr();
int *p=NULL;
int nbytes=100;
p=(int *)malloc(nbytes);
if(p==NULL)
{
cout<<"Insuficiente espacio en memoria\n";
return -1;
}
cout<< "Bytes Reservados\n\n";
cout<<"Se han asignado " <<nbytes <<" bytes de memoria\n";
free(p);
getch();
}
Progra19.cpp
// Listado de librerías o archives de cabecera
#include<iostream.h>
#include<stdlib.h>
#include<conio.h>
p =(persona *)malloc(sizeof(persona));
}
clrscr();
cout<<"LISTADO DE PERSONAS REGISTRADAS "<<"\n";
La Funcione Calloc()
50
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
La Función Realloc()
“Aplicación de Calloc
2
Tomado de: http://www.fismat.umich.mx/mn1/manual/node10.html
51
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Adjudica espacio para un array de nmemb objetos, cada cual tiene como tamaño
tamano. El espacio es inicializado a cero todos los bits.
Progra20.cpp
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
3
Tomado de: http://www.conclase.net/c/librerias/funcion.php?fun=calloc
52
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
int P = 10; // 1
int *x, *y; // 2
y = &P; // 3
x = y; // 4
cout<< “El resultado de x es :” << x ; // 5
Enunciado 2
Int punt; // 1
punt = punt + 1; // 2
punt = punt – 2; // 3
punt++; // 4
punt--; // 5
53
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
void main()
{
int m, *h, **s, ***q ; // 1
clrscr();
h = &m ; // 2
*h = 80 ; // 3
s = &h ; // 4
**s += *h ; // 5
q = &s ; // 6
***q += **s + *h ; // 7
cout << " *h=" << *h << " \n" ; //8
cout << " **s=" << **s << " \n" ; //9
cout << "***q=" << ***q << " \n" ; //10
getch();
}
Ejercicio 7. Implementar un programa que asigne memoria con new y delete, para
un arreglo de estructuras, el cual desea llevar los registros básicos de 5
mascotas, como: raza, nombre, color y edad Ingresados por teclado, además de
determinar en tiempo de ejecución el tamaño del arreglo a utilizar.
54
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
55
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
56
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
UNIDAD 2
58
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
CAPITULO 4: PILAS
Introducción
Las pilas son un tipo de estructura de datos de tipo lineal condicionadas donde las
inserciones y eleminaciones se realizan por un mismo extremo. Se tratan los
temas relacionados con los conceptos básicos de las pilas, las operaciones que se
pueden realizar con las pilas, todo conjugado en programas de aplicación,
implementados con apuntadores, al igual que en los anteriores capítulos, cada uno
de los programas aquí presentados, están previamente compilados y depurados
de tal manera que se mustra la salida en pantalla de cada uno. Lo anterior
garantiza al estudiante que puede guiarse en el código fuente para hacerle
modificaciones y proponer soluciones a entornos reales.
Una pila llamada stack (en inglés) se puede definir como un tipo especial de lista
lineal condicionada, en la que las inserciones y el borrado de nuevos elementos
se realizan sólo por un extremo, que se denomina cima o tope top (en inglés).
La pila es una estructura con numerosas analogías en la vida real: pila de platos,
una pila de monedas, una pila de camisas, una pila de animales, etc. Como se
muestra en la figura siguiente.
59
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Fuente: www.utpl.edu.ec/ecc/wiki/images/1/1e/Pilas.JPG
Una pila, a un nivel físico puede representarse tal como se muestra en figura 21,
donde representa una pila de moneda o una pila de platos en un restaurante.
Cuando se habla de una pila a nivel lógico, es una estructura de datos lineal
compuesta de elementos del mismo tipo, en la cual cada uno de ellos solo puede
ser insertado y eliminado por su parte final, es decir por el extremo final.
La posición final la llamamos cima o también cabeza de la pila; para darse una
mejor representación (abstracción) de ella, su representación gráfica en el papel la
se hace en forma vertical, con la cima en la parte de arriba. De esta forma cuando
se añade un nuevo elemento solo podrá ser colocado en la parte superior, piense
en una pila de platos de cocina o en una pila de libros, los cuales se colocan en
orden uno encima de otro. Por lo anterior las pilas también son llamadas listas en
las cuales el último elemento en entrar es el primero en salir, en inglés el acrónimo
LIFO(Last Input, First Out).
Las operaciones básicas que se pueden realizar con la implementación de una lista
lineal condicionada tipo pila son: la inserción la eliminación y la visualización de sus
elementos. Esta implementación se lleva a cabo haciendo uso de punteros con
listas enlazadas al igual que por medio de arreglos unidimensionales.
60
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
En principio, la pila está vacía y el puntero de la pila o CIMA debe estar en cero. Al
insertar un elemento en la pila, se incrementa el puntero en una unidad. Mientras
que al sacar un elemento de la pila se decrementa en una unidad el puntero,
teniendo aplicabilidad las operaciones que se realizan con punteros tratadas en la
Unidad uno. Siendo P el puntero (*P), al manipular una pila se deben realizar
algunas comprobaciones.
61
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
struct pila
{
int dato;
struct pila *siguiente;
};
#include<iostream.h>
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include<dos.h>
63
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
struct pila
{
int numero;
struct pila *sig;
}*inicio=NULL, *c=NULL;
Para continuar con el programa se escoge la segunda alternativa, que tiene entre
sus miembros una variable llamada numero de tipo entero que guardará los
números que serán ingresados, al igual que un puntero llamado sig del tipo struct
pila, del mismo tipo de la estructura usado para apuntar al siguiente nodo de la
pila. Finalmente se declaran como instancias, dos variables apuntador del mismo
tipo de la estructura llamadas inicio y c inicializadas a NULL como buena
costumbre.
Estas variables son llamadas instancias que son del mismo tipo de la estructura,
inicio usada para reservar memoria y c usada para recorrer la pila; una vista de lo
hecho hasta ahora es:
Void main()
64
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
{
textcolor(10);
int opc=0;
do
{
clrscr();
cout<<" MANEJO DE UNA ESTRUCTURA TIPO PILA ";
cout<<"\n\n\n");
cout<<"1. Insertar\n");
cout<<"2. Extraer\n");
cout<<"3. Visualizar\n");
cout<<"4. Salir\n\n");
cout<<"Digite la opcion: ");
cin >>opc;
switch (opc)
{
case 1:
cout<<"inserter";
break;
case 2:
cout<<"extraer";
break;
case 3:
cout<<"visualizar";
break;
case 4:
exit(1);
}
getch();
}while (opc!=4)
}
65
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
El otro cambio que se hará al código inicial, es en el case 1 del swich cambiamos
el mensaje a desplegar cout<<”insertar”; por insertar(); usado por el programa
principal para llamar a la función insertar(). Se visualiza en figura 26.
66
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
67
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
68
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Finalmente, solo queda incluir la opción de extraer o eliminar datos de la pila con
esta opción tendremos la implementación completa del programa básico para el
manejo de una pila.
Manos a la obra.
Como en los dos casos anteriores se siguen las mismas directrices declarando la
función extraer, en el espacio utilizado para tal fin, el código es:
69
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Para resumir la implementación del manejo de la pila que se realizó paso a paso,
se incluye el listado completo. Copie este código, en su editor que puede ser el
Bloc de Notas y lo guarda con el nombre Progra21.cpp en el directorio de
ejecución que por defecto está configurado el compilador C:\TC\BIN, con esto ya
tiene listo el programa para que lo abra desde el compilador de Turbo C++ de
cualquiera de sus versiones.
71
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Progra21.cpp
#include <iostream.h>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <dos.h>
struct pila
{
int numero;
struct pila *sig;
}*inicio=NULL, *c=NULL;
void insertar(void);
void extraer(void);
void visualizar(void);
void main()
{
textcolor(10);
int opc=0;
do
{
clrscr();
cout<<" MANEJO DE UNA ESTRUCTURA TIPO PILA ";
cout<<"\n\n\n";
cout<<"1. Insertar\n";
cout<<"2. Extraer\n";
cout<<"3. Visualizar\n";
cout<<"4. Salir\n\n";
cout<<"Digite la opcion: ";
cin >>opc;
switch (opc)
{
case 1:
insertar();
72
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
break;
case 2:
extraer();
break;
case 3:
visualizar();
break;
case 4:
exit(1);
}
getch();
}while (opc!=4);
}
else
{
clrscr();
inicio=c;
while (inicio!=NULL)
{
cout<<"Numero: "<<inicio->numero<<endl;
inicio=inicio->sig;
}
}
getch();
}
74
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Progra22.cpp
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <iostream.h>
void insertar(void);
void extraer(void);
void visualizar(void);
struct pila
{
char nombre[20];
struct pila *ant;
};
75
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
main()
{
char opc;
do
{
clrscr();
gotoxy(30,8);
cout<<"1.- Insertar";
gotoxy(30,10);
cout<<"2.- Extraer";
gotoxy(30,12);
cout<<"3.- Visualizar la pila";
gotoxy(30,14);
cout<<"4.- Salir";
gotoxy(20,16);
cout<<"Ingrese una opcion : ";
cin>> opc;
// opc=getch( ); otra forma
switch(opc)
{
case '1':
insertar( );
break;
case '2':
extraer( );
break;
case '3':
visualizar( );
}
// getch(); es opcional
}while (opc!='4');
return 0;
}
void insertar(void)
{
AUX=(struct pila *)malloc(sizeof(struct pila));
clrscr();
cout<<"INGRESAR DATOS DE LA PILA \n\n ";
cout<<"Nombre: ";
gets(AUX->nombre);
if (CAB==NULL)
{
CAB=AUX;
AUX->ant=NULL;
}
else
{
AUX->ant=CAB;
CAB=AUX;
}
}
void extraer(void)
{
if (CAB==NULL)
return;
AUX=CAB;
CAB=CAB->ant;
free(AUX);
cout<<"\n Se elimino a " <<AUX->nombre <<" de la pila";
getch();
}
void visualizar(void)
{
if (CAB==NULL)
return;
clrscr();
77
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
AUX=CAB;
cout<<"DATOS DE LA PILA \n\n ";
while (AUX!=NULL)
{
cout<<"Nombre: "<<AUX->nombre <<endl;
AUX=AUX->ant;
}
getch( );
}
Progra23.cpp
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
79
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
int menu()
{
int o = 0;
do{
int main()
{
tope = NULL; // hacemos que el tope no apunte a nada (pila vacia)
int d = 0;
do
{
d = menu(); // retorna opcion
switch(d)
{
case 1:
Push();
break;
case 2:
{
Pop();
getch();
break;
}
case 3:
80
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
{
while(tope != NULL)
Pop();
printf("PILA VACIA");
getch();
break;
}
}
}while(d != 4); // mientras que la opcion no sea 4
return 0;
}
81
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
CAPITULO 5: COLAS
Introducción
Las colas al igual que las pilas, son una estructura de datos de tipo lineal
condicionadas donde las inserciones y eleminaciones se realizan por extremos
diferentes. Se abordan los temas relacionados con los conceptos básicos de las
colas, las operaciones que se pueden realizar con las colas, todo conjugado en
programas de aplicación, implementados con apuntadores.
Las colas son otro tipo de estructura de datos lineales, similar a las pilas,
diferenciándose de ellas en el modo de insertar/eliminar elementos. Así pues, la
diferencia con las pilas reside en el modo de entrada/salida de datos; en las colas
las inserciones se realizan al final de la lista, no al principio.
Por ello, las colas se usan para almacenar datos que necesitan ser procesados
según el orden de llegada. Una aplicabilidad de las colas puede realizarse en un
sistema de computacional manejado a través de una red de computadoras donde
se comparte una sola impresora para todos los equipos conectados a la red; de
tal manera que se imprimirán los documentos en el orden en que se hace la
petición de impresión de cada usuario. Formando así una cola de impresión.
82
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Una muy buena representación gráfica de las estructuras de datos tipo cola puede
visualizarse en la Figura 32, que se muestra a continuación.
Fuente: http://www.utpl.edu.ec/ecc/wiki/index.php/Imagen:Cola.JPG
Existe otra aplicación muy utilizada que se denomina cola de prioridades; en ella
el procesador central no atiende por riguroso orden de llamada, aquí el procesador
atiende por prioridades asignadas por el sistema o bien por el usuario y sólo
dentro de las peticiones de igual prioridad se producirá una cola”4.
4
Tomado de: http://www.uhu.es/17207-18209/Transparencias/Tema3.pdf
83
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Una muy buena implementación de las colas podría realizarse un programa para
manejar un planificador de citas en un consultorio médico, de tal manera que cada
solicitud de una cita se va almacenando en la cola el nombre del paciente y la hora
de la cita, en el mismo orden de fecha y hora en que se solicitó será atendida.
En general en una cola, de la vida diaria, el primero que llega será atendido
primero, pasando a continuación el segundo de la cola al frente; y cada que llega
un nuevo elemento este se colocará al final de la cola. De aquí que el extremo por
donde se insertan los elementos se llamará "final" y por donde se retiran "frente".
Debido a esto último las colas también son llamadas listas en las cuales el primer
elemento en entrar es el primero en salir.
Las operaciones en detalle que se pueden realizar con una cola son:
Progra24.cpp
#include <iostream.h>
#include <iomanip.h>
#include <conio.h>
void Insertar(){
if ( (final+1 == MaxiCola && frente == 0) || (final+1 == frente) )
{
cout << "La cola está llena ";
getch();
}
else
if (frente == nulo)
{ //la cola estaba vacía
frente = final = 0;
cout << "\n\n Ingrese el elemento a insertar: ";
cin >> cola[frente];
}
else
{
final++;
if (final == MaxiCola)
final = 0;
85
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
void Atender()
{
if (frente == nulo)
cout << "\nCola vacia\a";
else {
cout << "\nEliminando elemento: " << cola[frente];
if (frente == final) // cola quedó vacía
frente = final = nulo;
else{
frente++;
if (frente == MaxiCola)
frente = 0;
}
}
}
void Listar()
{
int i;
if (frente==nulo)
cout << "\nLa cola esta vacia \a\n";
else
if (frente <= final)
for (i=frente; i <= final; i++)
cout <<setw(4) << cola[i];
else {
for (i=frente; i < MaxiCola; i++)
cout << setw(4) << cola[i];
void main()
{
char opcion;
do{
86
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
clrscr();
Listar();
cout << "\nIMPLENTACION DE UNA COLA CON ARREGLOS \n";
cout << "\n\nInsertar Atender Salir \n";
switch (opcion=getch()){
case 'I':; case 'i': Insertar(); break;
case 'A':; case 'a': Atender(); break;
}
} while (opcion != 'S' && opcion != 's');
}
El resultado de la salida en pantalla del Listado Implementado con arreglos llamado
progra24.cpp se puede visualizar en la siguiente figura 34.
Las colas también se pueden representar como estructuras dinámicas, para ello
se necesitan dos punteros que se llamarán: CAB, FIN y AUX.
Las operaciones con colas son muy sencillas, prácticamente no hay casos
especiales, salvo que la cola esté vacía.
Se parte del hecho de que ya se tiene el nodo a insertar y por supuesto un puntero
que apunte a él, además los punteros que definen la cola, CABEZA, FINAL y
AUXILIAR que se inicializan a cero es decir valdrán NULL.
El proceso es muy simple, bastará con que:
87
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
void insertar(void)
{
AUXILIAR=(struct cola *)malloc(sizeof(struct cola));
clrscr();
cout<<"Nombre: ";
gets(AUXILIAR->nombre);
AUXILIAR->sig=NULL;
if (FINAL==NULL)
FINAL=CABEZA=AUXILIAR;
else
{
FINAL->sig=AUXILIAR;
FINAL=AUXILIAR;
}
}
3. Se guarda el contenido del nodo para devolverlo como retorno, hay que
recordar que la operación de lectura en colas implican también borrar.
4. se libera la memoria asignada al primer nodo, el que se quiere eliminar.
Free (AUXILIAR);
void extraer(void)
{
if (CABEZA==NULL)
{
cout<<"No hay elementos en la cola";
getch();
}
else
{
AUXILIAR=CABEZA;
cout<<"El dato eliminado es: "<<AUXILIAR->nombre;
getch();
CABEZA=CABEZA->sig;
free(AUXILIAR);
}
}
Se hará uso del puntero llamado CABEZA que apunta a la cabeza de la cola. Si la
cola está vacía si CABEZA==NULL retorna al programa principal desplegando el
mensaje que indica el estado de la cola.
void visualizar(void)
{
if (CABEZA==NULL)
89
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
{
cout<<"NO HAY ELEMENTOS EN LA COLA";
getch();
}
else
{
clrscr();
AUXILIAR=CABEZA;
while (AUXILIAR!=NULL)
{
cout<<"Nombre:" <<AUXILIAR->nombre <<"\n";
AUXILIAR=AUXILIAR->sig;
}
getch();
}
Progra25.cpp
#include <stdio.h>
#include <iostream.h>
#include <conio.h>
#include <stdlib.h>
void insertar(void);
void extraer(void);
void visualizar(void);
struct cola
{
char nombre[20];
struct cola *sig;
}*CABEZA=NULL,*AUXILIAR=NULL,*FINAL=NULL;
main()
{
char opc;
do
{
90
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
clrscr();
gotoxy(30,8);
cout<<"1.- Insertar";
gotoxy(30,10);
cout<<"2.- Extraer";
gotoxy(30,12);
cout<<"3.- Visualizar la cola";
gotoxy(30,14);
cout<<"4.- Salir";
gotoxy(25,16);
cout<<"Ingrese la opcion :";
opc=getch( );
switch(opc)
{
case '1':
insertar( );
break;
case '2':
extraer( );
break;
case '3':
visualizar( );
}
}while (opc!='4');
return 0;
}
void insertar(void)
{
AUXILIAR=(struct cola *)malloc(sizeof(struct cola));
clrscr();
cout<<"Nombre: ";
gets(AUXILIAR->nombre);
AUXILIAR->sig=NULL;
if (FINAL==NULL)
FINAL=CABEZA=AUXILIAR;
else
{
FINAL->sig=AUXILIAR;
FINAL=AUXILIAR;
}
}
91
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
void extraer(void)
{
if (CABEZA==NULL)
{
cout<<"No hay elementos en la cola";
getch();
}
else
{
AUXILIAR=CABEZA;
cout<<"El dato eliminado es: "<<AUXILIAR->nombre;
getch();
CABEZA=CABEZA->sig;
free(AUXILIAR);
}
}
void visualizar(void)
{
if (CABEZA==NULL)
{
cout<<"NO HAY ELEMENTOS EN LA COLA";
getch();
}
else
{
clrscr();
cout<<"ELEMENTOS DE LA COLA \n\n";
AUXILIAR=CABEZA;
while (AUXILIAR!=NULL)
{
cout<<"Nombre:" <<AUXILIAR->nombre <<"\n";
AUXILIAR=AUXILIAR->sig;
}
getch();
}
}
La salida en pantalla de Progra25.cpp se puede visualizar en la figura 35 que se
muestra a continuación.
92
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Progra26.cpp
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <conio.h>
#include <iostream.h>
#define MAX 5
int main()
{
clrscr();
char s[80];
93
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
register int t;
for(;;)
{
cout<<"\n\nOPCIONES DE ITERACION DE LA COLA\n\n";
cout<<"I. Introducir\n";
cout<<"R. Revisar\n";
cout<<"E. Eliminar\n";
cout<<"S. Salir\n\n";
cout<<"Seleccione la opci¢n : ";
gets(s);
*s = toupper(*s);
switch(*s)
{
case 'I':
intro();
break;
case 'R':
revisar();
break;
case 'E':
eliminar();
break;
case 'S':
exit(0);
}
}
void intro(void)
{
char s[256], *p;
do
{
cout<<"Introduce la cita " <<spos+1 <<" : ";
gets(s);
if(*s==0) break; //no hay entradas
p = (char *)malloc(strlen(s)+1);
94
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
if(!p)
{
cout<<"No hay memoria \n";
return;
}
strcpy(p, s);
if(*s)calmac(p);
}while(*s);
clrscr();
}
void revisar(void)
{
clrscr();
register int t;
cout<<endl <<endl <<" LISTADO DE CITAS" <<endl <<endl;
for(t=rpos;t<spos;++t)
cout<<t+1 <<p[t] <<endl;
}
void eliminar(void)
{
clrscr();
char *p;
if ((p=crecup())==NULL) return;
cout<<endl <<"CITA ELIMINADA:" <<p;
}
char *crecup(void)
{
if(rpos==spos)
{
cout<<"No hay mas citas \n";
return NULL;
}
rpos++;
return p[rpos-1];
}
96
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
CAPITULO 6: LISTAS
Introducción
Las listas al igual que las pilas y las colas, son una estructura de datos de tipo
lineal diferenciándose de las anteriores en el hecho de que pueden las
inserciones y eleminaciones se en cualquier parte de la lista. Esto hace que
tengan mayor aplicabilidad en el entorno real. Se abordan los temas relacionados
con los conceptos básicos de las listas, así como tipos de listas y las operaciones
que se pueden realizar con las listas, todo conjugado en programas de aplicación,
implementados con apuntadores.
Una lista enlazada es una colección o secuencia de elementos del mismo tipo
dispuestos uno detrás de otro, en el que cada elemento se liga al siguiente
elemento por un enlace que no es más que un puntero previamente definido.
Entre las listas simplemente enlazadas se encuentra un tipo de lista llamada Lista
contigua: La cual se compone de un conjunto de elementos de un tipo dado que
se encuentran ordenados y pueden variar en número. Esta es una definición
general, que incluye los ficheros y vectores.
97
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Las entradas de una guía o directorio telefónico, por ejemplo, están en líneas
sucesivas, excepto en las partes superior e inferior de cada columna. Una lista
lineal se almacena en la memoria principal de una computadora en posiciones
sucesivas de memoria; cuando se almacenan en cinta magnética, los elementos
sucesivos se presentan en sucesión en la cinta. Esta asignación de memoria se
denomina almacenamiento secuencial. Posteriormente, se verá que existe otro
tipo de almacenamiento denominado encadenado o enlazado.
Para permitir operaciones con las listas como arreglos se deben dimensionar
éstos con tamaño suficiente para que contengan todos los posibles elementos de
la lista.
Las operaciones que se pueden realizar con listas lineales contiguas son:
98
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Una lista enlazada sin ningún elemento se llama lista vacía. Su puntero inicial o
de cabecera tiene el valor nulo, es decir apunta a NULL.
*puntero NULL;
99
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
El siguiente programa se plantea como ejemplo guía para implementar una lista
simplemente enlazada con punteros, para gestionar números enteros, ingresados
por teclado con funciones de crear, insertar, eliminar, recorrer y buscar.
Las eliminaciones y la búsqueda, se realizan en cualquier lugar de la lista.
Progra27.cpp
#include <iostream.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
struct lista
{
int dato;
struct lista *sig;
};
int main()
{
clrscr();
struct lista *entero;
int dato;
crear(&entero);
101
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
auxiliar->dato = dato;
anterior = NULL;
puntero = *entero; //puntero es el puntero auxiliar que recorre la lista
while((puntero != NULL) && (puntero->dato < dato))
{
anterior = puntero;
puntero = puntero->sig;
}
if(anterior == NULL)
{
auxiliar->sig = *entero;
*entero = auxiliar;
}
else
{
anterior->sig = auxiliar;
auxiliar->sig = puntero;
}
}
{
anterior = puntero;
puntero = puntero->sig;
}
if(puntero->dato != dato)
anterior->sig = puntero->sig;
delete puntero;
}
}
return 1;
else
return 0;
}
104
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Progra28.cpp
#include <conio.h>
#include <iostream.h>
#include <stdlib.h>
struct lista
{
int nuevo;
struct lista *sig;
};
int main()
{
clrscr();
struct lista *L;
105
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Análisis de Progra28.cpp
106
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Progra29.cpp
#include <stdlib.h>
#include <iostream.h>
#include <conio.h>
struct nodo
{
int dato;
struct nodo *sig;
}*l=NULL,*primero=NULL;
int main()
{
clrscr();
int acumulador=0;
int i=0, vector[6];
cout<<"IMPLEMENTACION DE UNA LISTA ENLAZADA\n\n";
cout<<"Ingrese 6 numeros\n";
for(i;i<6;i++)
{
cin>> vector[i];
acumulador = acumulador + vector[i];
107
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
}
for(i;i<6;i++)
{
primero=(struct nodo *)malloc(sizeof(struct nodo));
primero->dato=vector[i-1];
primero->sig = l;
l = primero;
}
108
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Las listas doblemente enlazadas son un tipo de lista lineal en la que cada nodo
tiene dos enlaces, uno que apunta al nodo siguiente, y el otro que apunta al
nodo anterior.
struct ListaDoble {
int dato;
struct nodo *siguiente;
struct nodo *anterior;
};
109
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Progra30.cpp
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream.h>
struct direc
{
char nombre[30];
char ciudad[20];
char codigo[10];
struct direc *sig; //PUNTERO A LA SIGUIENTE ENTRADA
5
Tomado de: http://ldcastillo.wordpress.com/tema-2-listas-doblemente-enlazadas/
110
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
void intro(void);
void buscar(void);
void listar(void);
void eliminar(struct direc **, struct direc **);
void dl_insert(struct direc *i, struct direc **ppio, struct direc **final);
void leecad(char *, char *, int), mostrar(struct direc *);
int menu(void);
int main(void)
{
clrscr();
for(;;)
{
switch(menu())
{
case 1: intro(); //INTRODUCIR UNA DIRECCION
break;
case 2: eliminar(&ppio, &final); //ELIMINA UNA DIRECCION
break;
case 3: listar();//MOSTRAR LA LISTA
break;
case 4: buscar();//ENCONTRAR UNA DIRECCION
break;
case 5: exit(0);
}
}
}
int menu(void)
{
111
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
char s[80];
int c;
cout<<"\nLISTA DOBLEMENTE ENLAZADA\n\n";
cout<<"1. Introducir una direccion" <<endl;
cout<<"2. Eliminar una direcci¢n" <<endl;
cout<<"3. Listar el archivo" <<endl;
cout<<"4. Buscar" <<endl;
cout<<"5. Salir" <<endl;
do
{
cout<<"\nIntroduce una opcion: ";
gets(s);
c = atoi(s);
}while(c<0 || c>5);
clrscr();
return c;
}
void intro(void)
{
struct direc *info;
for(;;)
{
info = (struct direc *)malloc(sizeof(struct direc));
if(!info)
{
cout<<endl <<"no hay memoria";
return;
}
112
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
do
{
printf(indic);
fgets(p, 254, stdin);
}while(strlen(p) > cont);
void dl_insert(
struct direc *i, //nuevo elemento
struct direc **ppio, //primer elemento de la lista
struct direc **final //ultimo elemento de la lista
)
{
ant = NULL;
while(p)
{
if(strcmp(p->nombre, i->nombre) <0)
{
113
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
ant = p;
p = p->sig;
}
else
{
if(p->ant)
{
p->ant->sig = i;
i->sig = p;
i->ant = p->ant;
p->ant = i;
*ppio = i;
return;
}
i->sig = p; //nuevo primer elemento
i->ant = NULL;
p->ant = i;
*ppio = i;
return;
}
}
ant->sig = i; //ponerlo en el final
i->sig = NULL;
i->ant = ant;
*final = i;
}
{
info->ant->sig = info->sig;
if(info != *final)
info->sig->ant = info->ant;
else
*final = info->ant;
}
free(info); //devolver la memoria al sistema
}
clrscr();
}
info = ppio;
while(info)
{
if(!strcmp(nombre, info->nombre))
return info;
info = info->sig; //obtener siguiente direccion
}
cout<<"nombre no encontrado" <<endl;
void listar(void)
{
struct direc *info;
info = ppio;
while(info)
{
mostrar(info);
info = info->sig; //obtener la siguiente direccion
}
115
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
cout<<endl <<endl;
}
void buscar(void)
{
char nombre[40];
struct direc *info;
116
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Las listas circulares presentan las siguientes ventajas respecto de las listas
enlazadas simples:
Cada nodo de una lista circular es accesible desde cualquier otro nodo de ella.
Es decir, dado un nodo se puede recorrer toda la lista completa. En una lista
enlazada de forma simple sólo es posible recorrerla por completo si se parte de
su primer nodo.
Las operaciones de concatenación o unión y división de listas son más
eficaces con listas circulares.
Se pueden producir lazos o bucles infinitos. Una forma de evitar estos bucles
infinitos es disponer de un nodo especial que se encuentre permanentemente
asociado a la existencia de la lista circular. Este nodo se denomina cabecera
de la lista.
117
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
El nodo cabecera puede diferenciarse de otros nodos en una de las dos formas
siguientes:
Puede tener un valor especial en su campo INFO que no es válido como datos
de otros elementos.
Puede tener un indicador o bandera que señale cuándo es nodo cabecera.
No existe elemento alguno que apunte a NULL es decir que el último elemento
apunta a la cabeza o al inicio de la lista. De igual manera se integra como una
estructura tipo anillo. Solo se evidencia un nodo cabecera, La cabecera siempre
apuntará al siguiente enlace para algún nodo y es susceptible de crear ciclos o
bucles infinitos.
En una estructura tipo Circular no existe algún elemento que apunte a NULL, se
presenta entonces la dificultad para conocer el último elemento. Sin embargo
podría considerarse que como el último nodo será aquel que en su parte siguiente
apunta a la cabeza y precisamente en un método de búsqueda la comparación
con el nodo cabeza será la que indique que no existen más elementos en la lista.
118
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
119
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
120
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Para generalizar los dos casos anteriores, sólo necesitamos añadir una operación:
Progra31.cpp
#include <stdio.h>
#include <stdlib.h>
int main() {
Lista lista = NULL;
pNodo p;
121
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Insertar(&lista, 10);
Insertar(&lista, 40);
Insertar(&lista, 30);
Insertar(&lista, 20);
Insertar(&lista, 50);
MostrarLista(lista);
Borrar(&lista, 30);
Borrar(&lista, 50);
MostrarLista(lista);
BorrarLista(&lista);
getchar();
return 0;
}
nodo = *lista;
do {
printf("%d -> ", nodo->valor);
nodo = nodo->siguiente;
} while(nodo != lista);
printf("\n");
}
6
Tomado de: http://www.conclase.net/c/edd/index.php?cap=004c
123
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
124
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Ejercicio 5. Una cola medieval se comporta como una cola ordinaria, con la única
diferencia de que los elementos almacenados en ella se dividen en dos
estamentos: nobles y plebeyos. Dentro de cada estamento, los elementos deben
ser atendidos en orden de llegada; pero siempre que haya nobles en la cola, éstos
deben ser atendidos antes que los plebeyos. Se pide:
Ejercicio 6. Implemente una lista lineal de datos de tipo numérico, con opciones de
ordenar la lista en los dos sentidos, ascendente y descendente, e imprima el
resultado.
struct nodo {
int nota;
char nombre[15];
struct nodo *siguiente;
} cabeza;
126
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
127
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
128
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
UNIDAD 3
Capítulo 1 ÁRBOLES
Lección 1 Teoría general de árboles
Lección 2 Otros conceptos de la teoría general de árboles
Lección 3 Árbol completo
Lección 4 Estructura para la creación de un árbol de orden tres
Lección 5 Introducción al Modo Gráfico de C++
Capítulo 2 ÁRBOLES BINARIOS
Lección 6 Conceptualización de árboles binarios
Lección 7 Clasificación de los árboles binarios
Lección 8 Formas de Recorrer un Árbol Binario
Lección 9 Ábol binario de búsqueda (ABB)
Lección 10 Operaciones en ABB
Capítulo 3 GRAFOS
Lección 11 Conceptos básicos de grafos
Lección 12 Grafo no dirigido
Lección 13 Representación de los grafos
Lección 14 Representación mediante listas de Adyacencia
Lección 15 Exploración de grafos
130
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
CAPITULO 7: ÁRBOLES
Introducción
Los árboles a diferencia de las listas son una estructura de datos de no lineal,
atendiendo más a una estructura de tipo jerárquico. Se abordan los temas
relacionados con los conceptos básicos de árboles, incluyendo la teoría general de
árboles e identificando los diferentes tipos de árboles.
Los árboles son, sin duda, una de las estructuras de datos no lineales, empleadas
en informática, tanto para resolver problemas de hardware como de software. Los
árboles de directorios son organizaciones bastante empleadas por cualquier
usuario o programador de una computadora. De igual manera cumplen un buen
papel en la toma de decisiones, valido como árbol de decisiones.
Los árboles genealógicos y los organigramas son ejemplos comunes. Entre otras
aplicaciones, los árboles se emplean para analizar circuitos eléctricos y para
representar la estructura de fórmulas matemáticas, así como para organizar la
información de bases de datos, para representar la estructura sintáctica de un
programa fuente en compiladores y para la toma de decisiones.
Definición de árboles
Los árboles son estructuras de datos muy similares a las listas doblemente
enlazadas, en el sentido que tienen punteros que apuntan a otros elementos, pero
131
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
no tienen una estructura lógica de tipo lineal o secuencial como aquellas, sino
ramificada. Tienen aspecto de árbol, de ahí su nombre.
Fuente: http://www.conclase.net/c/edd/index.php?cap=006b
“Con relación al tipo de nodos que hacen parte de los árboles, se identifican
algunos nodos:
132
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Nodo hijo: cualquiera de los nodos apuntados por uno de los nodos del árbol. En
el ejemplo, 'L' y 'M' son hijos de 'G'.
Nodo padre: nodo que contiene un puntero al nodo actual. En el ejemplo, el nodo
'A' es padre de 'B', 'C' y 'D'.
Los árboles con los que trabajará tienen otra característica importante: cada
nodo sólo puede ser apuntado por otro nodo, es decir, cada nodo sólo tendrá un
padre. Esto hace que estos árboles estén fuertemente jerarquizados, y es lo que
en realidad les da la apariencia de árboles.
Nodo hoja: nodo que no tiene hijos. En el ejemplo hay varios: 'F', 'H', 'I', 'K', 'L',
'M', 'N' y 'O'.
Nodo rama: aunque esta definición apenas la usaremos, estos son los nodos que
no pertenecen a ninguna de las dos categorías anteriores. En el ejemplo: 'B', 'C',
'D', 'E', 'G' y 'J'.
Existen otros conceptos que definen las características del árbol, en relación a
su tamaño:
Orden: es el número potencial de hijos que puede tener cada elemento de árbol.
De este modo, se dice que un árbol en el que cada nodo puede apuntar a otros
dos es de orden dos, si puede apuntar a tres será de orden tres y así
sucesivamente.
Grado: el número de hijos que tiene el elemento con más hijos dentro del árbol.
En el árbol del ejemplo en la figura 50, el grado es tres, ya que tanto 'A' como 'D'
tienen tres hijos, y no existen elementos con más de tres hijos.
Nivel: se define para cada elemento del árbol como la distancia a la raíz, medida
en nodos. El nivel de la raíz siempre será cero y el de sus hijos uno. Así
133
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
sucesivamente. En el ejemplo de la figura 50, el nodo 'D' tiene nivel 1, el nodo 'G'
tiene nivel 2, y el nodo 'N', nivel 3.
Altura: la altura de un árbol se define como el nivel del nodo de mayor nivel.
Como cada nodo de un árbol puede considerarse a su vez como la raíz de un
árbol, también se puede hablar de altura de ramas. El árbol del ejemplo de la
figura 50, tiene altura 3, la rama 'B' tiene altura 2, la rama 'G' tiene altura 1, la 'H'
cero. Los árboles de orden dos son bastante especiales, de hecho se ampliará un
poco la información en el siguiente capítulo. Estos árboles se conocen también
como árboles binarios.
El nodo típico de un árbol difiere de los nodos que se vieron en la unidad dos
para el manejo de las listas, aunque sólo en el número de nodos. A continuación
se presenta un ejemplo de nodo para crear árboles de orden tres:
struct Arbol {
int dato;
struct Arbol *rama1;
struct Arbol *rama2;
struct Arbol *rama3;
};
#define ORDEN 5
struct Arbol {
int dato;
struct Arbol *rama[ORDEN];
};
134
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Salvo que se trabaje con algún tipo de árboles especiales, como los que se verán
en el siguiente capítulo es decir el capítulo 8, las inserciones serán siempre en
punteros de nodos hoja o en punteros libres de nodos rama. Ya que con estas
estructuras no es tan fácil generalizar, existen muchas variedades de árboles.
Los algoritmos de inserción y borrado dependen en gran medida del tipo de árbol
que se esté implementando, de modo que por ahora se dejarán a un lado y se
centrará la atención en el modo de recorrer los árboles.
Árboles ordenados
Los árboles ordenados son los que tienen más interés desde el punto de vista
de los tipos de datos abstractos (TAD), y los que tienen más aplicaciones
genéricas.
Un árbol ordenado, en general, es aquel que a partir del cual se puede obtener
una secuencia ordenada siguiendo uno de los recorridos posibles del árbol, es
decir en inorden, preorden o posorden.
135
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Árboles 2-3: son árboles de orden 3, que contienen dos claves en cada nodo y
que están también equilibrados. También generan secuencias ordenadas al
recorrerlos en inorden.
Árboles-B: caso general de árboles 2-3, que para un orden M, contienen M-1
claves”7.
Bienvenidos….
Tal como se propone en la introducción general del curso, para el desarrollo del
lenguaje de programación se recomienda trabajar con el compilador de Borlan
C++ 3.0, la razones obedecen a que es uno de los compiladores más completos
de uso general para plataforma Linux y Windows XP en especial, ya que para
Windows Vista y Windows 7 en el manejo de gráficos se requiere una versión de
compilador superior es por ello que para este curso se propone Borland C++ 5.5
7
Tomado de: http://www.conclase.net/c/edd/index.php?cap=006b.
136
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
entre tantas versiones que hay disponibles y son de fácil manejo y algo adicional
que es de libre uso y ya viene configurado siempre y cuando la descarga la realice
del sitio https://sites.google.com/site/hhmosquera/file-cabinet.
Para compilar el programa solo tiene que ubicar en la barra de menú del
compilador la opción Tools y dar clic en la opción Compile o presione las teclas
Ctrl + F7.
Para probar si quedó bien instalado el compilador solo tiene que copiar en el editor
el siguiente código fuente:
#include <graphics.h>
#include <conio.h>
137
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
#include <stdio.h>
void main(void)
{
int monitor=DETECT, modo;
initgraph(&monitor,&modo,"");
setcolor(YELLOW);
line(10,50,50,100);
setcolor(WHITE);
circle(100,200,30);
//setfillstyle(LINE_FILL,RED);
floodfill(100,200,WHITE);
rectangle(200,100,300,200);
setfillstyle(HATCH_FILL,BLUE);
floodfill(250,150,WHITE);
setcolor(GREEN);
settextstyle(GOTHIC_FONT,HORIZ_DIR,3);
outtextxy(20,10,"Modo Gráfico de C++");
outtextxy(20,250,"Hola Ingeniero esto es:");
setcolor(CYAN);
outtextxy(20,300,"Estructura de datos");
getch();
closegraph();
return;
}
Otra alternativa para trabajar en modo gráfico es el compilador de Turbo C++ 3.0,
el cual requiere una configuración básica que se describe a continuación.
138
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Una vez habilitada las librerías gráficas, solo queda por incluir la ruta donde se
encuentran los archivos de la interfaz gráfica binaria (BGI) que está ubicada en la
ruta que trae por defecto al instalarse el programa; esa ruta es C:\TC\BGI; se
procede a incluir esta ruta en la opción de directorios tal como se muestra en la
figura siguiente, Figura 53.
En la primera línea solo tiene que incluir la siguiente ruta tal como se ve en la
siguiente gráfica; C:\TC\BGI
139
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Así se verá una vez haya incluido la ruta C:\TC\BGI solo debe presionar OK y listo
ya tiene configurado el compilador para trabajar en modo gráfico sin problemas.
Solo resta probar la configuración del editor para modo gráfico con un Hola mundo
sencillo, que Grafica Figuras Geométricas, líneas, texto, colores y rellenos. El
programa incluye comentarios explicativos en cada línea de código, se sugiere
que estos comentarios los elimine para evitar que pueda generarle algún tipo de
error de compilación.
Progra32.cpp
gotoxy(1,23);printf("getmaxx()=%d",getmaxx());
gotoxy(1,24);printf("getmaxy()=%d",getmaxy());
setcolor(YELLOW); // Establece el color amarillo para los trazos
line(0,0,50,50); // Dibuja una linea desde 0,0 hasta 50,50
setcolor(WHITE); //Establece el color blanco
circle(100,200,30); // Dibuja un circulo el centro está en 100,200 y de
// radio=30 pixeles
140
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
141
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Introducción
142
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
La raíz de este árbol es A y el árbol izquierdo está conformado por dos árboles.
Uno de raíz B tal como se muestra en la figura 59. Y el otro de raíz I tal como se
muestra en la figura 60.
Los dos subárboles tienen a su vez dos subárboles cada uno, donde C y F son la
raíces de los arboles del sub árbol izquierdo. Mientras que las raíces de los
subárboles del subárbol derecho son J y M respectivamente, tal como se visualiza
en la figura 60.
143
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Hermano: Nos referimos al caso 3 del ejemplo anterior. Los hermanos son los
hijos de un mismo padre. Los nodos B y C son hermanos. El nodo D no tiene
Hermanos.
144
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
El nodo C es una hoja mientras que el nodo B no se puede considerar como hoja
porque tiene una ramificación por la derecha. El nodo D también es una hoja.
Nodo no terminal: Un nodo no terminal es aquel que posee por lo menos una
ramificación. En el ejemplo anterior, el nodo A o el nodo B son nodos no
terminales, mientras el nodo D o el nodo C son nodos terminales.
Camino: Un árbol siempre se examina de arriba hacia abajo. Por Ejemplo:
A ------- D ------ F
145
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Nivel: Cada nodo tiene un nivel dentro de un árbol binario. Por definición el nodo
raíz tiene un nivel 0 y los demás nodos tienen el nivel de su padre más 1. Por esto
los nodos que son hijos del nodo raíz tienen un nivel 1.
146
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Altura: La altura de un árbol binario es el nivel de la hoja o de las hojas que están
más distantes de la raíz. Basándose en la figura 65 de la gráfica anterior, la altura
del árbol cuya raíz es A, corresponde a la longitud del camino para llegar a la hoja
G que es más distante de la raíz, En este caso será 3.
Árbol Binario completo: Un árbol binario completo es aquel en el que todo nodo
no terminal tiene sus dos hijos. El siguiente es un árbol binario completo de nivel 3
147
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Obsérvese que todos los nodos no terminales tienen sus dos hijos. El máximo
número de nodos que puede tener un árbol de nivel n puede representarse con la
siguiente ecuación matemática:
2°+2¹+2²+2³...+2n
Si n es 3 entonces:
2°+2¹+2²+2³ = 15
Estos árboles son iguales porque sus raíces son iguales y también lo son su
respectivo árbol izquierdo y derecho. Para que un árbol sea igual a otro, es
necesario que el contenido de cada uno de sus respectivos nodos sea el mismo y
que tengan las mismas relaciones de parentesco.
148
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Estos árboles son semejantes. Contienen los mismos valores en cada uno de sus
nodos.
Árbol Binario Isomorfo: Dos árboles binarios son isomorfos si tienen la misma
estructura aunque el contenido de cada uno de sus nodos sea diferente. Por
ejemplo los siguientes árboles son isomorfos.
Los árboles binarios, son estructuras de datos no lineales, son considerados como
estructuras jerárquicas y como tal su forma de recorrerlos difiere sustancialmente
en comparación con las listas enlazadas que son estructuras de datos de tipo
149
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Recorrido en Preorden
Recorrer un árbol en preorden consiste en primer lugar, examinar el dato del nodo
raíz, posteriormente se recorrer el subárbol izquierdo en preorden y finalmente se
recorre el subárbol derecho en preorden. Esto significa que para cada subárbol se
debe conservar el recorrido en preorden, primero la raíz, luego la parte izquierda y
posteriormente la parte derecha.
Otro ejemplo de recorrido en preorden, donde sus nodos son de tipo numérico
para el siguiente árbol binario de la figura 71.
150
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Recorrido en Inorden
Finalizado el recorrido del subárbol izquierdo se visita el nodo de la raíz, que para
este caso es el numero 10.
151
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Por último solo queda describir la tercera forma de recorrer un árbol binario.
Recorrido en Postorden
Manos a la obra…
152
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Solo queda recorrer la raíz del árbol que para este caso es el número 10.
153
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Preorden: P Q S T R U W X V Y Z
Inorden: S Q T P W U X R Y V Z
Postorden: S T Q P W X U Y Z V R P
Los árboles binarios de búsqueda, son un tipo especial de árbol binario cuya
característica radica en la forma ordenada de insertar sus elementos, facilitando
así la búsqueda de un nodo en particular. Para puntualizar aun más, se tratarán
los árboles binarios de búsqueda, en los que se tiene preestablecido un cierto
orden, que seguramente ayudará a encontrar un cierto dato dentro de un árbol con
mucha rapidez.
Manos a la obra…
Se tienen los siguientes datos de tipo numérico para crear con ellos un árbol
binario de búsqueda.
154
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
El primer nodo siempre será asignado a la raíz del árbol binario de búsqueda, así
que para este caso el 5 es la raíz del árbol.
5
Primer número: 5 (directo)
5
/
3
5
/ \
3 7
5
/ \
3 7
/
2
5
/ \
3 7
/ \
2 4
Sexto número: 8 (8 es mayor que 5 y mayor que 7) en este caso se ingresa al lado
derecho de 7.
155
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
5
/ \
3 7
/ \ \
2 4 8
5
/ \
3 7
/ \ \
2 4 8
\
9
Para este tipo de árbol es muy evidente la rapidez con que se podría encontrar un
el valor de un nodo; para este caso se tienen 7 elementos de tipo numérico no
ordenados, lo que en una lista supone que si se busca un dato que casualmente
está al final, se harían 7 comparaciones; en este árbol, dado que este árbol es de
altura 4, se tienen que realizar 4 comparaciones como máximo.
156
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Fuente: http://www.conclase.net/c/edd/index.php?cap=007
Borrar un nodo rama con intercambio de un nodo rama
Para este ejemplo se tiene otro árbol. En éste se borrará el elemento 6.
157
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Fuente: http://www.conclase.net/c/edd/index.php?cap=007
Fuente: http://www.conclase.net/c/edd/index.php?cap=007
158
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Fuente: http://www.conclase.net/c/edd/index.php?cap=007
Progra34.cpp
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <ctype.h>
#include <iostream.h>
struct arbol
{
int dato;
struct arbol *izq;
struct arbol *der;
}*raiz;
/*PROTOTIPOS*/
8
Tomado de: http://ldcastillo.wordpress.com/tema-4-arboles-binarios/
159
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
struct arbol *insertar( struct arbol *raiz, struct arbol *hoja, int num )
{
if( !hoja )
{
hoja= (struct arbol *) malloc( sizeof (struct arbol) );
hoja->dato= num;
hoja->izq= NULL;
hoja->der= NULL;
if( !raiz ) return hoja;
else if( num<raiz->dato ) raiz->izq= hoja;
160
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
(*cont)++;
auxnodos( hoja->izq, cont );
auxnodos( hoja->der, cont );
}
161
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
podar( hoja->izq );
podar( hoja->der );
free( hoja );
hoja= NULL;
return hoja;
}
162
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
/*Recorridos*/
void preorden( struct arbol *hoja )
{
if( !hoja ) return;
inorden( hoja->izq );
cout <<hoja->dato ;
inorden( hoja->der );
}
posorden( hoja->izq );
posorden( hoja->der );
cout <<hoja->dato ;
}
while( _op!='4' )
{
clrscr();
cout << "1. PreOrden." ;
cout << "\n2. InOrden." ;
cout << "\n3. PosOrden." ;
cout << "\n4. Salir." ;
cout << "\n\n:: " ;
_op= getch();
switch( _op )
{
case '1':
163
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
preorden( raiz );
getch();
break;
case '2':
inorden( raiz );
getch();
break;
case '3':
posorden( raiz );
getch();
break;
}
}
return;
}
while( _op!='3' )
{
clrscr();
cout << "1. Podar Un Nodos del Arbol." ;
cout << "\n2. Podar Todo el Arbol." ;
164
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
int main()
{
char _op='A';
int val;
inicializar();
while( _op!='S' )
{
clrscr();
cout << "IMPLEMENTACION DE UN ARBOL BINARIO \n\n";
cout << "Insertar" ;
cout << "\nRecorridos" ;
cout << "\nBusquedas" ;
cout << "\nNodos" ;
cout << "\nPodar" ;
cout << "\nSalir" ;
cout << "\n\n Ingrese la Opcion : " ;
_op= toupper( getch() );
switch( _op )
{
case 'I':
cout << "\n\nNumero: " ;
cin>> val ;
if( busqueda( raiz, val ) )
165
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
{
cout << "\n\nEste numero ya ha sido insertado." ;
getch();
break;
}
raiz= insertar( raiz, raiz, val );
break;
case 'R':
if( vacio( raiz ) )
{
cout << "\n\nEl Arbol Aun esta Vacio." ;
getch();
break;
}
menu_recorridos();
break;
case 'B':
if( vacio( raiz ) )
{
cout << "\n\nEl Arbol Aun esta Vacio." ;
getch();
break;
}
menu_busquedas();
break;
case 'A':
if( vacio( raiz ) )
{
cout << "\n\nEl Arbol Aun esta Vacio." ;
getch();
break;
}
case 'N':
if( vacio( raiz ) )
{
cout << "\n\nEl Arbol Aun esta Vacio." ;
getch();
break;
}
menu_nodos();
break;
case 'P':
if( vacio( raiz ) )
{
cout << "\n\nEl Arbol Aun esta Vacio." ;
166
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
getch();
break;
}
menu_podar();
break;
}
}
cout << "\n\nPulsa para salir..." ;
getchar();
return 0;
}
El siguiente programa llamado progra35, fue realizado por Carlos Javier Guzmán,
estudiante del programa de Ingeniería de Sistemas de la UNAD en el CEAD de
Popayán
Progra35.cpp
//Autor: Carlos Javier Guzmán
//Estudiante de Ingeniería de Sistemas del CEAD de Popayán
#include <graphics.h>
#include <iostream.h>
#include <string.h>
167
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
#include <dos.h>
#include <conio.h>
#include <stdlib.h>
void cajadetexto_a(int x,int y,int ancho,int altura);
int iniciagrafica();
int linea_iz(int tx, int px1, int py1, int ty, int px2, int py2);
int linea_der(int tx, int px1, int py1, int ty, int px2, int py2);
int presentacion();
int ordenar();
int texto(); //para textos
int verificar(int z); //analiza cuando hijos pueden haber
main()
{
// int z;
iniciagrafica();
setbkcolor(DARKGRAY); //color de fondo de pantalla
setfillstyle(SOLID_FILL,LIGHTGRAY); //fondo de la ventana grande
bar3d(620,470,5,20,10,30);//x/y/px1/py1/an //ventana grande
presentacion();
cajadetexto_a(280,30,30,30);//px,py,largo,ancho A
outtextxy(292,42,"A");
ordenar();
getch();
}
int iniciagrafica()
{
int gdriver = DETECT, gmode, errorcode;
initgraph(&gdriver, &gmode, "c:\\tc\\bgi");
}
int ordenar()
{
int A,B,D,G,C,M,P,x;
texto(); //llama la caja de texto
outtextxy(55,388,"Cuandos hijos tiene A ");
gotoxy(31,25);
168
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
cin>>x;
texto();// llama caja de texto para no spbrescribir
A=verificar(x);
if(B==2) //D y G
{
setcolor(5);
linea_iz(60,133,110, 75,72,109); //izquierda entre d y b
cajadetexto_a(60,190,30,30);//px,py,largo,ancho iszquierda 1 D
outtextxy(73,200,"D"); // D
setcolor(5);
linea_der(57,164,110, 75,220,109);//izquierdo entre g y b
cajadetexto_a(207,190,30,30);//px,py,largo,ancho iszquierda 2 G
169
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
outtextxy(220,200,"G"); //G
}
outtextxy(55,388,"Cuandos hijos tiene D ");
gotoxy(31,25);
cin>>x;
texto();// llama caja de texto para no sobrescribir
D=verificar(x);
if(D==1)//D
{
setcolor(5);
linea_iz(34,55,198, 55,22,198); //izquierda entre e y d
cajadetexto_a(10,250,30,30);//px,py,largo,ancho iszquierda 1.1 E
outtextxy(23,263,"E");
}
if(D==2) //E Y F
{
setcolor(5);
linea_iz(34,55,198, 55,22,198); //izquierda entre e y d
cajadetexto_a(10,250,30,30);//px,py,largo,ancho iszquierda 1.1 E
outtextxy(23,263,"E");
setcolor(5);
linea_der(28,87,198, 55,114,197);//izquierdo entre f y d
cajadetexto_a(100,250,30,30);//px,py,largo,ancho iszquierda 1.2 F
outtextxy(113,263,"F");
}
if(B==2)
{
outtextxy(55,388,"Cuandos hijos tiene G ");
gotoxy(31,25);
cin>>x;
texto();// llama caja de texto para no sobrescribir
G=verificar(x);
if(G==1) //H
{
setcolor(5);
linea_iz(30,203,199, 45,173,199); //izquierda entre h y g
cajadetexto_a(160,250,30,30);//px,py,largo,ancho iszquierda 2.1 H
outtextxy(173,263,"H");
setcolor(5);
170
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
}
if(G==2) // H y I
{
setcolor(5);
linea_iz(30,203,199, 45,173,199); //izquierda entre h y g
cajadetexto_a(160,250,30,30);//px,py,largo,ancho iszquierda 2.1 H
outtextxy(173,263,"H");
setcolor(5);
linea_der(28,234,199, 47,261,198);//izquierdo entre i y g
cajadetexto_a(250,250,30,30);//px,py,largo,ancho iszquierda 2.2 I
outtextxy(263,263,"I");
}
}
} //termina lado izquierdo
if(A==2)
{
outtextxy(55,388,"Cuandos hijos tiene C ");
gotoxy(31,25);
cin>>x;
texto();// llama caja de texto para no sobrescribir
C=verificar(x);
if(C==1)
{
setcolor(13);
linea_der(55,466,110, 75,520,109);//izquierdo entre c y p
setcolor(13);
cajadetexto_a(510,190,30,30);//px,py,largo,ancho derecha 4 P
outtextxy(522,200,"P");
}
if(C==2)
{
setcolor(13);
linea_iz(57,435,110, 75,378,109); //izquierda entre m y c
setcolor(13);
cajadetexto_a(367,190,30,30);//px,py,largo,ancho dercha 3 M
outtextxy(379,200,"M");
setcolor(13);
linea_der(55,466,110, 75,520,109);//izquierdo entre c y p
171
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
setcolor(13);
cajadetexto_a(510,190,30,30);//px,py,largo,ancho derecha 4 P
outtextxy(522,200,"P");
}
outtextxy(55,388,"Cuandos hijos tiene P ");
gotoxy(31,25);
cin>>x;
texto();// llama caja de texto para no sobrescribir
P=verificar(x);
if(P==1)
{
setcolor(13);
linea_der(28,537,199, 47,564,198);//izquierdo entre z y p
cajadetexto_a(550,250,30,30);//px,py,largo,ancho derecha 4.2 Z
outtextxy(563,263,"Z");
}
if(P==2)
{
setcolor(13);
linea_iz(25,506,199, 45,482,199); //izquierda entre q y p
cajadetexto_a(470,250,30,30);//px,py,largo,ancho derecha 4.1 Q
outtextxy(482,263,"Q");
setcolor(13);
linea_der(28,537,199, 47,564,198);//izquierdo entre z y p
cajadetexto_a(550,250,30,30);//px,py,largo,ancho derecha 4.2 Z
outtextxy(563,263,"Z");
}
if(C==2)
{
outtextxy(55,388,"Cuandos hijos tiene M ");
gotoxy(31,25);
cin>>x;
texto();// llama caja de texto para no sobrescribir
M=verificar(x);
if(M==1)
{
setcolor(13);
linea_iz(33,364,199, 45,332,199); //izquierda entre n y m
cajadetexto_a(320,250,30,30);//px,py,largo,ancho derecha 3.1 N
172
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
outtextxy(332,263,"N");
}
if(M==2)
{
setcolor(13);
linea_iz(33,364,199, 45,332,199); //izquierda entre n y m
cajadetexto_a(320,250,30,30);//px,py,largo,ancho derecha 3.1 N
outtextxy(332,263,"N");
setcolor(13);
linea_der(28,394,199, 47,422,198);//izquierdo entre o y m
cajadetexto_a(410,250,30,30);//px,py,largo,ancho derecha 3.2 O
outtextxy(422,263,"O");
}
}
} //termina A=2
}//termina funcion ordenar
int linea_iz(int tx, int px1, int py1, int ty, int px2, int py2)
{
for(int i=1; i<tx; i++)
{
outtextxy(px1-i,py1,".");
delay(15);
}
173
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
int linea_der(int tx, int px1, int py1, int ty, int px2, int py2)
{
for(int i=1; i<tx; i++)
{
outtextxy(px1+i,py1,".");
delay(15);
}
for(i=1; i<ty; i++)
{
outtextxy(px2,i+py2,".");
delay(15);
}
}
int presentacion()
{
cajadetexto_a(12,25,130,30);//px,py,largo,ancho A cuadro de mensaje arbo
cajadetexto_a(482,25,130,30);//px,py,largo,ancho A cuadro de mensaje carlos
sleep(1);
setcolor(11);
outtextxy(15,32,"Arboles");
sleep(1);
outtextxy(68,44,"Binarios");
sleep(1);
setcolor(11);
outtextxy(495,32,"Carlos Javier");
sleep(1);
outtextxy(524,44,"Guzman");
}
int texto()
{
174
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
cajadetexto_a(50,375,180,30);//px,py,largo,ancho A
cajadetexto_a(230,375,30,30);//px,py,largo,ancho A
}
int verificar(int z)
{
int n,d;
n=z;
while(n<=0 || n>=3)
{
outtextxy(60,386,"Dato errado, ingrese ");
outtextxy(64,393,"otro dato ");
gotoxy(31,25);
cin>>n;
texto();// llama caja de texto para no sobrescribir
}
if(n==1 || n==2)
{
return n;
}
return n;
}
Actividad de verificación
175
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
CAPITULO 3: GRAFOS
Introducción
Los grafos al igual que los árboles son estructuras de datos de no lineales,
semejada a una estructura de tipo jerárquico. En el presente capítulo se abordan
los temas relacionados con los conceptos básicos de grafos, incluyendo la teoría
general de grafos e identificando la forma de recorrerlos. Así como también la
documentación de los tipos de grafos y la representación a través de matriz de
adyacencia y de listas de adyacencia especialmente.
Definición grafos
Aristas: son consideradas las uniones entre los nodos o vértices, véase la primera
figura 80, donde las aristas representan la unión entre ciudades. Generalmente
las aristas denotan relaciones entre los vértices. Las aristas, junto con los vértices
forman los elementos principales de un grafo.
177
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Fuente: http://www.slideshare.net/pilypardo/grafos-1407276
Fuente: http://www.slideshare.net/pilypardo/grafos-1407276
Costos: Los enlaces tanto para los grafos dirigidos como para los grafos no
dirigidos tienen un peso, costo o valor, por lo que se conocen como grafos
178
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
etiquetados. Para ampliar este concepto se puede visualizar la figura 83. Que se
muestra a continuación.
Fuente: http://www.slideshare.net/pilypardo/grafos-1407276
Grafos Completos: es aquel con una arista entre cada par de vértices, es decir
un grafo con todas las aristas posibles. Por otra parte, se denominan grafos
densos aquellos que tienen muchas aristas.
Grafo nulo: Se dice que un grafo es nulo cuando los vértices que lo componen no
están conectados, esto es, que son vértices aislados.
Grafos Isomorfos: Dos grafos son isomorfos cuando existe una correspondencia
biunívoca (uno a uno), entre sus vértices de tal forma que dos de estos quedan
unidos por una arista en común.
Matriz de adyacencia
Lista de adyacencia
Arreglos para listas de adyacencias
V = {1,2,3,4}
E = {(1,2),(2,3),(3,1), ((4,2),(3,4)}
180
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
http://www.slideshare.net/pilypardo/grafos-1407276
Fuente: http://www.slideshare.net/pilypardo/grafos-1407276
181
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
peso) tanto la entrada a[i][j] como la entrada a[j][i], puesto que se puede recorrer
en ambos sentidos.
int V,A;
int a[maxV][maxV];
void inicializar()
{
int i,x,y,p;
char v1,v2;
// Leer V y A
memset(a,0,sizeof(a));
for (i=1; i<=A; i++)
{
Cout <<"\n" <<v1 <<v2 <<p;
x=v1-'A'; y=v2-'A';
a[x][y]=p; a[y][x]=p;
}
}
En esta implementación se ha supuesto que los vértices se nombran con una letra
mayúscula y no hay errores en la entrada. Evidentemente, cada problema tendrá
una forma de entrada distinta y la inicialización será conveniente adaptarla a cada
situación. En todo caso, esta operación es sencilla si el número de nodos es
pequeño. Si, por el contrario, la entrada fuese muy grande se pueden almacenar
los nombres de nodos en un árbol binario de búsqueda o utilizar una tabla de
dispersión, asignando un entero a cada nodo, que será el utilizado en la matriz de
adyacencia.
9
Tomado de: http://www.algoritmia.net/articles.php?id=18
182
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Es fácil determinar si existe un ciclo en el grafo, solo basta con multiplicar la matriz
por ella mismo n veces hasta obtener la matriz nula (no hat ciclos) o bien una
sucesión periodica de matrices (hay ciclo).
En las listas de adyacencia para un vértice v es unas listas enlazadas de todos los
vértices w adyacentes a v. Un grafo puede estar representado por un |v|, listas de
adyacencia, una para cada vértice.
Fuente: http://www.slideshare.net/pilypardo/grafos-1407276
“En las listas de adyacencia lo que se haga será guardado por cada nodo, además
de la información que pueda contener el propio nodo, una lista dinámica con los
nodos a los que se puede acceder desde él. La información de los nodos se puede
guardar en un vector, al igual que antes, o en otra lista dinámica.
Las listas de adyacencia serán estructuras que contendrán un valor entero (el
número que identifica al nodo destino), así como otro entero que indica el coste en
el caso de que el grafo sea ponderado. En el ejemplo siguiente se ha utilizado una
estructura con un nodo z ficticio en la cola.
struct nodo
{
int v;
183
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
int p;
nodo *sig;
};
int V,A; // vértices y aristas del grafo
struct nodo *a[maxV], *z;
void inicializar()
{
int i,x,y,peso;
char v1,v2;
struct nodo *t;
z=(struct nodo *)malloc(sizeof(struct nodo));
z->sig=z;
for (i=0; i<V; i++)
a[i]=z;
for (i=0; i<A; i++)
{
cout <<”\n" <<v1<<v2<<peso;
x=v1-'A'; y=v2-'A';
t=(struct nodo *)malloc(sizeof(struct nodo));
t->v=y; t->p=peso; t->sig=a[x]; a[x]=t;
t=(struct nodo *)malloc(sizeof(struct nodo));
t->v=x; t->p=peso; t->sig=a[y]; a[y]=t;
}
}
En este caso el espacio ocupado es O(V + A), muy distinto del necesario en la
matriz de adyacencia, que era de O(V2). La representación por listas de
adyacencia, por tanto, será más adecuada para grafos dispersos.
184
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
insertarlo en una posición adecuada), de manera que el algoritmo mismo diera las
soluciones ya ordenadas”10.
Se utiliza bastante cuando el número de enlaces es mucho menor que O(n 2).
En primer lugar, una forma sencilla de recorrer los vértices es mediante una
función recursiva, lo que se denomina búsqueda en profundidad. La sustitución
de la recursión (cuya base es la estructura de datos pila) mientras que el segundo
método de búsqueda o recorrido, la búsqueda en amplitud o anchura lo
proporciona una cola.
10
Tomado de: http://www.algoritmia.net/articles.php?id=18
185
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Fuente: http://www.algoritmia.net/articles.php?id=18
En este ejemplo hay que tener en cuenta que es fundamental el orden en que los
nodos están almacenados en las estructuras de datos. Si, por ejemplo, el nodo D
estuviera antes que el C, en la búsqueda en profundidad se tomaría primero la
rama del D (con lo que el último en visitarse sería el C), y en la búsqueda en
anchura se exploraría antes el H que el G.
A-B-E-I-F-C-G-J-K-H-D
A-B-C-D-E-G-H-I-J-K-F
Búsqueda en profundidad
Se implementa de forma recursiva, aunque también puede realizarse con una pila.
Se utiliza un array val para almacenar el orden en que fueron explorados los
vértices. Para ello se incrementa una variable global id (inicializada a 0) cada vez
que se visita un nuevo vértice y se almacena id en la entrada del array val
correspondiente al vértice que se está explorando.
La siguiente función realiza un máximo de V (el número total de vértices) llamadas
a la función visitar, que implementamos aquí en sus dos variantes: representación
por matriz de adyacencia y por listas de adyacencia.
186
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
int id=0;
int val[V];
void buscar()
{
int k;
for (k=1; k<=V; k++)
val[k]=0;
for (k=1; k<=V; k++)
if (val[k]==0) visitar(k);
}
void visitar(int k) // matriz de adyacencia
{
int t;
val[k]=++id;
for (t=1; t<=V; t++)
if (a[k][t] && val[t]==0) visitar(t);
}
void visitar(int k) // listas de adyacencia
{
struct nodo *t;
val[k]=++id;
for (t=a[k]; t!=z; t=t->sig)
if (val[t->v]==0) visitar(t->v);
}
val[1]=3;
val[2]=1;
187
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
val[3]=2;
val[4]=4;
11
Tomado de: http://www.algoritmia.net/articles.php?id=18 consultado en Junio 10 de 2009
188
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
Ejercicio 7. Implemente un árbol binario por medio del entorno gráfico de C++, de
tal manera que se pueda gestionar la teoría de un árbol binario (Creación y
visualización del árbol, al igual que los tres recorridos Inorden, Preorden,
Posorden, altura del árbol, el grado).
Ejercicio 8. Implemente un grafo por medio del entorno gráfico de C++, de tal
manera que se pueda gestionar la teoría de grafos (Creación y visualización del
grafo, al igual que imprima los dos recorridos en profundidad y en amplitud).
189
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
190
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD
ESCUELA DE CIENCIAS BÁSICAS TECNOLOGÍA E INGENIERÍA
CONTENIDO DIDÁCTICO DEL CURSO: 301305 – ESTRUCTURA DE DATOS
191