You are on page 1of 47

Estructuras de datos en c/c++ "pilas" parte 1

DEFINICIN Y EJEMPLOS

Definicin 4 Una pila (stack) es una coleccin ordenada de elementos en la cual se pueden insertar nuevos elementos por un extremo y se pueden retirar otros por el mismo extremo; ese estremos se llama ``la parte superior'' de la pila. Si tenemos un par de elementos en la pila, uno de ellos debe estar en la parte superior de la pila, que se considera ``el ms alto'' en la pila que el otro. En la figura 9 el elemento F es el ms alto de todos los elementos que estn en la pila. El elemento D es el ms alto de los elementos A,B,C, pero es menor que los elementos E y F.

Figura 9: Pila con 6 elementos

Para describir cmo funciona esta estructura, debemos agregar un nuevo elemento, el elemento G. Despus de haber agregado el elemento G a la pila, la nueva configuracin es la que se muestra en la figura 10.

Figura 10: Operacin de insertar el elemento G en la pila P

De acuerdo con la definicin, existe solamente un lugar en donde cualquier elemento puede ser agregado a la pila. Despus de haber insertado el nuevo elemento, G ahora es el elemento en la cima. Debedos aclarar en qu pila deseamos insertar elementos, puesto que es posible tener ms de una pila al mismo tiempo. Cuando se desea retirar un elemento de la pila, solo basta ordenar que sea retirado un elemento; no podemos decir ``retira C de la pila'', porque C no est en la cima de la pila y solamente podemos retirar el elemento que est en la cima. Para que la sentencia ``retira C de la pila'' tenga sentido, debemos replantear las rdenes a algo como:

Retira de la pila hasta que el elemento retirado sea C.

Ni siquiera es necesario decir: ``Retira un elemento de la pila...'' porque es sobreentendido que solamente se puede sacar un elemento a la vez. Siguiendo nuestro ejemplo, ahora deseamos retirar de la pila P. La configuracin global de la pila es como se muestra en la figura 11

Figura 11: Operacin de retirar de la pila P

El concepto de pila es muy importante en computacin y en especial en teora de lenguajes de programacin. En lenguajes procedurales como Pascal o C, la pila es una estructura indispensable, debido a las llamadas a funcin. Resulta que el flujo de instrucciones va de arriba hacia abajo, y cuando ocurre una llamada a alguna funcin, el estado global del sistema se almacena en un registro y ste en una pila. As que la pila va a contenr todas las llamadas a procedimientos que se hagan. Cuando se termina de ejecutar algn procedimiento, se recupera el registro que est en la cima de la pila. En ese registro estn los valores de las variables como estaban antes de la llamada a la funcin, o algunas pueden haber cambiado si valor, dependiendo del mbito de las variables. Cada elemento en la pila que es retirado, significa que se ha terminado de ejecutar alguna funcin. Cuando se termina de ejecutar el programa, la pila de llamadas a subprogramas debe haber quedado en 0 tambin, de otro modo podra causar algun tipo de error. Esto nos lleva a pensar en otras utilidades de la pila. La pila sirve para encontrar errores. La dinmica de la pila, es decir, la manera en cmo entran los datos a la estructura de datos y cmo salen, se denomina fifo, que viene del ings first in first out (primero en entrar, primero en salir).

Figura 12: Dinmica de la pila P

En la figura 12 se muestran ``fotografas'' en distintos momentos de la pila, cuando se desea insertar H justo debajo de F. Para hacer esto se requiere, retirar tantos elementos como sean necesarios, aqu se han retirado de la cima G y F para luego insertar H, que quedar posteriormente debajo de F. Lo que sucede es que, cuando se retira el elemento G se debe hacer una evaluacin para determinar si el elemento retirado es el elemento objetivo, en este caso el elemento objetivo es F, puesto que se desea insertar un elemento debajo de F. Despus de haber insertado F, insertamos de nuevo los elementos F y G en ese orden, adems de insertar finalmente el elemento I que queda en la cima de la pila. Enseguida veremos con ms detalle las operaciones bsicas de las pilas.
OPERACIONES BSICAS

Las operaciones bsicas de una pila son: 1. 2. 3. 4. En la pila S, insertar un elemento e: push(S,e), Retirar un elemento de la pila S: pop(S), Verificar si la pila S est vaca: stackempty(S) y Saber cul es el elemento en la cima de la pila S: stacktop(S).

enseguida cada una de estas operaciones:

La operacin push
Esta operacin sirve para insertar un elemento e en la pila S, lo vamos a escribir como:
push(S,e)

Despus de hacer esta operacin sucede que:

El elemento en la cima de la pila S ahora es e

La operacin pop
Para retirar un elemento de la pila S y asignarlo a una variable del mismo tipo que el tipo de los elementos de la pila, usaremos la operacin pop escribindola como:
v=pop(S); En donde v es una variable que almacena el valor del elemento que estaba en la cima de S. Hacer esta operacin tiene algunas implicaciones:

La variable v debe ser del mismo tipo que los elementos almacenados en la pila. Solamente se puede retirar un elemento de la pila a la vez. Antes de la operacin, e era el elemento en la cima, ahora ya no lo es ms. El apuntador ``cima'' decrece en una unidad.

La operacin stackempty
Esta operacin toma como argumento una estructura del tipo stack (pila) y devuelve un valor booleano, devuelve un true si la pila est vaca y devuelve un false si la pila tiene al menos un elemento, es decir:

La operacin stacktop
La operacin stacktop(S) devuelve el valor del elemento en la cima de la pila S. Para hacer esta operacin escribiremos:
v=stacktop(S)

las implicaciones de usar esta operacin son:


Se hace una copia del elemento que est en la cima En realidad se hacen dos operaciones, primero se hace v=pop(S), luego un push(S,v), porque despus de la operacin stacktop, la pila S queda sin cambio alguno.

JUEVES, 6 DE OCTUBRE DE 2011

Estructuras de datos en c/c++ "pilas" parte 2


EJEMPLO: NMERO DE PARNTESIS

