INDICE

MAESTRO:

PRESENTAN:

MATERIA:

ESTRUCTURA DE DATOS

TRABAJO:

UNIDAD 4

ESTRUCTURAS NO LINEALES

FECHA DE ENTREGA:

ContenidoINDICE................................................................................................................................................2

INTRODUCCION..................................................................................................................................3

OBJETIVO............................................................................................................................................4

ESTRUCTURAS NO LINEALES ARBOLES Y GRAFOS..............................................................................5

ESTRUCTURAS NO LINEALES: ARBOLES..............................................................................................5

CLASIFICACIÓN DE ARBOLES..............................................................................................................9

ÁRBOL BINARIO DE BÚSQUEDA......................................................................................................9

APLICACIONES DE ÁRBOLES BINARIOS.............................................................................................10

ESTRUCTURAS NO LINEALES: GRAFOS.............................................................................................11

CLASIFICACIÓN DE GRAFOS..............................................................................................................12

OPERACIONES SOBRE GRAFOS.........................................................................................................13

IMPLEMENTACIÓN DE EL TDA GRAFO..............................................................................................14

LISTA DE PRIMITIVAS................................................................................................................14

IMPLEMENTACIÓN DE LAS PRIMITIVAS....................................................................................15

CONCLUSIONES................................................................................................................................21

GLOSARIO.........................................................................................................................................22

REFERENCIAS....................................................................................................................................23

INTRODUCCION 

2

El siguiente trabajo trata sobre la estructura de datos no lineales llamada árbol. Esta estructura se usa principalmente para representar datos con una relación jerárquica entre sus elementos, como por ejemplo registros, árboles genealógicos, y tablas de contenidos. Vamos a profundizar en un tipo especial de árbol llamado árbol binario, la cual puede ser implementada fácilmente en la computadora; aunque en un árbol puede parecer muy restrictivo. Entre estos tenemos a la terminología, los árboles binarios complementos, árboles binarios de búsqueda, búsqueda e inserción en árboles binarios de búsqueda, árboles generales, representación de árboles generales en la computadora y correspondencia entre los árboles generales y árboles binarios.

Hoy en día podemos ver muchas cosas que nos pueden parecer de lo mas cotidianas, carreteras, líneas telefónicas, líneas de televisión por cable, el transporte colectivo metro, circuitos eléctricos de nuestras casas, automóviles, y tantas cosas mas; lo que no pensamos frecuentemente es que estos forman parte de algo que en matemáticas se denomina como grafos.

En este trabajo se tratará de explicar lo que son los grafos, sus tipos, y algunas derivaciones de ellos, así como su representación gráfica y en algunos casos, su representación en algún programa informático, así como en la memoria.

3

OBJETIVO

El objetivo del siguiente trabajo es definir el concepto de las estructuras no lineales los arboles y grafos.

Para que el concepto de cada uno de ellos quede resuelto, así como para que se usen y de que forma pueden aplicarse en la vida cotidiana, también se va a ampliar sobre árboles más generales y puntos con relación a los árboles binarios; y la relación que tienen los arboles con los grafos.

4

ESTRUCTURAS NO LINEALES ARBOLES Y GRAFOS

ESTRUCTURAS NO LINEALES: ARBOLES

En ciencias de la computación, un árbol es una estructura de datos ampliamente usada que emula la forma de un árbol (un conjunto de nodos conectados). Un nodo es la unidad sobre la que se construye el árbol y puede tener cero o mas nodos hijos conectados a él. Se dice que un nodo a es padre de un nodo b, si existe un enlace desde a hasta b (en ese caso, también decimos que b es hijo de a). Sólo puede haber un único nodo sin padres, que llamaremos raíz. Un nodo que no tiene hijos se conoce como hoja.

El árbol También se define como una estructura de datos no lineal. Esta estructura se usa principalmente para representar datos con una relación jerárquica entre sus elementos, como por ejemplo registros, árboles genealógicos y tablas de contenidos. Entre otros tenemos un tipo especial de árbol que es, llamado árbol binario, que puede ser implementado fácilmente en la computadora.

Un árbol es una estructura no lineal en la que cada nodo puede apuntar a uno o varios nodos.

También se suele dar una definición recursiva: un árbol es una estructura en compuesta por un dato y varios árboles.

Esto son definiciones simples. Pero las características que implican no lo son tanto.

Definiremos varios conceptos. En relación con otros nodos:

Nodo hijo: cualquiera de los nodos apuntados por uno de los nodos del árbol. En el ejemplo, 'L' y 'M' son hijos de 'G'.

5

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 trabajaremos 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.

En cuanto a la posición dentro del árbol:

Nodo raíz: nodo que no tiene padre. Este es el nodo que usaremos para referirnos al árbol. En el ejemplo, ese nodo es el 'A'.

Nodo hoja: nodo que no tiene hijos. En el ejemplo hay varios: 'F', 'H', 'I', 'K', 'L', 'M', 'N' y 'O'.

Nodo rama: aunque esta definición apenas la usaremos, estos son los nodos que no pertenecen a ninguna de las dos categorías anteriores. En el ejemplo: 'B', 'C', 'D', 'E', 'G' y 'J'.

Otra característica que normalmente tendrán nuestros árboles es que todos los nodos contengan el mismo número de punteros, es decir, usaremos la misma estructura para todos los nodos del árbol. Esto hace que la estructura sea más sencilla, y por lo tanto también los programas para trabajar con ellos.

Tampoco es necesario que todos los nodos hijos de un nodo concreto existan. Es decir, que pueden usarse todos, algunos o ninguno de los punteros de cada nodo.

Un árbol en el que en cada nodo o bien todos o ninguno de los hijos existe, se llama árbol completo.

En una cosa, los árboles se parecen al resto de las estructuras que hemos visto: dado un nodo cualquiera de la estructura, podemos considerarlo como una estructura independiente. Es decir, un nodo cualquiera puede ser considerado como la raíz de un árbol completo.

Existen otros conceptos que definen las características del árbol, en relación a su tamaño:

Orden: es el número potencial de hijos que puede tener cada elemento de árbol. De este modo, diremos que un árbol en el que cada nodo puede apuntar a otros dos es de orden dos, si puede apuntar a tres será de orden tres, etc.

Grado: el número de hijos que tiene el elemento con más hijos dentro del árbol. En el árbol del ejemplo, el grado es tres, ya que tanto 'A' como 'D' tienen tres hijos, y no existen elementos con más de tres hijos.

6

Nivel: se define para cada elemento del árbol como la distancia a la raíz, medida en nodos. El nivel de la raíz es cero y el de sus hijos uno. Así sucesivamente. En el ejemplo, el nodo 'D' tiene nivel 1, el nodo 'G' tiene nivel 2, y el nodo 'N', nivel 3.

Altura: la altura de un árbol se define como el nivel del nodo de mayor nivel. Como cada nodo de un árbol puede considerarse a su vez como la raíz de un árbol, también podemos hablar de altura de ramas. El árbol del ejemplo tiene altura 3, la rama 'B' tiene altura 2, la rama 'G' tiene altura 1, la 'H' cero, etc.

Los árboles de orden dos son bastante especiales, de hecho les dedicaremos varios capítulos. Estos árboles se conocen también como árboles binarios.

Frecuentemente, aunque tampoco es estrictamente necesario, para hacer más fácil moverse a través del árbol, añadiremos un puntero a cada nodo que apunte al nodo padre. De este modo podremos avanzar en dirección a la raíz, y no sólo hacia las hojas.

Es importante conservar siempre el nodo raíz ya que es el nodo a partir del cual se desarrolla el árbol, si perdemos este nodo, perderemos el acceso a todo el árbol.

El nodo típico de un árbol difiere de los nodos que hemos visto hasta ahora para listas, aunque sólo en el número de nodos. Veamos un ejemplo de nodo para crear árboles de orden tres:

struct nodo \{ int dato; struct nodo *rama1; struct nodo *rama2; struct nodo *rama3;};

O generalizando más:

#define ORDEN 5

struct nodo \{ int dato; struct nodo *rama[ORDEN];};

7

Para C, y basándonos en la declaración de nodo que hemos visto más arriba, trabajaremos con los siguientes tipos:

typedef struct _nodo \{ int dato; struct _nodo *rama[ORDEN];} tipoNodo; typedef tipoNodo *pNodo;typedef tipoNodo *Arbol;

Al igual que hicimos con las listas que hemos visto hasta ahora, declaramos un tipo tipoNodo para declarar nodos, y un tipo pNodo para es el tipo para declarar punteros a un nodo.