Supongamos ahora la expresin ((5+6)*4)/(17+9), una de las condiciones para que sea una expresin aritmtica correcta en que tengas sus parntesis balanceados, as que deseamos saber si el nmero de parntesis que abres es el mismo nmero de parntesis que cierran. Para resolver este problema usaremos el concepto de pila. La idea es simple. Vamos a leer cada elemento de la expresin, si se trata de un parntesis que abre, entonces lo insertaremos en una pila; si se trata de un parntesis que cierra, entonces sacamos un elemento de la pila. Al terminar de leer la expresin revisaremos si la pila est vaca, en cuyo caso habremos concludo que el nmero de parntesis que abre es el mismo que el nmero de parntesis que cierra y la expresin tiene parntesis balanceados. Veamos cmo funciona: ` (' :
push(S,`(')

` (' :
push(S,`(')

` 5' : nada que hacer ` +' : nada que hacer ` 6' : nada que hacer ` )' :
v=pop(S)

` *' : nada que hacer ` 4' :

nada que hacer ` )' :


v=pop(S)

` /' : nada que hacer ` (' :


push(S,`(')

`17': nada que hacer ` +' : nada que hacer ` 9' : nada que hacer ` )' :
v=pop(S)

Empezamos con un contador iniciado en 0, y por cada push aumentamos un contador, y por cada pop decrementamos el contador. Al final vemos el valor del contador, si el contador=0 entonces terminamos con xito, de otro mod sealamos el error. En la figura 13 se muestra la actividad de la pila a medida que se van agregando y quitando elementos.
Figura 13: Evaluacin del balance de parntesis en una expresin aritmtica
LA ESTRUCTURA DE DATOS PILA EN C/C++

Una pila est conformada por dos elementos:


Un espacio suficientemente grande para almacenar los elementos insertados en la pila Una parte que nos seale cul es el elemento en la cima de la pila.

Estas partes las conformamos en una estructura, descrita como sigue:


definir numero maximo de elementos en la pila definir nuevo tipo estructura llamado "stack" con item : un arreglo de 1 a maximos elementos enteros top : un numero de 0 a maximos elementos fin de la nueva estructura Fcilmente podemos describir un cdigo en C/C++ que represente lo anteriormente

propuesto.
// En la parte de definiciones #define maxElem 100 // En la parte de tipos struct stack { int item[maxElem]; int top; }; // En la parte de variables

struct stack A;

LA REPRESENTACIN EN C/C++ DE LAS OPERACIONES DE UNA PILA

En esta seccin veremos una implementacin de las cuatro operaciones bsicas de las pilas. Todas estas operaciones se han hecho desde un punto de vista de programacin funcional, sin duda se pueden describir en un modelo orientado a objetos

JUEVES, 6 DE OCTUBRE DE 2011

Estructuras de datos en c/c++ "pilas" parte 3


La operacin push
El siguiente segmento de cdigo ilustra cmo se puede implementar la operacin insertar un elemento en una pila. Hemos supuesto que la pila ya est definida como una estructura stack.
(1) void push(struct stack *S,int e){ (2) S->top++; (3) S->item[S->top]=e; (4) } En la lnea (1) se observa que la operacin push recibe dos parmetros: la direccin de

una estructura de tipo pila y un elemento de tipo entero. La lnea (2) incrementa el tope (cima) de la pila en una unidad, con el fin de agregar el elemento en una posicin libre de la pila, lo cual se logra en la lnea (3), asignando el valor e en la casilla S->top del arreglo item de la pila.

La operacin pop
La operacin pop se escribe en forma de cdigo en C/C++ con la siguiente secuencia de rdenes:
(1) int pop(struct stack *S){ (2) int valReturn; (3) (4) valReturn=S->item[S->top]; (5) S->top--; (6) return valReturn; (7) }

La lnea (1) describe que esta funcin devuelve un tipo entero, el tipo de elementos guardados en la pila; luego notamos que debemos dar slo la direccin de alguna variable de tipo estructura de pila (struct stack *). Obtener la direccin se logra con el operador de indireccin (&). Las lneas (4) y (5) hacen todo el trabajo de esta funcin, se almacena el valor que ser devuelto en una variable de tipo entero y luego se decrementa el tope de la pila.

La operacin stackempty
La operacin stackempty se describe en el siguiente segmento de cdigo:
(1) bool stackempty(struct stack *S){ (2) bool valorDevuelto;

(3) if(S->top== -1) (4) valorDevuelto=true; (5) else (6) valorDevuelto=false; (7) return valorDevuelto; (8) }

El encabezado de la funcin que se muestra en la lnea (1) establece que se devuelve un valor booleano, y que se debe dar un parmetro, que es la direccin de una localidad de memoria que almacena una estructura de tipo pila. El objetivo de esta funcin es claro: La lnea (3) establece la verdacidad o falsedad del predicado (S->top==-1), determinando si el nivel del tope es igual que -1, en cuyo caso devuelve un verdadero (4), de otro modo ha de devolver un valor falso (6). Se ha establecido un -1 como vaco porque el manejo de arreglos en C/C++ empieza en el ndice 0, que a diferencia de otros lenguajes como Pascal, empiezan en 1.

La operacin stacktop
Este es un caso especial porque no se requiere hacer ningn cdigo. Esta funcin debe devolver un nmero entero y dejar la pila sin cambio. Para lograr esto se debe hacer un pop(&A), mostrar el elemento y luego insertar de nuevo el elemento en la pila haciendo un push(&A,elemento), notemos que se han usado los operadores de direccin para dar la direccin de la variable que alberga una estructura de tipo pila. El siguiente segmento de cdigo ilustra cmo se han usado las funciones antes creadas, por supuesto que se pueden separar y crear una nueva funcin que haga lo mismo:
... (1) case 4:{ (2) if(not stackempty(&A)){ (3) valor=pop(&A); (4) std::cout<<"La cima de la pila es: "<<valor<<"\n"; (5) push(&A,valor); (6) } else (7) std::cout<<"La pila esta vacia"; (8) break; (9) } ...
JUEVES, 6 DE OCTUBRE DE 2011

Estructuras de datos en c/c++ "pilas" parte 4


PROBLEMAS DE PROGRAMACIN

Los siguientes ejercicios deben ser resueltos en un progrma (en C/C++ ): 1. Expresiones entrefijas y prefijas. Las expresiones aritmticas pueden representarse de varias maneras, una de ellas, la ms usual es la notacin entrefija. La notacin entrefija establece que en medio de dos operandos se escribe un operador, como por ejemplos: 1. , donde los operandos son y , y el operador es el smbolo

2.

Donde el parntesis ms interno establece la mayor prioridad, de manera que primero se debe evaluar , luego resultado . y fimalmente , luego , dando como

3.

No hay nada que hacer, pues es un operador unario.

En las expresiones prefijas se establece que el orden de escritura debe ser, primero el operador y luego la lista de operandos: 4. 5. , donde los operandos son y , y el operador es el smbolo ;

Lo primero que hay que hacer es tomar el primer operador y tomar los operandos necesarios siguientes (dos si se trata de un operador binario y uno si es un operador unario). En este caso se trata de evaluar . Cada uno de los operandos debe ser tratado de nuevo como una expresion en prefijo, de manera que se repite lo anterior, tomar el operador y la lista de sus operandos y tratar cada uno de sus operandos como expresiones en prefijo: ,

luego y finalmente y evaluar. Los parntesis cuadrados son para ilustrar el ejemplo y no son necesarios para su evaluacin. 6. No hay nada que hacer, pues es un operador unario.

Haga un programa en C/C++ que transforme expresiones de entrefijo a prefijo, y de prefijo a entrefijo. Los caracteres vlidos son: las letras maysculas y minsculas, los nmeros enteros, los parntesis normales, los cuatro operadores y el operador unario .

Figura: Ilustracin del estacionamiento mencionado en el problema 2

2. en cierto punto de la ciudad hay un estacionamiento como el que se muestra en la figura 14, en donde hay lugar para 9 vehculos. haga un programa que muestre el manejo de este estacionamiento, considerando los siguientes requisitos: 1. Los vehculos proporcionan la siguiente informacin: Placas (6 digitos), Estado (2-3 caracteres, p.e. SON, DF, CHI, YUC), Marca, Modelo, AoModelo, Nombre del propietario. 2. Al llegar un veculo se acepta solamente si hay lugar disponible. 3. Validar todas las operaciones de la pila. 4. En cualquier momento se puede sacar algn vehculo del estacionamiento, regresando los vehculos en el orden en que estaban. 5. Toda la corrida del programa debe hacerse hacia/desde la terminal estndar. 3. Haga un programa que implemente 2 pilas en 1 arreglo A[1..n] de manera que ninguna pila se desborde a menos que el nmero de elementos en ambas pilas sea

JUEVES, 6 DE OCTUBRE DE 2011

Estructuras de datos en c/c++ "colas" parte 1


Colas Definicin 5 Las colas son una estructura de datos similar a las pilas. Recordemos que las pilas funcionan en un depsito en donde se insertan y se retiran elementos por el mismo extremo. En las colas sucede algo diferente, se insertan elementos por un extremo y se retiran elementos por el otro extremo. De hecho a este tipo de dispositivos se les conoce como dispositivos ``fifo'' (first in, first out) porque funcionan como una tubera, lo que entra primero por un extremo, sale primero por el otro extremo. En una cola hay dos extremos, uno es llamado la parte delantera y el otro extremo se llama la parte trasera de la cola. En una cola, los elementos se retiran por la parte delantera y se agregan por la parte trasera.

Figura 15: Dinmica de una cola. a) estado actual con una cola con tres elementos a,b,c; b) estado de la cola cuando se agrega el elemento d; c) estado de la cola cuando se elimina el elemento a del frente de la cola

En la figura 15 se muestra una actividad tpica de la cola, en donde se muestra que se agregan datos por la parte trasera de la cola y se eliminana datos por el frente de la cola. Si es una cola y colas: es un elemento, se pueden hacer tres operaciones bsicas con las

1. insert(Q,x), que inserta el elemento x en la parte trasera de la cola Q. 2. x=remove(Q), que almacena en x el valor del elemento retirado de la parte frontal de la cola Q. 3. empty(Q), que es un predicado de valor booleano, y es cuando la cola Q tiene 0 elementos, y es cuando la cola Q tiene al menos un elemento, en cuyo caso, ese nico elemento es la parte frontal y la parte trasera de la cola al mismo tiempo. Tericamente no hay lmite para el tamao de la cola, asi que siempre se debera poder insertar elementos a una cola, sin embargo, al igual que las pilas, normalmente se deja un espacio de memoria para trabajar con esta estructura. Por el contrario, la operacin slamente se puede hacer si la cola no est vaca.
ESTRUCTURA DE LAS COLAS EN C/C++

De manera similar a las pilas, las colas definen una estructura no estndar, de manera que se debe crear un nuevo tipo de dado, el tipo cola, que debe tener los siguientes elementos:

Un arreglo de elementos de algn tipo especfico, puede incluso ser un tipo estndar o no. Un nmero que indica el elemento que est en la posicin del frente de la cola. Un nmero que indica el elemento que est en la posicin trasera de la cola.

Suponiendo que los elementos son nmeros enteros, una idea para representar una cola en C/C++ es usar un arreglo para contener los elementos y emplear otras dos variables para representar la parte frontal y trasera de la cola.

#define maxQueue 100 struct cola{ int items[maxQueue]; int front; int rear; };

Esta representacin con arreglos es completamente vlida, pero debemos tener cuidado con los lmites del arreglo. Suponiendo que no existiera la posibilidad de caer en un desbordamiento del arreglo, es decir, que se insertaran ms elementos de lo que el arreglo puede almacenar, la operacin insert podra quedar como:
void insert(struct cola *C, int e){ C->items[++C->rear]=e; } y al operacin x=remove(Q) int remove(struct cola *C){ return C->items[C->front++]; } y finalmente la operacin empty(Q): bool empty(struct cola *C){ if(C->front>C->rear) return true; else return false; }

JUEVES, 6 DE OCTUBRE DE 2011

Estructuras de datos en c/c++ "colas" parte 2


COLAS CON PRIORIDAD

Una cola con prioridad es una estructura de datos en la que se ordenan los datos almacenados de acuerdo a un criterio de prioridad. Hay dos tipos de colas de prioridad:

Las colas de prioridad con ordenamiento descendente. Las colas de prioridad con ordenamiento ascendente.

En las colas de prioridad ascendente se pueden insertar elementos en forma arbitraria y solamente se puede remover el elemento con menor prioridad. Si CPA es una cola de prioridad ascendente, la operacin insert(CPA,x) inserta el elemento x en la cola CPA; y la operacin x=minRemove(CPA) asigna a x el valor del elemento menor (de su prioridad) y lo remueve de la cola. En las colas de prioridad descendente es similar, pero slo permite la supresin del elemento ms grande. Las operaciones aplicables a la cola de prioridad descendente son insert(CPD,x) y x=maxRemove(CPD), cuando CPD es una cola de prioridad descendente y x es un elemento. La operacin empty(C) se aplica a cualquier tipo de cola y determina si una cola de

prioridad est vaca. Las operaciones de insertar y borrar se aplican solamente si la pila no est vaca. Los elementos de la cola de prioridad no necesitan ser nmeros o caracteres para que puedan compararse directamente. Pueden ser estructuras complejas ordenadas en uno o varios campos. Por ejemplo, las agendas telefnicas constan de apellidos, nombres, direcciones y nmeros de telfono y estn ordenadas por apellido. A diferencia de las pilas y las colas, en las colas de prioridad se pueden sacar los elementos que no estn en el primer sitio del extremo donde salen los elementos. Esto es porque el elemento a retirar puede estar en cualquier parte del arreglo. Cuando se requiere eliminar un dato de una cola de prioridad se necesita verificar cada uno de los elementos almacenados para saber cul es el menor (o el mayor). Esto conlleva algunos problemas, el principal problema es que el tiempo necesario para eliminar un elemento puede crecer tanto como elementos tenga la cola. Para resolver este problema hay varias soluciones: 1. Se coloca una marca de ``vaco'' en la casilla de un elemento suprimido. Este enfoque realmente no es muy bueno, porque de cualquier modo se accesan los elementos para saber si es una localidad vaca o no lo es. Por otro lado, cuando se remueven elementos, se van creando lugares vacos y despus es necesario hacer una compactacin, reubicando los elementos en el frente de la cola. 2. Cada supresin puede compactar el arreglo, cambiando los elementos depus del elemento eliminado en una posicin y despus decrementando rear en 1. La insercin no cambia. En promedio, se cambian la mitad de los elementos de una cola de prioridad para cada supresin, por lo que esta operacin no es eficiente.

EJERCICIO DE PROGRAMACIN

1. Modifique los procedimientos de insertar, retirar y verificar-cola-vaca para que considere aprovechar los espacios dejados al retirar elementos. 2. Un deque es un conjunto ordenado de elementos del cual pueden eliminarse elementos en cualquier extremo y en el cual pueden insertarse elementos en cualquier extremo. Llamemos a los dos extremos de un deque left (izquierdo) y right (derecho). ?'cmo se representa un deque en un arreglo en C/C++ ? escriba un programa que maneje un deque, y que considere las cuatro rutinas
o o o o removeLeft removeRight insertLeft insertRight

para remover e insertar elementos en los extemos izquierdo y derecho de un deque. Asegrese de que las rutinas funcionan adecuadamente para que un deque vaco y que detectan desbordamiento y subdesbordamiento. 3. Programe las colas de prioridad ascendente y descendente. 4. Existe un estacionamiento que tiene un slo carril que aloja hasta 10 carros. Los autos llegan por el extremo sur del estacionamiento y salen por el extremo norte del mismo. Si llega un cliente para recoger un carro que no est en el extremo norte, se sacan todos los automviles de ese lado, se retira el auto y los otros

coches se restablecen en el mismo orden que estaban. Cada vez que sale un auto, todos los autos del lado sur se mueven hacia adelante para que en todas las ocasiones todos los espacios vacos estn en la parte sur del estacionamiento. Escriba un programa que lea un grupo de lineas de ingreso. Cada lnea contiene una ``A'' para las llegadas y una ``D'' para las salidas y un nmero de placa. Se supone que los carros llegan y salen en el orden especificado en la entrada. El programa debe imprimir (en la terminal estndar) un mensaje cada vez que entra o sale un auto. Cuando llega un carro, el mensaje debe especificar si hay espacio o no para l en el estacionamiento. Si no hay espacio, el carro espera hasta que hay espacio o hasta que se lee una lnea de salida para el auto. Cuando queda disponible espacio, debe imprimirse otro mensaje. Cuando salga un coche, el mensaje debe incluir la cantidad de veces que se movi el auto dentro del estacionamiento, incluyendo la salida misma, pero no la llegada. Este nmero es 0 si el carro sale de la fila de espera

JUEVES, 6 DE OCTUBRE DE 2011

Estructuras de datos en c/c++ "recursion" parte 1


Recursin Un tema fundamental para los prximos temas es el de recusrin. La recursin es muy importante tanto en mateticas como em computacin, pues se usa recursin para definir procedimientos autosimilares. Definicin 6 Decimos que un objeto es recursivo si en su definicin se nombra a s mismo. En programacin, una funcin es recursiva si en el mbito de esa funcin hay una llamada a s misma, C/C++ permite esta clase de acciones. Los algoritmos recursivos dan elegancia a las soluciones de los problemas. Un ejemplo clsico es el factorial de un nmero. Una manera de definir el factorial de un nmero es:

es decir, el producto de todos los nmeros enteros menores o guales que l, lo que se puede resolver fcilmente con una funcin iterativa, esto es, una funcin con un ciclo que itere suficientes veces, incrementando un valor y entonces ir almacenando en una variable el resultado de esas multiplicaciones. Una implementacin de esta definicin iterativa es:
(1) int i,n; (2) long double valorAc; (4) valorAc=1.0;

(5) (6) (7) (8)

std::cout << "Numero entero:"; std::cin>> n; for(i=1; i<=n; i++) valorAc = valorAc*i; std::cout<<"El factorial de "<<n<<" es:"<<valorAc;

El ciclo principal es en la lnea (7). No hay ningn truco hasta aqu. La nica observacin importante es en la lnea (2) en donde se declara el tipo long double para el valor del resultado, la razn para tal accin es que el nmero factorial crece muy rpido y an con entradas en el rango de los caracteres (hasta 255), el factorial es muy grande. Este procedimiento computacional no hace uso de tcnicas especiales empleadas para tratar nmeros grandes. Sin embargo una solucin ms elegante es usar la definicin recursiva, y esta es:

El programa en C/C++ es el que se muestra a continuacin:


( 1) double factorial(double a){ ( 2) if (a<=1) return 1.0; ( 3) else return (a *factorial(a-1.0)); } ( 4) ( 5) int main (int argc, char * const argv[]) { ( 6) double n; ( 7) std::cout << "Numero entero:"; ( 8) std::cin>> n; ( 9) std::cout<<"El factorial de "<<n<<" es: "<< factorial(n); (10) return 0; }

Aqu hay varias cosas que sealar, en primer lugar se ha creado una nueva funcin, a diferencia de la definicin iterativa en donde era suficiente trabajar en el programa principal. Esta funcin se llama factorial (como era de suponerse), y empieza su encabezado en la lnea (1). All mismo en la misma lnea (1), es de notar que hemos emplado ahora el tipo double tanto para el tipo devuelto como para el tipo del argumento, a diferencia de la versin iterativa en donde emplebamos tipos diferentes. La razn es que al iniciar la recursin el argumento es del tipo devuelto, asi que deben ser del mismo tipo. Cada llamada recursiva genera una entrada a una pila, en donde se guardan (como elementos) los estados generales del sistema al momento de hacer la llamada, entonces, cuando se termina la funcin se recupera una entrada de la pila. En la figura 16 ilustra cmo funciona la recursividad cuando se intenta obtener el factorial(5).

Figura 16: Recursividad cuando se ejecuta factorial(5)

La serie Fibonacci
Una de las series ms famosas es sin duda alguna la serie de Fibonacci:

Un poco de observacin es sufucuente para encontrar que cualquier nmero (a partir del tercero de la serie, osea el segundo 1) es igual a la suma de los dos nmeros anteriores. Daremos en primer lugar la versin iterativa. En este algoritmo deseamos encontrar el simo nmero de la serie Fibonacci. As si el resultado del algoritmo debe ser ; si el resultado debe ser . La versin iterativa empieza desde los primeros 1's, sumndolos y encontrando el tercero, luego para encontrar el cuarto nmero se suman el tercero (recin encontrado) y el segundo, y as en adelante hasta encontrar el nmero buscado.
#include <iostream> int main (int argc, char * const argv[]) { int i,n,fib,fib1,fib2,fibx; std::cout<<"Un numero entero:"; std::cin>>n; fib1=2; fib2=1; i=3; if((n==1)||(n==2)) fib=1; else{ do{ fib = fib1 + fib2; fibx = fib1; i++; fib1 = fib; fib2 = fibx; }while(i<n); } std::cout << "\nEl "<<n<<"-esimo numero de la serie Fibonacci es: "<<fib; return 0; }

La definicin recursiva para encontrar todos los es:

primeros nmeros de la serie Fibonacci

En el siguiente cdigo, la solucin que propone la recursividad resulta en una programacin elegante, aunque costosa. El cdigo que hace esto es:

( 1) ( 2) ( 3) ( 4) ( 5) ( 6) ( 7) ( 8) ( 9) (10) (11) (12) (13) (14) (15) (16)

#include <iostream> //==================== int fib(int val){ if ((val==1)||(val==2)) return 1; else return (fib(val-1)+fib(val-2)); } //==================== int main (int argc, char * const argv[]) { int n; std::cout<<"Numero entero:"; std::cin>>n; std::cout<<"\nEl "<< n <<"-esimo numero fibonacci es: "<< fib(n); return 0; }