Arbol es el tipo para declarar árboles de orden ORDEN.

El movimiento a través de árboles, salvo que implementemos punteros al nodo padre, será siempre partiendo del nodo raíz hacia un nodo hoja. Cada vez que lleguemos a un nuevo nodo podremos optar por cualquiera de los nodos a los que apunta para avanzar al siguiente nodo.

En general, intentaremos que exista algún significado asociado a cada uno de los punteros dentro de cada nodo, los árboles que estamos viendo son abstractos, pero las aplicaciones no tienen por qué serlo. Un ejemplo de estructura en árbol es el sistema de directorios y ficheros de un sistema operativo. Aunque en este caso se trata de árboles con nodos de dos tipos, nodos directorio y nodos fichero, podríamos considerar que los nodos hoja son ficheros y los nodos rama son directorios.

Otro ejemplo podría ser la tabla de contenido de un libro, por ejemplo de este mismo curso, dividido en capítulos, y cada uno de ellos en subcapítulos. Aunque el libro sea algo lineal, como una lista, en el que cada capítulo sigue al anterior, también es posible acceder a cualquier punto de él a través de la tabla de contenido.

8

También se suelen organizar en forma de árbol los organigramas de mando en empresas o en el ejército, y los árboles genealógicos.

CLASIFICACIÓN DE ARBOLES

Clasificación de arboles binarios:

1.-arbol binario distinto: Se dice que un árbol es distinto cuando su estructura grafica es diferente.

2.-arbol binario similar.- Se dice que un árbol es similar cuando su estructura grafica es idéntica pero la información que contiene entre sus nodos es diferente.

3.-arbol binario equivalente.-Son aquellos que su estructura grafica es idéntica pero además la información entre sus nodos.

4.-arbol binario completo.-son aquellos que todos nos nodos excepto el ultimo nivel tienen sus dos hijos.

5.-arbol binario lleno: es aquel que tiene su número máximo de posibles nodos.Se define un árbol binario como un conjunto finito de elementos (nodos) que bien esta vacío o esta formado por una raíz con dos arboles binarios disjuntos, es decir, dos descendientes directos llamados subarbol izquierdo y subarbol derecho.

Los árboles binarios (también llamados de grado 2) tienen una especial importancia.

Las aplicaciones de los arboles binarios son muy variadas ya que se les puede utilizar para representar una estructura en la cual es posible tomar decisiones con dos opciones en distintos puntos.

ÁRBOL BINARIO DE BÚSQUEDA.

Los árboles binarios se utilizan frecuentemente para representar conjuntos de datos cuyos elementos se identifican por una clave única. Si el árbol está organizado de tal manera que la clave de cada nodo es mayor que todas las claves su subarbol izquierdo, y menor que todas las claves del subarbol derecho se dice que este árbol es un árbol binario de búsqueda.

9

APLICACIONES DE ÁRBOLES BINARIOS

Un árbol binario es una estructura de datos útil cuando se trata de hacer modelos de procesos en donde se requiere tomar decisiones en uno de dos sentidos en cada parte del proceso. Por ejemplo, supongamos que tenemos un arreglo en donde queremos encontrar todos los duplicados. Esta situación es bastante útil en el manejo de las bases de datos, para evitar un problema que se llama redundancia.

Una manera de encontrar los elementos duplicados en un arreglo es recorrer todo el arreglo y comparar con cada uno de los elementos del arreglo. Esto implica que si el arreglo tiene   elementos, se deben hacer   comparaciones, claro, no es mucho problema si   es un número pequeño, pero el problema se va complicando más a medida que   aumenta.

Si usamos un árbol binario, el número de comparaciones se reduce bastante, veamos cómo.

El primer número del arreglo se coloca en la raíz del árbol (como en este ejemplo siempre vamos a trabajar con árboles binarios, simplemente diremos árbol, para referirnos a un árbol binario) con sus subárbol es izquierdo y derecho vacíos. Luego, cada elemento del arreglo se compara son la información del nodo raíz y se crean los nuevos hijos con el siguiente criterio:

Si el elemento del arreglo es igual que la información del nodo raíz, entonces notificar duplicidad.

Si el elemento del arreglo es menor que la información del nodo raíz, entonces se crea un hijo izquierdo.