Como regla general, cualquier algoritmo recursivo se puede reescribir en un algoritmo iterativo. La ventaja de tener un algoritmo iterativo es que no se usa una pila para guardar llamadas a la misma funcin de manera recursiva, esto es una ventaja porque el espacio de memoria destinado al uso de la pila es generalmente limitado, de manera que cuando se hacen demasiadas funciones push seguramente llegar el momento en que la pila ``se desborde'', que por cierto es un trmino usado en computacin para decir que ya no hay ms espacio disponible en la pila.

JUEVES, 6 DE OCTUBRE DE 2011

Estructuras de datos en c/c++ "recursion" parte 2


PELIGROS EN LA RECURSIVIDAD

El principal peligro al usar recursividad, es no tener una manera de salir del paso recursivo, esto es peligroso porque se hacen llamadas a la misma funcin, lo que significa una entrada en la pila donde se almacenan los estados generales del programa. Para decidir hacer un programa recursivo se deben de tener al menos dos cosas muy claras: 1. El paso base: Esta es la clave para terminar la recursin, es cuando deja de hacer llamadas a la funcin recursiva y hace evaluaciones devolviendo los resultados. En el ejemplo de la serie de Fibonacci, el paso base est en la lnea ( 5). Adems se debe asegurar de que es posible entrar a este paso. 2. El paso recursivo: Es la parte de la definicin que hace llamadas a esa misma funcin y que es la causante de las inserciones en la pila, almacenando en cada una de las llamadas, informacin del programa, del estado de sus variables locales y globales. En el mismo ejemplo de la serie Fibonacci, el paso recursivo se muestra en la lnea ( 7). Otras cosas que se deben tener claras son por ejemplo si se pasa una variable como referencia o por valor, si las variables apuntadores son del tipo adecuado etc. Frecuentemente tanto el paso base como el paso recursivo, se encuentran en una sentencia condicional if, pero porsupuesto que es posible usar cualquier otra sentencia

de control, dependiendo de las necesidades particulares del problema. El siguiente ejemplo ilustra este problema
( 1) ( 2) ( 3) ( 4) ( 5) ( 6) ( 7) ( 8) ( 9) (10) (11) (12) #include <iostream> int malaFuncion( int n ){ std::cout << "malaFuncion es una recursion infinita. n="<<n; if( n == 0 ) return 0; else return malaFuncion( n / 3 + 1 ) + n - 1; } int main (int argc, char * const argv[]) { std::cout << malaFuncion(10); return 0; }

EJERCICIOS DE PROGRAMACIN

Los siguientes ejercicios deben de ser programados en C/C++ : 1. Bsqueda binaria: Considere un arreglo de elementos (nmeros enteros est bien) en el cual los objetos ya estan ordenados, y se desea encontrar un elemento dentro de este arreglo. Es decir, se desea realizar una ``bsqueda''. La idea general de este mtodo de bsqueda binaria es: Si el arreglo tiene 1 elemento, se compara con el numero requerido y la bsqueda termina. o Si el arreglo tiene ms de 1 elemento, tendremos que dividir en dos el arreglo y decidir en qu parte del arreglo buscar; luego buscarlo usando busqueda binaria 2. Escriba un programa para calcular la cantidad de maneras diferentes en las cuales un entero se puede expresar como la suma de dos enteros menores y
o

tales que

JUEVES, 6 DE OCTUBRE DE 2011

Estructuras de datos en c/c++ "Listas" parte 1


Listas
Hay dos desventajas serias con respecto a las estructuras estticas de pilas y colas usando arreglos. Estas desventajas son que tienen un espacio limitado de memoria y la otra desventaja es que es posible no ocupar toda la memoria disponible, haciendo que se desperdicie espacio. Una solucin es usar listas. Las listas son estructuras de datos que son dinmicas, esto significa que adquieren espacio y liberan espacio a medida que se necesita. sin embargo, hay una advertencia. Como regla general siempre hay que tener cuidado al manejar

direcciones de espacios de memoria, porque es posible que accedamos a una localidad de memoria de la cual no deseabamos cambiar su contenido. Antes de estudiar las listas, daremos una breve introduccin a los grafos, pues las listas son un caso especial de los grafos.

GRAFOS

Los grafos son una manera visual de representar las relaciones.

Definicin 7 Si

son dos conjuntos, decimos que

est relacionado con

si es verdadera una sentencia que considere a ambos elementos. Esta sentencia puede ser cualquier predicado, por ejemplo: ``es padre de'', ``debe dinero a'', ``toma el curso de'' etc.; si el predicado es verdadero para ese par de elementos, lo escribimos como , y si el predicado es falso, lo escribimos como .

As los ejemplos citados, si

se puede leer: es el conjunto de materias y se lee `` es ``toma el

Si

es el conjunto de alumnos,

curso'', entonces

. En la figura 17 se puede apreciar esto en forma de diagramas de Venn. Si es el conjunto de personas y es tambin el conjunto de personas, y es ``debe dinero a''; significa que ``marisol debe dinero a rafaelle'' y de ningn modo es al contrario, es decir ``rafaelle no debe dinero a marisol''.

Figura 17: Relacin ``toma el curso de'' para los conjuntos

de personas y

de materias.

Los elementos de la figura 17 definen un nuevo conjunto de elementos, el conjunto de pares de elementos que estan relacionados. As la relacin ``toma el curso de'' es el siguiente:

Grficamente podemos ilustrar el conjunto que se muestra en la figura 18.

de ``toma el curso de'' con un grafo como el

Figura 18: Grafo que ilustra la relacin ``toma el curso de''.

De manera que podemos definir un grafo como una representacin grfica de una relacin.

Definicin 8 Para definir formalmente un grafo debemos establecer la siguiente tupla:

Donde

es un conjunto de aristas y

un conjunto no vaco de nodos. En el caso

de , el conjunto conjunto de aristas.

es el conjunto de nodos y el conjunto de flechas es el

Notemos que el conjunto de aristas puede ser un conjunto vaco, pero de ningn modo hay grafo sin nodos, es decir el conjunto debe ser diferente que el conjunto vaco. Supongamos ahora y la siguiente relacin en :

Esta relacin luce como aparece en la figura 20.

Figura: Relacin

de A en A

y en forma de grafo es:

Figura: Grafo de la relacin

A esta clase de grafos, en las que cada nodo tiene a lo ms una arista dirigida que sale y a lo ms una arista dirigida que entra, se le llama lista.

JUEVES, 6 DE OCTUBRE DE 2011

Estructuras de datos en c/c++ "Listas" parte 2


LISTAS SIMPLEMENTE ENCADENADAS

Como vimos en la seccin anterior, una lista es una relacin de elementos, tales que cada elemento est relacionado con nicamente un elemento del conjunto, diferente a s mismo. Como cada elemento puede tener a lo ms una arista dirigida que sale y una arista dirigida que entra, bien puede tener 0 aristas que salen, o cero aristas que entran. Si el nodo tiene 0 aristas que salen, entonces es el final de la lista. Si el nodo tiene 0 aristas que entran, entonces es el inicio de la lista. Por razones prcticas, se dibujan una flecha que sale de un identificador de la lista y entra al inicio de la lista y otra flecha que sale del final de la lista y apunta a un smbolo que se llama NULO.

Figura: Grafo de la relacin

con apuntadores del nombre de la lista listaLigada y hacia NULL

En C/C++ el identificador de la lista contiene la direccin del primer elemento de la lista, as como sucede con los arreglos. El valor NULO es til para saber cundo termina la

lista, es una constante estndar y no tiene valor. El contenido de los nodos, como ya hemos visto, son los elementos de un conjunto. Si ese conjunto tiene elementos estructurados, tambin es vlido usarlos. Normalmente cada nodo de la lista est estructurado con dos partes: 1. La parte de informacin. 2. La parte de direccin al siguiente nodo de la lista. El campo de informacin contiene el elemento real de la lista. El campo de direccin al siguiente contiene un apuntador al elemento con el cul est relacionado, es decir, al elemento siguiente de la lista. La lista completa se accesa mediante el identificador de lalista. El campo de la direccin del ltimo nodo apunta a una direccion nula. La lista que no tiene elementos (solamente tiene un identificador que apunta a nulo) se llama lista nula o lista vaca. Una lista se inicializa a una lista vaca haciendo lista=null, recordemos que lista es un apuntador a una direccin de memoria que puede albergar una variable del tipo que se hayan definido los nodos; null es una direccin de cualquier tipo, as que el compilador asigna la direccin null a lista. Enseguida vamos a dar una lista de trminos usados para manejar los elementos de una lista simplemente encadenada, aunque no son los que usa C/C++ , pero s son bastante claros para hacer algoritmos. Si p es un apuntador a la direccin de una variable del tipo declarado para los nodos de una lista:
node(p):

hace referencia al noso al que se apunta mediante p.


info(p):

hace referencia a la informacin del nodo al que apunta p. next(p): hace referencia a la parte direccin siguiente y, por tanto, es un apuntador. As que la expresin info(next(p)) significa que se hace referencia a la seccin de informacin del nodo siguiente al que apunta p.

Insertar y eliminar nodos de una lista


En el uso de las listas ligadas se ven involucradas varias operaciones, entre ellas la de insertar un nuevo nodo a la lista y la operacin de eliminar un nodo de la lista. En ambos casos debemos recordar que se trata de manejo de la memoria, as que insertar un nodo en la lista significa obtener un espacio de memoria disponible y relacionarlo con los elementos de la lista; as mismo, eliminar un nodo de la lista significa liberar la memoria que ocupa ese nodo sin perder la relacin con el resto de los nodos de la lista. Insertar un elemento al inicio de la lista. La operacin p=getnode(); obtiene un nodo vaco y establece el contenido de una variable nombrada p en la direccin de este nodo, como se muestra en la figura 22.a. Este nodo an no pertenece a alguna lista, simplemente se ha logrado dedicar un especio de memoria que es apuntado por p, figura 22.b.

Figura 22: a) Creacin de un nuevo nodo. b) El nuevo nodo debe de ir insertado al frente, atrs o en medio de la lista.

Una vez que se ha creado un nuevo espacio para el nuevo nodo, se debe de establecer la parte de informacin de ese nodo con la operacin info(p), como se ilustra en el siguiente ejemplo con el dato 6.
info(p)=6;

Despus de esstablecer la parte de informacin es necesario establecer la parte siguiente de este nodo. Debido a que node(p) va a insertarse en la parte delantera de la lista, el nodo que sigue debe ser el primer nodo actual de la lista. Debido a que la variable lista (el identificador de la lista) contiene la direccin de ese primer nodo, node(p) se agrega a la lista ejecutando la operacin
next(p)=lista;

Esta operacin coloca el valor de lista (la direccin del primer nodo en la lista) en el campo siguiente de node(p). Estos pasos se ilustran en la figura 23

Figura 23: Operaciones involucradas en la insercin de un nuevo nodo al inicio de una lista: c) info(p). d) next(p)=list. e) list=p

Hasta ahora, p apunta a la lista con el elemento adicional incluido. Sin embargo, debido a que list es el apuntador externo a la lista deseada, su valor debe modificarse en la direccin del nuevo primer nodo de la lista. Esto se hace ejecutando la operacin

list=p;

En resumen, ya tenemos un algoritmo para insertar un elemento al inicio de una lista simplemente ligada, al reunir todos los pasos tenemos:
p=getnode(); info(p)=6; next(p)=list; list=p;

Eliminar un elemento de la lista. Para eliminar un elemento del inicio de la lista, se siguen los mismos pasos que se usan para insertar un elemento, pero en un orden diferente:
p=list; x=info(p); list=next(p);

Comentaremos cada una de estas tres lneas, que se pueden apreciar en la figura 24

Figura 24: Operaciones involucradas en la eliminacin de un nodo al inicio de una lista: c) p=list). d) x=info(p). e) list=next(p)

JUEVES, 6 DE OCTUBRE DE 2011

Estructuras de datos en c/c++ "Listas" parte 3


Listas en C/C++ con arreglos
Vamos a empezar una primera implementacin de listas usando arreglos, cada elemento del arreglo debe ser un elemento compuesto. Cada elemento debe contener una parte para la informacin y otra parte para apuntar al elemento siguiente:
#include <iostream> ( 1) #define numNodes 500 ( 2) struct nodeType{

( 3) int info; ( 4) int next; ( 5) }; ( 6) struct nodeType node[numNodes]; int main (int argc, char * const argv[]) { std::cout << "Hello, World!\n"; return 0; }