Si el elemento del arreglo es mayor que la información del nodo raíz, entonces se crea un hijo derecho.

Una vez que ya está creado el árbol, se pueden buscar los elementos repetidos. Si x el elemento buscado, se debe recorrer el árbol del siguiente modo:

10

Sea k la información del nodo actual p. Si   entonces cambiar el nodo actual a light(p), en caso contrario, en caso de que   informar una ocurrencia

duplicada y en caso de que  cambiar el nodo actual a left(p).

ESTRUCTURAS NO LINEALES: GRAFOS

Las estructuras de datos no lineales se caracterizan por no existir una relación de adyacencia, entre sus elementos, es decir, un elemento puede estar relacionado con cero, uno o más elementos. La estructura no lineal de datos más general es el grafo donde sus nodos pueden relacionarse de cualquier manera sin una relación de orden predefinida.

Entre las múltiples aplicaciones que tienen estas estructuras podemos mencionar:•Para modelar diversas situaciones tales como: sistemas de aeropuertos, flujo de tráfico, y responder a preguntas como: ¿Qué tiempo es más corto?, ¿Cómo es más barato?, o ¿Qué camino es más corto?•Los grafos también son utilizados para realizar planificación de actividades, tareas del computador, planificar operaciones en lenguaje de máquinas para minimizar tiempo de ejecución. Qué tarea debo hacer primero?.

•Para representar circuitos eléctricos, de aguas etc... , y preguntar, están todas las componentes conectadas

Un grafo está formado por un conjunto de nodos(o vértices) y un conjunto de arcos. Cada arco en un grafo se especifica por un par de nodos.

TERMINOLOGÍA

1. Al número de nodos del grafo se le llama orden del grafo.2. Un grafo nulo es un grafo de orden 0 (cero).3. Dos nodos son adyacentes si hay un arco que los une.4. En un grafo dirigido, si A es adyacente de B, no necesariamente B es

adyacente de A5. Camino es una secuencia de uno o mas arcos que conectan dos nodos.6. Un grafo se denomina conectado cuando existe siempre un camino que

une dos nodos cualesquiera y desconectado en caso contrario.7. Un grafo es completo cuando cada nodo esta conectado con todos y cada

uno de los nodos restantes.8. El camino de un nodo así mismo se llama ciclo.

11

CLASIFICACIÓN DE GRAFOS

Los grafos se pueden clasificar en dos grupos: dirigidos y no dirigidos. En un grafo no dirigido el par de vértices que representa un arco no está ordenado. Por lo tanto, los pares (v1, v2) y (v2, v1) representan el mismo arco. En un grafo dirigido cada arco está representado por un par ordenado de vértices, de forma que y representan dos arcos diferentes.

Ejemplos

G1 = (V1, A1)

V1 = {1, 2, 3, 4} A1 = {(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)}

G2 = (V2, A2)

V2 = {1, 2, 3, 4, 5, 6} A2 = {(1, 2), (1, 3), (2, 4), (2, 5), (3, 6)}

G3 = (V3, A3)

V3 = {1, 2, 3} A3 = { <1, 2>, <2, 1>, <2, 3> }

Gráficamente estas tres estructuras de vértices y arcos se pueden representar de la siguiente manera:

Algunos de los principales tipos de grafos son los que se muestran a continuación:

Grafo regular: Aquel con el mismo grado en todos los vértices. Si ese grado es k lo llamaremos k-regular.

12

Por ejemplo, el primero de los siguientes grafos es 3-regular, el segundo es 2-regular y el tercero no es regular

Grafo bipartito: Es aquel con cuyos vértices pueden formarse dos conjuntos disjuntos de modo que no haya adyacencias entre vértices pertenecientes al mismo conjunto

Ejemplo.- de los dos grafos siguientes el primero es bipartito y el segundo no lo es

Grafo completo: Aquel con una arista entre cada par de vértices. Un grafo completo con n vértices se denota Kn.

Un grafo bipartito regular: se denota Km, n donde m, n es el grado de cada conjunto disjunto de vértices.

A continuación ponemos los dibujos de K1, 2, K3, 3, y K2, 5

 

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.

OPERACIONES SOBRE GRAFOS