En el programa anterior, en las lneas (2) a (5) se crea un nuevo tipo de dato, el tipo nodo. Cada nodo tiene dos partes, su parte de informacin y su parte de apuntador al siguiente. Como solamente tenemos 500 nodos (declarados en la lnea (1), el tipo de siguiente es entero y hemos decidido almacenar nmeros enteros solamente. En la lnea (6) se ha declarado una variable global de tipo arreglo de estructura de nodos, es decir, se ha creado un arreglo de 500 nodos. En este esquema, el ltimo nodo apunta a NULL, que se representa con el valor entero -1. Tenemos tambin los siguientes elementos de cada nodo: node[p] corresponde a next(p), por la notacin propia del lenguaje; tambin node[p].info para info(p) y finalmente node[p].next hace referencia al nodo siguiente next(p). Al principio todos los nodos estn sin usar, porque solamente se ha creado el arreglo. As que todos los nodos van a formar parte de una lista de nodos disponibles. Si se usa la variable global avail para apuntar a la lista disponible, podramos organizar inicialmente esta lista como:
void inicializaAvail(void){ int i; avail = 0; for(i=0; i<numNodes-1; i++){ node[i].next = i+1; } node[numNodes-1].next = -1; }

Cuando se requiere un nodo para usarlo en la lista, se obtiene de la lista disponible. Cuando ya no es necesario ese nodo, se devuelve a la lista disponible. Estas dos operaciones se implementan mediante las rutinas en C/C++ getnode y freenode:
int getNode(void){ int p; if (avail==-1){ std::cout<<"Overflow\n"; exit(1); } p=avail; avail=node[avail].next; return p; } Si avail es igual a -1 significa que no hay nodos disponibles, es decir, que el arreglo est

completamente lleno. Esto significa que las estructuras de lista de un programa particular han desbordado el espacio disponible. La funcin freeNode acepta un apuntador (nmero entero) a un nodo y devuelve ese nodo a la lista de disponibles:

void freeNode(int p){ node[p].next=avail; avail=p; }

Las operaciones primitivas para listas son versiones directas en C de los algoritmos correspondientes. La rutina insAfter acepta un apuntador p a un nodo y un elemento x como parmetros. Primero se asegura que p no sea nulo y despus se inserta x en el nodo siguiente al indicado por p.
void insAfter(int p, int x){ int q; if(p==-1){ std::cout<<"void insertion\n"; } else{ q=getNode(); node[q].info=x; node[q].next=node[p].next; node[p].next=q; } } La rutina delAfter(p,px), llamada por el enunciado delAfter(p,&x), suprime el nodo despus de node(p) y almacena su contenido en x; void delAfter(int p, int *px){ int q; if((p==-1)||(node[p].next==-1)){ std::cout<<"void detection\n"; } else{ q=node[p].next; *px = node[q].info; node[p].next=node[q].next; freeNode(q); } } Antes de llamar insAfter debemos asegurarnos de que ni p ni node[p].next sean

nulos.
EL USO DE MEMORIA DINMICA EN C/C++

Como sabemos, en lenguaje C/C++ , &x es la direccin donde se almacena en memoria la variable x. Si p es un apuntador en C/C++ , *p es el contenido de la localidad de memoria p. Si usamos C/C++ para implementar listas ligadas, podemos usar estos apuntadores. Sin embargo, primero analizaremos cmo asignar y liberar el almacenamiento en forma dinmica y cmo se accesa al almacenamiento dinmico en C/C++ . En C/C++ , una variable que debe contener la direccin en la memoria que almacena un nmero entero se crea mediante la declaracin
int *p;

Recordemos que esta declaracin se divide en dos partes: la parte de tipo int *, que indica que se trata de un apuntador a un entero; y la parte de identificador, en este caso p. Una vez declarada la variable p como un apuntador a un tipo especfico de dato, debe ser posible crear dinmicamente un objeto de este tipo especfico y asignar su direccin a p.

Esto se hace en C/C++ mediante la funcin de la biblioteca estndar malloc(size). La fucnin malloc asigna de manera dinmica una parte de memoria de tamao especificado en size y devuelve un apuntador a un elemento de tipo char. Consideremos las siguientes declaraciones
extern char *malloc(); int *pi; float *pr; La palabra clave extern especifica que una variable o funcin tiene un enlace externo.

Esto significa que la variable o funcin a la que nos referimos est definida en algn otro archivo fuente, o ms adelante en el mismo archivo. Sin embargo, en C/C++ podemos usar esta palabra clave extern con una cadena. La cadena indica que se est usando el convenio de enlace de otro lenguaje para los identificadores que se estn definiendo. Para los programas C++ la cadena por defecto es ``C++''. Los enunciados
pi = (int *) malloc(sizeof(int)); pr = (float *) malloc(sizeof(float)); crean directamente la variable entera *pi y la variable real *pr. Estas se denominan variables dinmicas. Al ejecutar estos enunciados, el operador sizeof devuelve el

tamao en bytes de su operando. Esto se usa para conservar la independencia de mquina. Despus, malloc crea un objeto de este tamao. Por tanto, malloc(sizeof(int)) asigna almacenamiento para un entero, en tanto que malloc(sizeof(float)) asigna espacio necesario para un real. De igual manera, malloc devuelve un apuntados al almacenamiento que asigna. Este apuntador es al primer byte de este almacenamiento y es de tipo char *. Para obligar al apuntador a que seale a un entero, usamos el operador de clculo (int *) (float *). El operador sizeof, devuelve un valor de tipo int, en tanto que la funcin malloc espera un parmetro de tipo unsigned. Para hacer que correspondan, debemos escribir
pi=(int *)malloc((unsigned)(sizeof(int)));

Como ejemplo, vamos a considerar este breve cdigo:


#include <iostream> int main (int argc, char * const argv[]) { ( 1) int *p, *q; ( 2) int x; ( 3) p = (int *)malloc(sizeof(int)); ( 4) *p = 3; ( 5) q = p; ( 6) std::cout<< *p << " " << *q << "\n"; ( 7) x = 7; ( 8) *q = x; ( 9) std::cout<< *p << " " << *q << "\n"; (10) p = (int *)malloc(sizeof(int)); (11) *p = 5; (12) std::cout<< *p << " " << *q << "\n"; return 0; }

En la l'inea (3), se crea una variable de tipo entero y su direccin se coloca en p. La lnea (4) establece el valor de esa variable en 3. La lnea (5) hace que la direccin q sea la misma direccin que p. El enunciado de la lnea (5) es perfectamente vlido, pues se

asigna a una variable de tipo apuntador (q) el valor de otra variable del mismo tipo (p). En este momento *p y *q hacen referencia a la misma variable. Por tanto, la lnea (6) imprime el contenido de esa variable (que ahora es 3) dos veces. En la lnea (7), se almacena el valor 7 en la variable entera x. La lnea (8) cambia el valor de *q al valor de x. sin embargo, dado que p y q apuntan a la misma variable, *p y *q tienen el valor 7. Por tanto la lnea (9) imprime el nmero 7 dos veces. La lnea (10) crea una nueva variable entera y coloca su direccin en p. Ahora *p hace referencia a la variable entera recin creada que todava no ha recibido un valor. q no ha cambiado; por lo que el valor de *q sigue siendo 7. Observemos que *p no hace referencia a una variable especfica nica. Su valor cambia conforme se modifica el valor de p. La lnea (11) establece el valor de esta variable recin creada en 5 y la lnea 12 imprime los valores 5 y 7. Y as la salida del programa es:
3 7 5 3 7 7

mallocEjemplo has exited with status 0. La funcin free se usa en C para liberar almacenamiento de una variable asignada

dinmicamente. La orden
free(p);

invalida cualquier referencia futura a la variable *p (a menos que se asigne nuevo espacio de memoraia a esa variable). Llamar free(p) hace que quede disponible para reso el almacenamiento ocupado por *p, si es necesario. La funcin free espera un parmetro apuntador del tipo char *, para que no tengamos problemas de tipos, debemos hacer
free((char *)p);

Consideremos el siguiente ejemplo para ilustrar el uso de free:


#include <iostream> int main (int argc, char * const argv[]) { int *p, *q; ( ( ( ( ( ( ( ( ( } 1) 2) 3) 4) 5) 6) 7) 8) 9) p=(int *)malloc(sizeof(int)); *p=5; q=(int *)malloc(sizeof(int)); *q=8; free(p); p=q; q=(int *)malloc(sizeof(int)); *q=6; std::cout<<*p<<" "<<*q<<"\n"; return 0;

Qu se imprime a la salida del programa? Observemos que si se llama malloc dos veces sucesivas y se asigna su valor a la misma variable como en:
p=(int *)malloc(sizeof(int)); *p=3; p=(int *)malloc(sizeof(int)); *p=7;

Se pierde la primera copia de *p, dado que su direccin no se guard

JUEVES, 6 DE OCTUBRE DE 2011

Estructuras de datos en c/c++ "Listas" parte 4


LISTAS LIGADAS USANDO MEMORIA DINMICA

Para hacer las listas ligadas necesitamos un conjunto de nodos, cada uno de los cuales tiene dos campos: uno de informacin y un apuntador al siguiente nodo de la lista. Adems, un apuntador externo seala el primer nodo de la lista. Usamos variables de apuntador para implementar apuntadores de listas. As que definimos el tipo de un apuntador y un nodo mediante
struct node{ int info; struct node *next; }; typedef struct node *nodePtr;

Un nodo de este tipo es igual a los nodos de la implementacin con arreglos, excepto que el campo next es un apuntador y no un entero. En lugar de declarar un arreglo, para que represente un conjunto acumulado de nodos, stos se asignan y liberan segn es necesario. Se elimina la necesidad de un conjunto de nodos previamente declarado. Si declaramos
nodePtr p;

la ejecucin de la orden
p=getNode();

debe colocar la direccin de un nodo disponible en p:


nodePtr getNode(void){ nodePtr p; p=(nodePtr)malloc(sizeof(struct node)); return(p); } Para liberar la memoria utilizada usamos freeNode. void freeNode(nodePtr p){ free(p); } Los procedimientos insAfter y delAfter usan la implementacin dinmica de una lista ligada. Supongamos que list es una variable apuntador que seala al primer nodo de

una lista (si lo hay) y es igual a NULL en el caso de una lista vaca.
void insAfter(nodePtr p, int x){ nodePtr q; if(p==NULL){ std::cout<<"Insercion nula\n"; } else{ q=getNode(); q->info=x;

q->next=p->next; p->next=q; } } void delAfter(nodePtr p, int *px){ nodePtr q; if((p==NULL)||(p->next==NULL)){ std::cout<<"Borrado prohibido\n"; } else{ q=p->next; *px=q->info; p->next=q->next; freeNode(q); } }

EJERCICIOS DE PROGRAMACIN

1. Implemente una pila usando memoria dinmica en listas ligadas. Implemente las operaciones push, pop, empty y stackTop. 2. Implemente una cola usando memoria dinmica en listas ligadas. Implemente las operaciones empty, insert y remove. 3. Desarrolle un programa para buscar un elemento en la lista (de nmeros enteros) y borrar la primera ocurrencia de ese elemento. 4. Desarrolle un programa para buscar un elemento en la lista (de nmeros enteros) y borrar todas las ocurrencias de ese elemento. 5. Las listas doblemente ligadas tienen nodos que estn divididos en tres segmentos: 1. Anterior: Un apuntador a un nodo 2. Info: La informacin de un nodo 3. Siguiente: Un apuntador a un nodo Implemente las operaciones borrarNodo(p), insertarNodoAntes e insertarNodoDespues.

JUEVES, 6 DE OCTUBRE DE 2011

Estructuras de datos en c/c++ "arboles" parte 1


rboles Los rboles son estructuras de datos tiles en muchas aplicaciones. Hay varias formas de rboles y cada una de ellas es prctica en situaciones especiales, en este captulo vamos a definir algunas de esas formas y sus aplicaciones.
CONCEPTO GENERAL DE RBOL

Desde el punto de vista de estructuras de datos, un rbol es un concepto simple en su definicin, sin embargo es muy ingenioso. Un rbol es un grafo con caractersticas muy especiales:

Definicin 9 Un rbol es un grafo


que tiene un nico nodo llamado raz que:

Tiene 0 relaciones, en cuyo caso se llama nodo hoja tiene un nmero finito de relaciones, en cuyo caso, cada una de esas relaciones es un subrbol

Para empezar a estudiar los rboles, nos concentraremos en primer lugar en el caso en que el nodo raz tenga 0, 1 2 subrboles.

RBOLES BINARIOS

Definicin 10 Un rbol binario es una estructura de datos de tipo rbol en donde cada uno de los nodos del rbol puede tener 0, 1, 2 subrboles llamados de acuerdo a su caso como:

Si el nodo raz tiene 0 relaciones se llama hoja. Si el nodo raz tiene 1 relacin a la izquierda, el segundo elemento de la relacin es el subrbol izquierdo. Si el nodo raz tiene 1 relacin a la derecha, el segundo elemento de la relacin es el subrbol derecho.

La figura 25 muestra algunas configuraciones de grafos que s son rboles binarios, y la figura 26 muestra algnas configuraciones de grafos que no son rboles binarios.

Figura 25: Grafos que son estructuras tipo rbol binario

Figura 26: Grafos que no son rboles binarios

Vamos a dar una lista de terminos que se usan frecuentemente cuando se trabaja con rboles:

Si A es la raz de un rbol y B es la raz de su subrbol izquierdo (o derecho), se dice que A es el padre de B y se dice que B es el hijo izquierdo (o derecho) de A. Un nodo que no tiene hijos se denomina hoja El nodo a es antecesor del nodo b (y recprocamente el nodo b es descendiente del nodo a), si a es el padre de b o el padre de algn ancestro de b. Un nodo b es un descendiente izquierdo del nodo a, si b es el hijo izquierdo de a o un descendiente del hijo izquierdo de a. Un descendiente derecho se define de la misma forma. Dos nodos son hermanos si son hijos izquierdo y derecho del mismo padre.

Otros trminos relacionados con rboles, tienen que ver con su funcinoamiento y topologa:

Si cada nodo que NO es una hoja tiene un subrbol izquierdo y un subrbol derecho, entonces se trata de un rbol binario completo. El nivel de un nodo es el nmero de aristas que se deben recorrer para llegar desde ese nodo al nodo raz. De manera que el nivel del nodo raz es 0, y el nivel de cualquier otro nodo es el nivel del padre ms uno. La profundidad de un nodo es el mximo nivel de cualquier hoja en el rbol. nodos en el nivel , el mximo nmero de nodos en el nivel

Si un rbol binario tiene

es . Dado que un rbol binario slo tiene un nodo en el nivel 0, puede contener un mximo de nodos en el nivel . Un rbol binario completo de profundidad es el rbol que contiene exactamente nodos en cada nivel entre 0 y . La

cantidad total de nodos en un rbol binario completo de profundidad suma de nodos en cada nivel entre 0 y , por tanto:

, es igual a la

Usando induccin matemtica se puede demostrar que que todas las hojas en este rbol estn en el nivel tanto, nodos que no son hojas. , el rbol contiene

. Dado hojas y, por

Si conocemos el nmero total de nodos

en un rbol binario completo, podemos

calcular su profundidad , a partir de la expresin . As sabemos que la profundidad es igual a 1 menos que el nmero de veces que 2 debe ser multiplicado por s mismo para llegar a . Es decir, que en un rbol binario completo,

Definicin 11 Un rbol binario es un rbol binario casi completo si:

1. Cualquier nodo a un nivel menor que tiene 2 hijos 2. Para cualquier nodo en el rbol con un descendiente derecho en el nivel debe tener un hijo izquierdo y cada descendiente izquierdo de : o es una hoja en el nivel o tiene dos hijos

Figura 27: Comparacin de un rbol binario y un rbol binario casi completo. El rbol mostrado en (A) descumple la regla 2 de los rboles binarios casi completos.

Los nodos en un rbol binario (completo, casi completo o incompleto) se pueden enumerar del siguiente modo. Al nodo raz le corresponde el nmero 1, al hijo izquierdo le corresponde el doble del nmero asignado al padre y al hijo derecho le corresponde el doble ms 1 del nmero asignado al padre.

JUEVES, 6 DE OCTUBRE DE 2011

Estructuras de datos en c/c++ "arboles" parte 2


Operaciones con rboles binarios
Con los rboles binarios es posible definir algunas operaciones primitivas, estas operaciones son en el sentido de saber la informacin de un nodo y sirven para desplazarse en el rbol, hacia arriba o hacia abajo.
info(p)

que devuelve el contenido del nodo apuntado por p.


left(p)

devuelve un apuntador al hijo izquierdo del nodo apuntado por p, o bien, devuelve NULL si el nodo apuntado por p es una hoja.
right(p)

devuelve un apuntador al hijo derecho del nodo apuntado por p, o bien, devuelve NULL si el nodo apuntado por p es una hoja.
father(p)

devuelve un apuntador al padre del nodo apuntado por p, o bien, devuelve NULL si el nodo apuntado por p es la raz.
brother(p)

devuelve un apuntador al hermano del nodo apuntado por p, o bien, devuelve NULL si el nodo apuntado por p no tiene hermano. Estas otras operaciones son lgicas, tienen que ver con la identidad de cada nodo:
isLeft(p)

devuelve el valor true si el nodo actual es el hijo izquierdo del nodo apuntado por p, y false en caso contrario.
isRight(p)

devuelve el valor true si el nodo actual es el hijo derecho del nodo apuntado por p, y false en caso contrario.
isBrother(p)

devuelve el valor true si el nodo actual es el hermano del nodo apuntado por p, y false en caso contrario. Como ejemplo, un algoritmo para el procedimiento isLeft es como sigue:
q=father(p); if(q==NULL) return(false) /* porque p apunta a la raiz */ if (left(q)==p) return(true); return(false);

En la construccin de un rbol binario son tiles las operaciones makeTree, setLeft y setRight. La operacin makeTree(x) crea un nuevo rbol binario que consta de un nico nodo con un campo de informacin x y devuelve un apuntador a ese nodos. La operacin setLeft(p,x) acepta un apuntador p a un nodo de rbol binario sin hijo izquierdo. Crea un nuevo hijo izquierdo de node(p) con el campo de informacin x. La operacin setRight(p,x) es similar, excepto que crea un hijo derecho.

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 situacin 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 nmero pequeo, pero el problema se va complicando ms a medida que aumenta. Si usamos un rbol binario, el nmero de comparaciones se reduce bastante, veamos cmo. El primer nmero del arreglo se coloca en la raz del rbol (como en este ejemplo siempre vamos a trabajar con rboles binarios, simplemente diremos rbol, para referirnos a un rbol binario) con sus subrboles izquierdo y derecho vacos. Luego, cada elemento del arreglo se compara son la informacin del nodo raz y se crean los nuevos hijos con el siguiente criterio:

Si el elemento del arreglo es igual que la informacin del nodo raz, entonces notificar duplicidad. Si el elemento del arreglo es menor que la informacin del nodo raz, entonces se crea un hijo izquierdo. Si el elemento del arreglo es mayor que la informacin del nodo raz, 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: Sea k la informacin del nodo actual p. Si right(p), en caso contrario, en caso de que entonces cambiar el nodo actual a informar una ocurrencia duplicada y

en caso de que cambiar el nodo actual a left(p). El siguiente algoritmo


leer numero buscado >> n tree=makeTree(n) while(hay numeros en el arreglo){ leeSiguienteNumero >> k p=q=tree; while(k!=info(p)&&q!=NULL){ p=q if(k<info(p)) q=left(p) else q=right(p) } if(k==info(p)) despliega<<" el numero es duplicado"; else if (k<info(p)) setLeft(p,k) else setRight(p,k) }

Figura 28: rbol binario para encontrar nmeros duplicados

Para saber el contenido de todos los nodos en un rbol es necesario recorrer el rbol. Esto es debido a que solo tenemos conocimiento del contenido de la direccin de un nodo a la vez. Al recorrer el rbol es necesario tener la direccin de cada nodo, no necesariamente todos al mismo tiempo, de hecho normalmente se tiene la direccin de uno o dos nodos a la vez; de manera que cuando se tiene la direccin de un nodo, se dice que se visita ese nodo. Aunque hay un orden preestablecido (la enumeracin de los nodos) no siempre es bueno recorrer el rbol en ese orden, porque el manejo de los apuntadores se vuelve ms complejo. En su lugar se han adoptado tres criterios principales para recorrer un rbol

binario, sin que de omita cualquier otro criterio diferente. Los tres criterios principales para recorrer un rbol binario y visitar todos sus nodos son, recorrer el rbol en: preorden: Se ejecutan las operaciones: 1. Visitar la raz 2. recorrer el subrbol izquierdo en preorden 3. recorrer el subrbol derecho en preorden entreorden: Se ejecutan las operaciones: 1. recorrer el subrbol izquierdo en entreorden 2. Visitar la raz 3. recorrer el subrbol derecho en entreorden postorden: Se ejecutan las operaciones: 1. recorrer el subrbol izquierdo en postorden 2. recorrer el subrbol derecho en postorden 3. Visitar la raz Al considerar el rbol binario que se muestra en la figura 28 usando cada uno de los tres criterios para recorrer el rbol se tienen las siguientes secuencias de nodos: En preorden: En entreorden: En postorden: Esto nos lleva a pensar en otra aplicacin, el ordenamiento de los elementos de un arreglo. Para ordenar los elementos de un arreglo en sentido ascendente, se debe construir un rbol similar al rbol binario de bsqueda, pero sin omitir las coincidencias. El arreglo usado para crear el rbol binario de bsqueda fue
<14,15,4,9,7,18,3,5,16,4,20,17,9,14,5>

El rbol de ordenamiento es el que se muestra en la figura 29

Figura 29: rbol binario para ordenar una secuencia de nmeros

Para ordenar los elementos de este arreglo basta recorrer el rbol en forma de entreorden. Cul sera el algoritmo para ordenarlo de manera descendente?

JUEVES, 6 DE OCTUBRE DE 2011

Estructuras de datos en c/c++ "arboles" parte 3


REPRESENTACIN EN C/C++ DE LOS RBOLES BINARIOS

Vamos a estudiar estas representaciones por partes, primero los nodos y el rbol; despus las operaciones para el manejo del rbol.

Representacin de los nodos


Los nodos de los rboles binarios son estructuras en C/C++ que estan compuestas por tres partes:

Un apuntador al subrbol izquierdo, left Un apuntador al subrbol derecho, right Una parte de informacin, que puede ser una estructura en s misma, info. Adicionalmente es muy til poner un apuntador al padre del nodo. father.

Usando una implementacin de arreglos tenemos:


#define numNodes 500 struct nodeType{ int info; int left; int right; int father; }; struct nodeType node[numNodes];

y usando una representacin con memoria dinmica, los nodos de un rbol se puede representar tambien con una estructura en C/C++ :

struct nodeType{ int info; struct nodeType *left; struct nodeType *right; struct nodeType *father; }; struct nodeType *nodePtr; La operaciones info(p), left(p), right(p) y father(p) se implementaran mediante referencias a p->info, p->left, p->right y p->father respectivamente. Las rutinas getnode y freenode simplemente asignan y liberan nodos usando las rutinas malloc y free. nodePtr makeTree(int x){ nodePtr p; p = getNode(); p->info = x; p->left = NULL; p->right = NULL; return p; } La rutina setLeft(p,x) establece un nodo con contenido x como el hijo izquierdo de node(p). void setLeft(nodePtr p, int x){ if(p == NULL) std::cout<<"Insercion nula\n"; else if(p->left != NULL) std::cout<<"Insercion no valida\n"; else p->left=maketree(x); } La rutina para setRight(p,x) es similar a la rutina anterior.

Cuando se establece la diferencia entre los nodos de hojas y los no-hojas, los nodos que no son hojas se llaman nodos internos y los nodos que s son hojas se llaman nodos externos.

Recorridos de rbol binario en C/C++


Aqu usaremos recursividad para hacer estas rutidas de los recorridos de rboles binarios. Las rutinas se llaman preTr, inTr y postTr, que imprimen el contenido de los nodos de un rbol binario en orden previo, en orden y en orden posterior, respectivamente. El recorrido en pre orden se logra con esta rutina:
void preTr(nodePtr tree){ if (tree != NULL){ std::cout<<tree->info; preTr(tree->left); preTr(tree->right); } }

El recorrido en entre-orden se logra con esta rutina:


void inTr(nodePtr tree){ if (tree != NULL){

inTr(tree->left); std::cout<<tree->info; inTr(tree->right); } }

y el recorrido en post-orden se logra con esta rutina:


void postTr(nodePtr tree){ if (tree != NULL){ postTr(tree->left); postTr(tree->right); std::cout<<tree->info; } }

JUEVES, 6 DE OCTUBRE DE 2011

Estructuras de datos en c/c++ "arboles" parte 4


RBOLES

Hasta ahora hemos visto los rboles binarios que son aquellos rboles que sus nodos solamente pueden tener un mximo de dos hijos. Cuando ocurre que los nodos tienen cualquier nmero finito de hijos, son rboles (en genreal). De manera que Definicin 12 Un rbol es un conjunto finito no vaco de elementos en el cual un elemento se denomina la raz y los restantes se dividen en subconjuntos disjuntos, cada uno de los cuales es por s mismo un rbol. Cada elemento en un rbol se denomina un nodo del rbol Un nodo sin subrboles es una hoja. Usamos los trminos padre, hijo, hermano, antecesor, descendiente, nivel y profundidad del mismo modo que en los rboles binarios. El grado de un nodo es en nmero mximo de hijos que aln nodo tiene. Un rbol ordenado de define como un rbol en el que los subrboles de cada nodo forman un conjunto ordenado. En un rbol ordenado, podemos hablar del primero, segundo o ltimo hijo de un nodo en particular. El primer hijo de un nodo en un rbol ordenado se denomina con frecuencia el hijo ms viejo de este nodo y el ltimo se denomina el hijo ms joven. Vase la figura 30. Un bosque es un conjunto ordenado de

rboles ordenados.

Figura 30: El rbol de la izquierda es ordenado y el rbol de la derecha es un rbol no ordenado.

Representacin dinmica en C de los rboles


Al igual que en los rboles binarios, los nodos en un rbol tienen una parte de informacin, un apuntador al padre y uno o ms apuntadores a los hijos. De manera que una solucin es crear una estructura que incluya una lista dinmica de apuntadores, como lo muestra la figura 31.

Figura 31: Representacin con listas de los nodos de un rbol struct treeNode{ int info; struct treeNode *father; struct treeNode *son; struct treeNode *next; }; typedef struct treeNode *nodePtr;

Si todos los recorridos se realizan de un nodo a sus hijos se omite el campo father. Incluso si es necesario acceder al padre de un nodo, el campo father se omite colocando un apuntador al padre en el campo next del hijo ms joven, en lugar de dejarlo en null. Se podra usar un campo lgico adicional para indicar si el campo next apunta al siguiente hijo ``real'' o al padre. Si consideramos que son corresponde al apuntador left de un nodo de rbol binario y

que next corresponde a su apuntador right, este mtodo representa en realidad un rbol ordenado general mediante un rbol binario.

Recorridos de rbol
Los mtodos de recorrido para rboles binarios inducen mtodos para recorrer los rboles en general. Si un rbol se representa como un conjunto de nodos de variables dinmicas con apuntadores son y next, una rutina en C/C++ para imprimir el contenido de sus nodos se escribira como:
void inTr(nodePtr tree){ if (tree != NULL){ inTr(tree->left); std::cout<<tree->info; inTr(tree->right); } }

Las rutinas para recorrer el rbol en los dems ordenes son similares. Estos recorridos tambin se defininen directamente as: Orden previo: similar al caso binario. 1. Visitar la raz 2. Recorrer en orden previo los subrboles de izquierda a derecha Las demas rutinas son similares. Un bosque puede ser representado medianto un rbol binario. Para hacer esta representacin, la raz de cada rbol se coloca en una lista de apuntadores; luego para cada nodo en la lista (la raz de cada rbol) se procede del siguiente modo: 1. Se crea una lista de subrboles izquierdos con los apuntadores a cada uno de los rboles en el bosque. 2. si un nodo tiene ms de un hijo, entonces se crea un subrbol izquierdo y se forma una lista de subrboles izquierdos con todos los hijos de ese nodo.

Figura 32: Arriba: Un bosque de rboles. Abajo: El rbol binario que corresponde a ese bosque.

Para recorrer los nodos de un bosque, es preferible convertir todo el bosque en un rbol binario correspondiente, como se ilustra en la figura 32. Cuando ya se tiene el rbol binario que corresponde a ese bosque, entonces se aplican las rutinas ya conocidas. Si el bosque es un bosque ordenado, es decir, que todos los rboles del bosque son rboles ordenados; entonces un recorrido en entreorden dar como resultado una secuencia de nodos ordenada en sentido ascendente.
EJERCICIOS DE PROGRAMACIN

1. Escriba un programa que acepte un apuntador a un nodo y devuelva un valor verdadero si este nodo es la raz de un rbol binario vlido y falso en caso contrario. 2. Escriba un programa que acepte un apuntador a un rbol binario y un apuntador a un nodo del rbol, y devuelva el nivel del nodo en el rbol. 3. Escriba un programa para ejecutar el experimento siguiente: genere 100 nmeros aleatorios. Conforme se genera cada nmero, insrtelo en un rbol de bsqueda binaria inicialmente vaco. Despus de insertar los 100 nmeros, imprima el nivel de la hoja que tiene el nivel ms grande y el nivel de la hoja que tiene el nivel ms chico. Repita este proceso 50 veces. Imprima una tabla que indique cuntas veces de las 50 ejecuciones produjeron una diferencia entre el nivel de hoja mximo y mnimo de 0,1,2,3, y as sucesivamente. 4. Implemente los recorridos de los rboles binarios. 5. Si un bosque se representa mediante un rbol binario, muestre que el nmero de vnculos derechos nulos es 1 mayor que el nmero de no hojas del bosque

JUEVES, 6 DE OCTUBRE DE 2011

Estructuras de datos en c/c++ "grafos" parte 1


Grafos
En esta parte del curso vamos a retomar la idea de los grfos. Hasta ahora homos visto las listas y los rboles como casos especiales de los grafos. Resumiendo, las listas son grafos en donde cada nodo tiene una arista que sale y una arista que llega, excepto un par de nodos, uno de esos nodos es el inicio de la lista que tiene no tiene arista que entra; y el otro nodo es el final de la lista que no tiene arista que sale; En los rboles, los nodos tienen una arista que llega (la del padre) y una o ms aristas que salen (los hijos). Como veremos ms adelante con mucho mayor detalle, los nodos en los grafos no tienen lmite de aristas que salen o aristas que lleguen, por eso tanto las listas como los rboles son casos particulares de los grafos.
RECORDATORIO DE LAS DEFINICIONES

Un grafo consiste de una tupla

, en donde

es un conjunto de

elementos llamados nodos; y es una relacin, representada por un conjunto de pares ordenados de nodos. El conjunto de nodos debe de ser un conjunto no-vaco, esto significa que para que exista un grafo es necesario al menos un nodo. El conjunto de aristas puede ser el conjunto vac. En la figura 33 se muestra un grafo y sus conjuntos de nodos y de aristas.

Figura 33: Grafo dirigido o digrafo

Si las aristas de un grafo no estn dirigidas se omiten las flechas, y se dice entonces que es un grafo (no un grafo dirigido). Cuando en las aristas no hay flechas, se entiende que

hay una relacin reflexiva, es decir, si para un grafo que sentido de la relacin.

y se tiene

, entonces no se dibujan las flechas. Porque la flecha indica el

Si es un grafo, los siguientes trminos son frecuentemente usados al trabajar con : Nodo incidente:

Si Grado de incidencia:

entonces tanto el nodo

como el nodo

son nodos incidentes.

Se define para cada nodo, y es su mximo numero de incidencias. Tambin se conoce con el nombre de ``valencia''. Grado interno: Tambin se define para cada nodo y es el nmero de aristas que llegan a ese nodo. Otro nombre para este trmino es ``valencia de entrada''. Grado externo: Para cada nodo es el nmero de aristas que salen del nodo. Se conoce tambin con el nombre de ``valencia de salida''. Adyacencia:

Si

, el nodo , pero

es adyacente al nodo

si

. Note que si no es adyacente al nodo

, entonces el nodo .

, pero el nodo Sucesor: Si el nodo . Antecesor: Si el nodo nodo .

si es adyacente al nodo

es adyacente al nodo

, entonces el nodo

es el sucesor del nodo

es adyacente al nodo

, entonces el nodo

es el antecesor del

Es posible asociar una etiqueta a cada arista, como se muestra en la figura 34. La etiqueta asociada con cada arista se denomina peso.

Figura 34: Grafo dirigido con pesos

Los grafos ponderados son relaciones definidas por un conjunto de elementos, en donde cada elemento es un trio ordenado donde y , para algn conjunto de pesos. Con los grafos y grafos ponderados (los que tienen pesos) se pueden tener algunas operaciones bsicas:

Con grafos:
join(a,b):

Agrega una relacin del nodo a al nodo b. Si la relacin no existe, entonces crea una relacin.
removeArc(a,b):

Quita un arco del nodo a al nodo b

Con grafos ponderados:


joinWt(a,b,w):

Agrega una relacin del nodo a al nodo b y le asocia el peso w. Si la relacin no existe, entonces de crea la relacin y le asocia el peso indicado.
removeArcWt(a,b):

Quita un arco del nodo a al nodo b con peso w.

La operacin isAdjacent(a,b) devuelve un valor TRUE si el nodo a es adyacente al nodo b, y devuelve un valor FALSE en caso contrario. del nodo a al nodo b se define como una secuencia de tal que , y isAdjacent(n

Una trayectoria de longitud nodos


,n

) para todas las . Una trayectoria de longitud 1 un nodo a s mismo es un autociclo. Si existe una trayectoria de longitud mayor que 1 de un nodo a s mismo, entonces es un ciclo. Si el grafo es acclico y dirigido, entonces se llama dag (directed acyclic graph).
APLICACIN EJEMPLO

Supongamos el grafo ponderado de la figura 35, este grafo tiene como conjunto de nodos y una relacin

Figura: Grafo

Se desea saber si existe un camino entre un par de nodos dado.