El algoritmo de dijkstra calcula la ruta óptima desde un vértice (x, vértice origen) a todos los demás vértices del grafo. Tiene como requisito que no existan longitudes/costes negativos. Se basa en la idea de la relajación de aristas (edge relajación), en la cual se mantiene información de cuál es la mejor distancia conocida de cualquier vértice al origen, y a medida que se va conociendo una distancia mejor desde el vértice j al origen, se actualizan las mejores distancias conocidas a todos los vértices adyacentes a j. en su desarrollo utiliza un enfoque

13

voraz: en un momento dado hay un conjunto de vértices, que llamaremos s, de los cuales se conoce la ruta óptima al origen y además son los más cercanos a él (cuando se hallen las rutas óptimas del resto de vértices ninguna tendrá una longitud menor que las de los vértices que están en s).

Del resto de los vértices (conjunto s’) no conocemos la ruta óptima, sino la mejor ruta encontrada hasta el momento (no tiene porqué ser la óptima).

Se puede visualizar el algoritmo imaginando que en cada momento tenemos un círculo centrado en el origen que contiene los vértices más cercanos. En cada paso ampliamos el círculo incluyendo el vértice de fuera más cercano (ampliamos por círculos concéntricos).

En cada paso se halla el vértice de s’ a menor distancia del origen y se obtiene su ruta óptima. Ese vértice se elimina de s’ y pasa a formar parte de s. en este punto aplicamos la relajación de aristas y actualizamos las mejores rutas de los vértices que quedan en s.

La clave para que éste algoritmo obtenga la solución óptima reside en que el vértice (llamémosle u) de s’ que se debe incorporar a s tiene que ser uno para el cual su ruta óptima vaya directamente de u a un vértice de s (llamémosle v), y su ruta óptima no puede ser una donde se vaya de u a un vértice w ∈ s’ ya que entonces (al no existir longitudes negativas), la ruta de u al origen.

IMPLEMENTACIÓN DE EL TDA GRAFO.

LISTA DE PRIMITIVAS.

Lista de primitivas para los grafos dirigidos:

Crear: Función que se encarga de crear un grafo vacio. Etiqueta: Función que devuelve la etiqueta asociada a un nodo en un grafo. Label: Función que devuelve la Label de un nodo en el grafo. LocalizaLabel: Esta función recibe el entero l (el label asociado a un nodo

que se supone pertenece al grafo y nos devuelve el nodo asociado con esa label.

ExisteArco: Función que devuelve 1 si existe un arco entre el nodo o y el nodo d en el grafo g, si no existe dicho arco devuelve 0.

PrimerArco: Devuelve el primer arco que sale del nodo n en el grafo g, si no existe dicho primer arco devuelve Nulo.

SiguienteArco: Función que devuelve el arco siguiente al arco a en el nodo n si no existe dicho arco devuelve Nulo.

PrimerArcoInv: Devuelve el primer arco que entra en el nodo n en el grafo g. Si no existe dicho arco devuelve Nulo.

14

SiguienteArcoInv: Devuelve el siguiente arco tras a que entra en el nodo n, si no existe dicho arco devuelve Nulo.

PrimerNodo: Devuelve el primer nodo del grafo G, si no existe devuelve nulo.

SiguienteNodo: Devuelve el nodo siguiente en orden al nodo n en el grafo g. Si no existe devuelve nulo.

NodoOrigen: Devuelve el nodo origen del arco a. NodoDestino: Devuelve el nodo destino del arco a. presentarGrafo: Escribe el grafo g en pantalla. NumeroNodos: Devuelve el numero de nodos de un grafo g. grafoVacio: Devuelve Nulo si el grafo esta vacio. EtiqArco: Funcion que devuelve la etiqueta asociada a un arco, es decir el

peso del arco. InsertarNodo: Funcion que inserta un nodo nuevo en un grafo. InsertarArco: Funcion que se encarga de insertar un arco entre el nodo org

y el dest en el grafo g, asociado al arco le podemos dar un valor. BorrarArco: Funcion que borra el arco existente entre los nodos org y dest. DesconectarNodo: Función que devuelve el grafo que se obtiene al eliminar

un nodo de un grafo G. Todos los arcos que entran o salen del nodo a eliminar también desaparecen.

Destruir: Función que destruye el grafo g liberando la memoria que ocupa. CopiarGrafo: Función que hace una copia del grafo g.

IMPLEMENTACIÓN DE LAS PRIMITIVAS.

tgrafo Crear(void){ tnodo aux; aux = (tnodo)malloc(sizeof(struct nodo)); if (aux == NULL) { error(\"Error en Crear.\"); } else { aux->nodo = 0;

aux->etiq = NULL; aux->ady = NULL; aux->inc = NULL; aux->sig = NULL; return aux;

}}tetiq Etiqueta(tnodo n, tgrafo g){ return(n->etiq);}int Label(tnodo n, tgrafo g){ return(n->nodo);

15

}tnodo LocalizaLabel(int l, tgrafo g){ tnodo n; int enc=0;

for (n=g->sig; n!=NULL && !enc; ) { if (n->nodo == l) enc = 1; else n = n->sig; } return n;}int ExisteArco(tnodo o, tnodo d, tgrafo g){ tarco a;

a=o->ady; while (a!=NULL) { if ((a->origen==o) && (a->destino==d)) return 1; else a = a->sig; } return 0;}tarco PrimerArco(tnodo n, tgrafo g){ return(n->ady);}tarco SiguienteArco(tnodo n, tarco a, tgrafo g){ return(a->sig);}tarco PrimerArcoInv(tnodo n, tgrafo g){ return(n->inc);}tarco SiguienteArcoInv(tnodo n, tarco a, tgrafo g){ return(a->sig);}tnodo PrimerNodo(tgrafo g){ return(g->sig);}tnodo SiguienteNodo(tnodo n, tgrafo g){ return(n->sig);}tnodo NodoOrigen(tarco a, tgrafo g){ return(a->origen);}tnodo NodoDestino(tarco a, tgrafo g){

16

return(a->destino);}void PresentarGrafo(tgrafo g){ tnodo n; tarco a;

n=PrimerNodo(g); while (n!=Nulo) { a=PrimerArco(n,g); while (a!=Nulo) { printf(\"%s -> %s \",a->origen->etiq,a->destino->etiq); printf(\" (%f)\\n\",a->valor); a=SiguienteArco(n,a,g); } n=SiguienteNodo(n,g); }}int NumeroNodos(tgrafo g){ return(g->nodo);}int GrafoVacio(tgrafo g){ return(g->sig == NULL);}float EtiqArco(tnodo o, tnodo d, tgrafo g){ tarco a; a=o->ady; while (a!=NULL) { if ((a->origen == o) && (a->destino == d)) return (a->valor); else a = a->sig; } return 0;}void InsertarNodo(tetq dato, tgrafo g){ tnodo aux,p;

aux = (tnodo)malloc(sizeof(struct nodo)); if (aux == NULL) error(\"Error Memoria Insuficiente.\"); else { p=g; while(p->sig != NULL) p = p->sig; aux->etiq = (char *)malloc(sizeof (char)*TE);"+ if (aux->etiq == NULL) error(\"Error Memoria Insuficiente.\"); aux->nodo = p->nodo+1; strcpy(aux->etiq,dato);+ aux->ady = NULL; aux->inc = NULL; aux->sig = NULL;

17

p->sig = aux; g->nodo++; }}void InsertarArco (tnodo org,tnodo dest,tvalor valor,tgrafo g){ tarco aux; tarco aux_inv;

aux = (tarco)malloc(sizeof(struct arco)); aux_inv= (tarco)malloc(sizeof(struct arco)); if ((aux==NULL) || (aux_inv==NULL))

error("Memoria Insuficiente."); else {

aux->origen = org; aux->destino = dest; aux->valor = valor; aux-> sig= org->ady; org->ady = aux;

aux_inv->origen = org; aux_inv->destino = dest; aux_inv-> valor= valor; aux_inv-> sig= dest->inc; des_inc-> = aux_inv;

}}void BorrarArco(tnodo org, tnodo dest, tgrafo g) { tarco a,ant; int enc=0; if (org->ady==NULL) return; else if (org->ady->destino==dest) {

a = org->ady; org->ady = a->sig; free(a);

} else { ant = org->ady; a = ant->sig; while (!enc && (a!=NULL)) {

if (a->destino==dest) enc=1; else { a = a->sig;

ant = ant->sig; } } if (a==NULL) return; else { ant->sig = a->sig; free(a); } }

enc=0; if (dest->inc==NULL) return;

18

else if (dest->inc->origen==org) { a = dest->inc;

dest->inc = a->sig; free(a); } else { ant = dest->inc; a = ant->sig; while (!enc && (a!=NULL)) { if (a->origen == org) enc=1;

else { a = a->sig;

ant = ant->sig; } } if (a==NULL) return; else { ant->sig = a->sig; free(a);

} }}void Destruir(tgrafo G) { tnodo n; tarco a_aux;

while (g->sig != NULL) { n = g->sig;

while (n->ady!= NULL) {a_aux = n->ady;n->ady = a_aux->sig;

free(a_aux); }

while (n->inc != NULL) { a_aux = n->inc;

n->inc = a_aux->sig; free(a_aux);

} g->sig = n->sig;

free(n->etiq); free(n); } free(g);}tgrafo DesconectarNodo(tnodo a_eliminar,tgeafo g){ tgrafo g_nd; tnodo n; tnodo org;dst; tnodo o,d; tarco a;

g_nd = Crear(); for (n=PrimerNodo(g); n!=NULL; n=SiguienteNodo(n,g))

InsertarNodo(Etiqueta(n,g),g_nd);

19

for (n=PrimerNodo(g); n!=NULL; n=SiguienteNodo(n,g)) for (a=PrimerArco(n,g); a!=NULL; a=SiguienteArco(n,a,g)) {

org = NodoOrigen(a,g);dst = NodoDestino(a,g);

if ((org!=a_eliminar) && dst!=a_eliminar)) { o = LocalizaLabel(Label(org,g), g_nd);

d = LocalizaLabel(Label(dst,g), g_nd); InsertarArco(o,d,g_nd);

} }

return g_nd;}

tgrafo CopiarGrafo(tgrafo g) { tgrafo g_nd; tnodo n; tnodo org;dst; tnodo o,d; tarco a; int lb;

g_nd = Crear(); for (n=PrimerNodo(g); n!=NULL; n=SiguienteNodo(n,g))

InsertarNodo(Etiqueta(n,g),g_nd); for (n=PrimerNodo(g); n!=NULL; n=SiguienteNodo(n,g))

for (a=PrimerArco(n,g); a!=NULL; a=SiguienteArco(n,a,g)) {org = NodoOrigen(a,g);dst = NodoDestino(a,g);

o = LocalizaLabel(Label(org,g), g_nd);d = LocalizaLabel(Label(dst,g), g_nd);InsertarArco(o,d,g_nd);

} } return g_nd; }

20

CONCLUSIONES

De este trabajo se podría decir que un árbol binario se define como un conjunto finito de elementos llamados nodos. En estos casos se puede usar terminología de relaciones familiares para descubrir las relaciones entre los nodos de un árbol; y que un árbol puede ser implementado fácilmente en una computadora.

De aquí se podría deducir que un grafo es básicamente un objeto geométrico aunque en realidad sea un objeto combinatorio, es decir, un conjunto de puntos y un conjunto de líneas tomado de entre el conjunto de líneas que une cada par de vértices. Por otro lado, y debido a su generalidad y a la gran diversidad de formas que pueden usarse, resulta complejo tratar con todas las ideas relacionadas con un grafo.

21

GLOSARIO

Nodo: En informática, un nodo es un «punto de intersección o unión de varios elementos que confluyen en el mismo lugar». Por ejemplo: en una red de ordenadores cada una de las máquinas es un nodo, y si la red es Internet, cada servidor constituye también un nodo.

Árbol: Es una estructura de datos ampliamente usada que imita la forma de un árbol (un conjunto de nodos conectados)

El algoritmo de dijkstra: También llamado algoritmo de caminos mínimos, es un algoritmo para la determinación del camino más corto dado un vértice origen al resto de vértices en un grafo con pesos en cada arista. Su nombre se refiere a Edsger Dijkstra, quien lo describió por primera vez en 1959.

22

REFERENCIAS

Grimm, J.: Deutsche Mythologie, traducido al inglés por J. S. Stallybrass (1882), vol. I, p. 116-118.Diccionario enciclopédico popular ilustrado Salvat (1906-1914)

http://sistemas.ing.ula.ve/pr3/unidad_3/tema6/pdf/grafos.pdf

http://www.monografias.com/trabajos36/arboles/arboles.shtml

http://www.monografias.com/trabajos16/grafos/grafos.shtml

23