REPBLICA BOLIVARIANA DE VENEZUELA. MINISTERIO DEL PODER POPULAR PARA LA EDUCACIN. UNIVERSIDAD BOLIVARIANA DE VENEZUELA. SABANETA ESTADO BARINAS.

PROFESOR: Cirilo Linares.

INTEGRANTE: Yenni del P. Garca V. C.I: 18.588.202. Ing. Informtica 3er trimestre

Sabaneta, Enero del 2013.

NDICE.

Introduccin.3 Estructura de datos. .4 Ejercicios. ......7 Pilas. ...8 Colas..14 rbol binario C/c++.....20 Listas. ...27 Conclusin....38 Bibliografa....39

INTRODUCCIN.

Como ya sabemos, las computadoras fueron diseadas o ideadas como una herramienta mediante la cual podemos realizar operaciones de clculo complicadas en un lapso de mnimo tiempo. Pero la mayora de las aplicaciones de este fantstico invento del hombre, son las de almacenamiento y acceso de grandes cantidades de informacin. La informacin que se procesa en la computadora es un conjunto de datos, que pueden ser simples o estructurados. Los datos simples son aquellos que ocupan slo un localidad de memoria, mientras que los estructurados son un conjunto de casillas de memoria a las cuales hacemos referencia mediante un identificador nico. Debido a que por lo general tenemos que tratar con conjuntos de datos y no con datos simples (enteros, reales, booleanos, etc.) que por s solos no nos dicen nada, ni nos sirven de mucho, es necesario tratar con estructuras de datos adecuadas a cada necesidad. Las estructuras de datos son una coleccin de datos cuya organizacin se caracteriza por las funciones de acceso que se usan para almacenar y acceder a elementos individuales de datos.

Para fortalecer este tema podemos tambin citamos una estructura de datos dinmicas representada por pilas, colas, rbol binario C/c++ y listas, que posee un primer nivel de abstraccin en donde simplemente se identifica la coleccin de elementos a agrupar y sus operaciones de acceso.

ESTRUCTURA DE DATOS.

En programacin, una estructura de datos es una forma de organizar un conjunto de datos elementales con el objetivo de facilitar su manipulacin. Un dato elemental es la mnima informacin que se tiene en un sistema. Una estructura de datos define la organizacin e interrelacin de estos y un conjunto de operaciones que se pueden realizar sobre ellos.

Las operaciones bsicas son:

Alta, adicionar un nuevo valor a la estructura. Baja, borrar un valor de la estructura. Bsqueda, encontrar un determinado valor en la estructura para realizar una operacin con este valor, en forma secuencial o binario (siempre y cuando los datos estn ordenados).

Otras operaciones que se pueden realizar son:

Ordenamiento, de los elementos pertenecientes a la estructura. Apareo, dadas dos estructuras originar una nueva ordenada y que contenga a las apareadas. Cada estructura ofrece ventajas y desventajas en relacin a la simplicidad y eficiencia

para la realizacin de cada operacin. De esta forma, la eleccin de la estructura de datos apropiada para cada problema depende de factores como la frecuencia y el orden en que se realiza cada operacin sobre los datos. Una de las aplicaciones ms interesantes y potentes de la memoria dinmica y de los punteros son, sin duda, las estructuras dinmicas de datos. Las estructuras bsicas disponibles en C y C++ (structs y arrays) tienen una importante limitacin: no pueden cambiar de tamao durante la ejecucin. Los arrays estn compuestos por un

determinado nmero de elementos, nmero que se decide en la fase de diseo, antes de que el programa ejecutable sea creado. En muchas ocasiones se necesitan estructuras que puedan cambiar de tamao durante la ejecucin del programa. Por supuesto, podemos crear arrays dinmicos, pero una vez creados, tu tamao tambin ser fijo, y para hacer que crezcan o disminuyan de tamao, deberemos reconstruirlos desde el principio. Las estructuras dinmicas nos permiten crear estructuras de datos que se adapten a las necesidades reales a las que suelen enfrentarse nuestros programas. Pero no slo eso, como veremos, tambin nos permitir crear estructuras de datos muy flexibles, ya sea en cuanto al orden, la estructura interna o las relaciones entre los elementos que las componen. Las estructuras de datos estn compuestas de otras pequeas estructuras a las que llamaremos nodos o elementos, que agrupan los datos con los que trabajar nuestro programa y adems uno o ms punteros autorreferenciales, es decir, punteros a objetos del mismo tipo nodo. Una estructura bsica de un nodo para crear listas de datos seria: struct nodo \{ int dato; struct nodo *otronodo; }; El campo "otronodo" puede apuntar a un objeto del tipo nodo. De este modo, cada nodo puede usarse como un ladrillo para construir listas de datos, y cada uno mantendr ciertas relaciones con otros nodos. Las estructuras dinmicas son una implementacin de TDAs o TADs (Tipos Abstractos de Datos). En estos tipos el inters se centra ms en la estructura de los datos que en el tipo concreto de informacin que almacenan.

Dependiendo del nmero de punteros y de las relaciones entre nodos, podemos distinguir varios tipos de estructuras dinmicas. Enumeraremos ahora slo de los tipos bsicos:

Listas abiertas: cada elemento slo dispone de un puntero, que apuntar al siguiente elemento de la lista o valdr NULL si es el ltimo elemento. Pilas: son un tipo especial de lista, conocidas como listas LIFO (Last In, First Out: el ltimo en entrar es el primero en salir). Los elementos se "amontonan" o apilan, de modo que slo el elemento que est encima de la pila puede ser ledo, y slo pueden aadirse elementos encima de la pila.

Colas: otro tipo de listas, conocidas como listas FIFO (First In, First Out: El primero en entrar es el primero en salir). Los elementos se almacenan en fila, pero slo pueden aadirse por un extremo y leerse por el otro.

Listas circulares: o listas cerradas, son parecidas a las listas abiertas, pero el ltimo elemento apunta al primero. De hecho, en las listas circulares no puede hablarse de "primero" ni de "ltimo". Cualquier nodo puede ser el nodo de entrada y salida.

Listas doblemente enlazadas: cada elemento dispone de dos punteros, uno a punta al siguiente elemento y el otro al elemento anterior. Al contrario que las listas abiertas anteriores, estas listas pueden recorrerse en los dos sentidos.

Arboles: cada elemento dispone de dos o ms punteros, pero las referencias nunca son a elementos anteriores, de modo que la estructura se ramifica y crece igual que un rbol.

Arboles binarios: son rboles donde cada nodo slo puede apuntar a dos nodos. Arboles binarios de bsqueda (ABB): son rboles binarios ordenados. Desde cada nodo todos los nodos de una rama sern mayores, segn la norma que se haya seguido para ordenar el rbol, y los de la otra rama sern menores.

Arboles AVL: son tambin rboles de bsqueda, pero su estructura est ms optimizada para reducir los tiempos de bsqueda. Arboles B: son estructuras ms complejas, aunque tambin se trata de rboles de bsqueda, estn mucho ms optimizados que los anteriores.

ESTRUCTURA DE DATOS: PILA.

RECORRIDO DE LA PILA: Ya que las pilas son LIFO (Last in - First Out) el Recorrido se hace sacando el ltimo dato que se inserto hasta que no encuentre ningn otro.

Detalle: Apuntador toma el Top, despus ve si la condicin cumple para efectuar un Ciclo mientras Apuntador sea diferente de Nulo, si cumple lo que hace es que despliega el contenido de la Pila (Pila[Apuntador]), despus Apuntador se le resta 1. Este proceso se repite hasta que Apuntador sea igual Nulo (Cuando llega a este punto la Pila ya fue Recorrida).

ALGORITMO:

DIAGRAMA:

Recorrido (Pila, Top); Apuntador - Top; Repetir mientras Apuntador & ne; Nulo; Imprimir Pila [Apuntador]; Apuntador - Apuntador 1; Fin del ciclo; Salir

PUSH: es simplemente el mtodo por el cual va agregando un Dato nuevo a la Pila tomando en cuenta la Capacidad Mxima (Max) de almacenar un dato.

Detalle: Compara en un principio el Top con Max, si la condicin no cumple es imposible insertar ms datos a la Pila, de otra forma lo que hace es Incrementar el valor de Top, y copia el valor de Elemento en Pila [Top]. De esta forma el dato ya esta insertado.

ALGORITMO:

DIAGRAMA:

Push (Pila, Top, Max, Elemento) Si Top ≠ Max Top - Top + 1 Pila [Top] - Elemento Si no: Imprimir Pila Llena Salir

POP: es simplemente el mtodo por el cual va sacando el ltimo Dato de la Pila, basndose nicamente en el Top.

Detalle: Compara para determinar si la pila esta vacio, de otra forma lo que hace es Imprimir el valor de Pila[Top] (Que es el dato que esta apunto de Eliminar) y enseguida a Top le resta 1, de esta forma el dato ya no existe.

ALGORITMO: Pop (Pila, Top) Si Top & ne; Nulo Imprimir Pila [Top] Top - Top - 1 Si no: Imprimir Pila Vaca Salir

DIAGRAMA:

BSQUEDA: Este mtodo usa el recorrido para encontrar Elemento y desplegar un mensaje si la bsqueda es exitosa.

Detalle: El algoritmo compara para determinar si la Pila tiene algn dato, si no simplemente desplegara Lista Vaca y saldr. De otra manera har un Recorrido y comparara con cada uno de los Datos de la Pila hasta encontrar el dato que desea buscar. Si lo encuentra desplegara El Dato fue encontrado de otra manera El Dato no se encontr.

ALGORITMO:

DIAGRAMA:

Bsqueda (Pila, Top, Elemento) Si Top & ne; Nulo Apuntador - Top Repetir mientras Apuntador & ne; Nulo Si Pila [Apuntador] = Elemento Imprimir El Dato fue encontrado y Salir Apuntador - Apuntador - 1 Fin del ciclo Imprimir El Dato no se encontr Si no: Imprimir Pila Vaca Salir

ELIMINAR: Este mtodo busca un Dato dentro de la pila y lo elimina.

Detalle: El algoritmo compara para determinar si la Pila tiene algn dato, si no simplemente desplegara Pila Vaca y saldr. De otra manera har un Recorrido y comparara con cada uno de los Datos de la Pila hasta encontrar el dato que desea eliminar, mientras hace esto copia cada uno de los datos a un arreglo Temp para cuando

encuentre el Dato regresar esos valores a la Pila. Si lo encuentra desplegara Eliminado el Dato y le restara 1 a Top, de otra manera El Dato no encontrado.

ALGORITMO:

DIAGRAMA:

Borrar (Pila, Temp, Top, Elemento) Si Top & ne; Nulo Apuntador1 - Top Repetir mientras Apuntador1 & ne; Nulo Si Pila [Apuntador1] = Elemento Imprimir Eliminando el Dato Repetir mientras Apuntador2 ≠ Nulo Pila [Apuntador1]=Temp [Apuntador2] Fin del ciclo Top - Top - 1 y Salir Si No: Temp [Apuntador2] - Pila [Apuntador1] Apuntador1 - Apuntador1 - 1 Apuntador2 - Apuntador2 + 1 Fin del ciclo Imprimir Dato no encontrado Si no: Imprimir Pila Vaca Salir

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 sesin 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 puede describir en un modelo orientado a objetos. La operacin Push: en el siguiente segmento de cdigo se puede implementar la operacin insertar un elemento a una pila. Hemos supuesto que la pila ya est definida como una estructura stack. . (1) void push(struct stack *S,int e) {(2) (3) (4) } S->top++; S->item[S->top]=e;

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 tem 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) (3) (4) (5) bool valorDevuelto; if(S->top== -1) valorDevuelto=true; else

(6) (7) (8) }

valorDevuelto=false; return valorDevuelto;

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 veracidad 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) (2) (3) (4) (5) (6) (7) (8) (9) ... case 4:{ if (not stackempty(&A)){ valor=pop(&A); std::cout<<"La cima de la pila es: "<<valor<<"\n"; push(&A,valor); } else std::cout<<"La pila esta vacia"; break; } ... ESTRUCTURA DE DATOS: COLA. RECORRIDO: Ya que las colas son FIFO (First in - First Out) el Recorrido se hace sacando el primer dato que se inserto hasta que llegue al extremo llamado Final. Detalle: En un principio se compara para saber si tiene algn dato en la Cola, si no es as desplegara Cola Vaca. De otra forma compara si Frente es mayor o igual a Final, de esta forma simplemente hace un Recorrido lineal como los anteriores.

De otra forma usar Max como bandera para saber cundo empezar a contar de 0 a Final (Ya que sabemos que el Frente despus del nodo Final). ALGORITMO: Recorrido (Cola, Frente, Final, Max) Si Frente Nulo Si Frente Final, entonces: Apuntador <-- Frente Repetir mientras Apuntador Final Imprimir Cola [Apuntador] Apuntador <-- Apuntador + 1 Fin del ciclo Si no, si Frente > Final, entonces: Apuntador <-- Frente Repetir mientras Apuntador Final Si Apuntador > Max, entonces: Apuntador <-- 0 Imprimir Cola [Apuntador] Apuntador <-- Apuntador + 1 Fin del ciclo Si no: Imprimir "Cola Vaca"; Salir PUSH: es simplemente el mtodo por el cual va agregando un Dato nuevo a la Cola tomando en cuenta el Tamao Mximo de Capacidad (Max), el Frente y el Final de la Cola. Detalle: Primer nos aseguramos que la Cola no est Llena, para que de esta manera sea capaz de insertar un Elemento nuevo. Si no desplegara Cola Llena. Despus compara para determinar las posiciones de Frente y Final y de esta manera poder moverlo con libertad. Ya que determina los valores de Frente y Final, nos Indica que Cola [Final] tomara el valor de Elemento. DIAGRAMA:

ALGORITMO: Push (Cola, Frente, Final, Max, Elemento) Si Frente = 0 y Final =9, o si Frente = (Final + 1) Imprimir "Cola Llena" y Salir Si Frente = Nulo Frente <-- 0 Final <-- 0 Si no, si Final = Max Final <-- 0 Si no: Final <-- Final + 1 Cola [Final] = Elemento Salir

DIAGRAMA:

POP: es simplemente el mtodo por el cual va sacando el primer Dato de la Cola (esto se comprueba ya que las Colas son FIFO), para esto toma en cuenta el Frente. Detalle: Compara para determinar si la cola est vaca, de otra forma lo que hace es Imprimir Eliminando el Dato. Despus se hacen una series de comparaciones para determinar la nueva posicin de Frente, de esa forma el Dato que exista en Frente es Eliminado.

ALGORITMO:

DIAGRAMA:

Pop (Cola, Frente, Final, Max) Si Frente Nulo Imprimir "Eliminado el Dato..." Si Frente = Final Frente = Nulo Final = Nulo Si no, si Frente = Max Frente = 0 Si no: Frente <-- Frente + 1 Si no: Imprimir "Cola Vaca" Salir BSQUEDA: Este mtodo usa el recorrido para encontrar Elemento y desplegar un mensaje si la bsqueda es exitosa. Detalle: El algoritmo usa bsicamente la misma estructura del Recorrido, la nica diferencia es que compara cada uno de los Datos con Elemento, de esta forma se da cuenta si este Dato existe en la Cola. ALGORITMO: Busqueda (Cola, Frente, Fin, Max, Elemento) Si Frente Nulo Si Frente Final, entonces: Apuntador <-- Frente Repetir mientras Apuntador Final Si Elemento = Cola [Apuntador] Imprimir "Dato encontrado..." y Salir Apuntador <-- Apuntador + 1 Fin del ciclo DIAGRAMA:

Si no, si Frente > Final, entonces: Apuntador <-- Frente Repetir mientras Apuntador Final Si Apuntador > Max, entonces: Apuntador <-- 0 Si Elemento = Cola [Apuntador] Imprimir "Dato encontrado..." y Salir Apuntador <-- Apuntador + 1 Fin del ciclo Imprimir "Dato no encontrado..." Si no: Imprimir "Cola Vaca" Salir

ELIMINACIN: Este mtodo busca un Dato dentro de la cola y lo elimina. Detalle: Este Mtodo es la mezcla de todos en uno, Recorrido, Bsqueda, Pop y Push. Debido que a busca el Dato haciendo un Recorrido, y en el proceso copia todos los Datos que no son en un Arreglo Temp, para despus meterlos a la Cola original, esto lo hace hasta encontrar el dato deseado que posteriormente lo Elimina. DIAGRAMA:

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 estndar o no.

elementos de algn tipo especfico, puede incluso ser un tipo

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; }

ESTRUCTURA DE DATOS: ARBOLES BINARIOS C/C++. ARBOLES BINARIOS: Un rbol Binario es un conjunto de finito de Elementos, de nombre Nodos de forma que: El rbol Binario es Vaci si no tiene ningn elemento en el. El rbol Binario contiene un Nodo Raz y los dos que parten de l, llamados Nodo Izquierdo y Nodo Derecho. Los rboles tienen 3 Recorridos Diferentes los cuales son: Pre-Orden In-Orden Post-Orden Pre-Orden Definicin: EL RECORRIDO PRE-ORDEN lo recorre de la siguiente manera, viaje a travs del rbol Binario desplegando el Contenido en la Raz, despus viaje a travs del Nodo Izquierdo y despus a travs del Nodo Derecho. Detalle: Temp toma el Valor de la Raz y compara si el rbol tiene algn Elemento, de otra manera Desplegara rbol Vaci y terminara el mtodo. Si el rbol tiene elementos dentro de l, lo recorrer y viajara a travs de los Arreglos Izq y Der para determinar qu valor meter en la Pila y en Temp para de esta manera imprimir el siguiente Elemento correspondiente. ALGORITMO: PreOrd(Arbol, Der, Izq, Pila, Raiz) Temp Raiz Top Pila [Top] Nulo Si Raiz = Nulo Imprimir rbol Vaci y Salir Repetir mientras Temp Nulo Imprimir Arbol[Temp] Si Der [Temp] Nulo Top Top + 1 Pila [Top] Der [Temp] Si Izq [Temp] Nulo Temp Izq [Temp] DIAGRAMA:

Si no: Temp Pila [Top]; Top Top - 1 Fin del ciclo Salir

EL RECORRIDO IN-ORDEN lo recorre de la siguiente manera, viaje a travs del rbol Binario desplegando el Contenido en el Nodo Izquierdo despus la Raz y finalmente viaja a travs del Nodo Derecho. Detalle: Temp toma el Valor de la Raz y compara si el rbol tiene algn Elemento, de otra manera Desplegara rbol Vaci y terminara el mtodo. Si el rbol tiene elementos dentro de l, lo recorrer y viajara a travs de los Arreglos Izq y Der para determinar qu valor meter en la Pila y en Temp para de esta manera imprimir el siguiente Elemento correspondiente. ALGORITMO: PreOrd(Arbol, Der, Izq, Pila, Raiz) Temp Raiz Top Pila[Top] Nulo Si Raiz = Nulo Imprmir Arbol Vacio y Salir Etiqueta: Mientras Temp Nulo Top Top + 1 Pila [Top] Temp Temp Izq[Temp] Fin del ciclo Temp Pila [Top] Top Top - 1 Mientras Temp Nulo Imprimir Arbol[Temp] Si Der [Temp] Nulo Temp Der [Temp] Ir a Etiqueta Temp Pila [Top] Top Top - 1 Fin del ciclo Salir DIAGRAMA:

EL RECORRIDO IN-ORDEN lo recorre de la siguiente manera, viaje a travs del rbol Binario desplegando el Contenido en el Nodo Izquierdo despus el Nodo Derecho y finalmente viaja a travs de la Raiz. Detalle: Temp toma el Valor de la Raz y compara si el rbol tiene algn Elemento, de otra manera Desplegara rbol Vaci y terminara el mtodo. Si el rbol tiene elementos dentro de l, lo recorrer y viajara a travs de los Arreglos Izq y Der para determinar qu valor meter en la Pila y en Temp para de esta manera imprimir el siguiente Elemento correspondiente. ALGORITMO: PostOrd(Arbol, Der, Izq, Pila, Raiz) Temp Raiz Top Pila[Top] Nulo Si Raiz = Nulo Imprimir Arbol Vacio y Salir Etiqueta: Mientras Temp Nulo Top Top + 1 Pila[Top] Temp Si Der[Temp] Nulo Top Top + 1 Pila[Top] - (Der[Temp]) Temp Izq[Temp] Temp Pila[Top] Top Top - 1 Fin del ciclo Mientras Temp 0 Imprimir Arbol[Temp] Si Arbol[Temp] = Info[Raiz] Salir Temp Pila[Top] Top Top - 1 Fin del ciclo Si Temp < 0 Temp = -(Temp) Ir a Etiqueta Salir DIAGRAMA:

BSQUEDA: es similar a todas los Mtodos anteriores de Bsqueda, simplemente efecta un recorrido comparando el Elemento que deseas encontrar contra cada uno de los Elementos en los Arreglos. Detalle: El Algoritmo de Bsqueda compara el Elemento a buscar con cada uno de los datos de nuestro rbol, compara si el Elemento con el Nodo Raz, si no se encuentra en la Raz compara Elemento contra la Raz para empezar a viajar por el rbol respectivamente, usa un mtodo similar al anterior hasta encontrar el Elemento. De otra forma la bsqueda es fallida. ALGORITMO:
Busqueda(Arbol, Der, Izq, Pila, Raiz, Elem) Si Raiz = Nulo Imprimir Arbol Vacio Pos Nulo Pad Nulo Regresar Pos y Pad Salir Si Elem = Arbol[Raiz] Imprimir Elemento Encontrado Pos Raiz Pad Nulo Regresar Pos y Pad Salir Si Elem < Arbol[Raiz] Temp Izq[Raiz] Temp2 Raiz Si no: Temp Der[Raiz] Temp2 Raiz Mientras Temp Nulo Si Elem = Arbol[Temp] Imprimir Elemento Encontrado Pos Temp Pad Temp2 Regresar Pos y Pad Salir Si Elem < Arbol[Temp] Temp2 Temp Temp Izq[Temp] Si no: Temp2 Temp Temp Der[Temp] Fin del ciclo Imprimir Elemento no Encontrado Pos Nulo

Pad Temp2 Regresar Pos y Pad Salir

DIAGRAMA:

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 estn 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 tambin 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 mediantereferencias 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; } }

ESTRUCTURA DE DATOS: LISTAS. LISTAS ENLAZADAS: Recorrido simplemente despliega los datos almacenados en el arreglo Info, con ayuda de un segundo arreglo llamado Indice el cual guarda el orden en el que encuentran enlazados cada uno de los datos. Explicacin: Apuntador toma el valor de Inicio, despus ve si la condicin cumple para efectuar un Ciclo mientras Apuntador sea diferente de 0, si cumple lo que hace es que despliega la Info [Apuntador], despus Apuntador toma el valor de ndice [Apuntador] (El cual nos indica el siguiente nodo que sigue en la lista) y hace esto hasta que Apuntador sea igual a 0 (Cuando llega a este punto ha llegado al fin de la Lista Enlazada).

ALGORITMO: Recorrido (Inicio, Info, Indice) Apuntador - Inicio Repetir mientras Apuntador Nill Imprimir Info[Apuntador] Apuntador - Indice[Apuntador] Fin del ciclo Salir

DIAGRAMA:

PROGRAMA:
#include <conio.h> #include <iostream.h> void Recorrido(char Info[8][2],int Indice[8],int Inicio,int Disp); void main() { char Info[8][2]={{"G"},{"I"},{" "},{"T"},{"O"},{"A"}, {" "},{"T"}}; int Indice[8]={5,7,6,1,-999,3,-999,4}; int Inicio=0,Disp=2; cout<<"El Recorrido es:\n"; Recorrido(Info,Indice,Inicio,Disp); getch();

} void Recorrido(char Info[8][2],int Indice[8],int Inicio,int Disp) { int Apuntador=Inicio; while(Apuntador!=-999) { cout<<Info[Apuntador]; Apuntador=Indice[Apuntador]; } }

BSQUEDA: La Bsqueda su objetivo es encontrar un dato en el arreglo Info, si lo encuentra lo desplegara en la pantalla, si no lo encuentra no desplegara nada ya que el dato no se encuentra en el arreglo Info. Explicacin: Apuntador toma el valor de Inicio, despus ve si la condicin cumple para efectuar un Ciclo mientras Apuntador sea diferente de 0, si cumple lo que hace a continuacin es la comparacin de Elemento (El dato que vamos a buscar) con Info [Apuntador], cuando lo encuentre lo despliega y sale del mtodo. Si no, regresa el valor de Apuntador para as saber que no se encontr el dato. ALGORITMO: Recorrido (Inicio, Info, Indice, Elemento) Apuntador - Inicio Repetir mientras Apuntador Nill Si Elemento = Info[Apuntador] entonces: Imprimir Info[Apuntador] Regresa Apuntador Apuntador - Indice[Apuntador] Fin del ciclo Regresar Apuntador

DIAGRAMA:

PROGRAMA:
#include <conio.h> #include <iostream.h> int Busqueda(int Info[8],int Indice[8],int Inicio,int Disp,int Elemento); void main() { int Info[8]={12,10,0,9,5,3,0,20}; int Indice[8]={5,7,6,1,-999,3,-999,4}; int Inicio=0,Disp=2,Elemento,Res; cout<<"Que Numero deseas buscar?"; cin>>Elemento; Res=Busqueda(Info,Indice,Inicio,Disp,Elemento); if(Res==-999) cout<<"Dato No Encontrado..."; getch(); } int Busqueda(int Info[8],int Indice[8],int Inicio,int Disp,int Elemento) { int Apuntador=Inicio; while(Apuntador!=-999) { if(Elemento==Info[Apuntador]) { cout<<"Numero "<<Info[Apuntador]<<" encontrado..."; return Apuntador; } Apuntador=Indice[Apuntador]; } return Apuntador; }

INSERCIN AL PRINCIPIO: La Insercin al Principio bsicamente busca si existe algn lugar disponible en el arreglo Info y lo agrega como primer Nodo si es que es posible. Explicacin: Hace una comparacin para ver si es posible insertar otro Elemento al arreglo Info, para esto checa si Disp es Diferente de Nulo. Si no cumple con la condicin se desplegar Sobre Carga ya que no se puede insertar un Nuevo Elemento. Si es cierto Apuntador toma el valor de Inicio, Disp cambia a Indice [Disp] ya que el primer Disp tomara el valor del Nuevo Elemento, despus de esto solo copia la informacin de Elemento al arreglo Info en la posicin que guarda Apuntador, ndice [Apuntador] toma el valor de Inicio y finalmente Inicio toma el valor de Apuntador. ALGORITMO: InsPr(Inicio, Disp, Info, Indice, Elemento) Si Disp Nill entonces: Apuntador - Disp Disp - Indice[Disp] Info[Apuntador] - Elemento Indice[Apuntador] - Inicio Inicio - Apuntador Si no: Imprimir Sobre Carga Salir DIAGRAMA:

PROGRAMA:
#include <conio.h> #include <iostream.h> void Recorrido(int Info[8],int Indice[8],int Inicio,int Disp); void InsPr(int Info[8],int Indice[8],int Inicio,int Disp,int Elemento); void main() { int Info[8]={12,10,0,9,5,3,0,20}; int Indice[8]={5,7,6,1,-999,3,-999,4}; int Inicio=0,Disp=2,Elemento,Res; cout<<"Lista Original\n"; Recorrido(Info,Indice,Inicio,Disp); cout<<"Que Numero deseas Insertar?"; cin>>Elemento; InsPr(Info,Indice,Inicio,Disp,Elemento); getch(); } void Recorrido(int Info[8],int Indice[8],int Inicio,int Disp) { int Apuntador=Inicio; while(Apuntador!=-999) { cout<<Info[Apuntador]<<endl; Apuntador=Indice[Apuntador]; } } void InsPr(int Info[8],int Indice[8],int Inicio,int Disp,int Elemento) { if(Disp!=-999) { int Apuntador=Disp; Disp=Indice[Disp]; Info[Apuntador]=Elemento; Indice[Apuntador]=Inicio; Inicio=Apuntador; Recorrido(Info,Indice,Inicio,Disp); } else cout<<"Overflow..."; }

INSERCIN DESPUS DE UN NODO DETERMINADO: La Insercin despus de un Nodo Determinado bsicamente hace lo mismo que la insercin al principio, la nica diferencia es que este recibe la posicin del nodo en la que ser Insertada. Este Algoritmo se usa para Insercin Ordenada que ms adelante explicaremos.

Explicacin: Primero confirma que sea posible insertar el Dato, si no es posible solo desplegara Sobre Carga. Si es posible insertar un dato nuevo lo posiciona en la primer posicin Disponible en el arreglo Info, despus compara la Nueva Posicin (Npos) que le mandamos con Nill si cumple la condicin el dato es insertado en la primer posicin, de otra forma se posicionara en la posicin que guarde Npos. ALGORITMO: InsNd(Inicio, Disp, Info, Indice, Elemento, Npos) Si Disp Nill entonces: Apuntador - Disp Disp - Indice[Disp] Info [Apuntador] - Elemento Si Npos = Nill entonces: Indice[Apuntador] - Inicio Inicio - Apuntador Si no: Indice[Apuntador] - Indice[Npos] Indice[Npos] - Apuntador Si no: Imprimir Sobre Carga Salir La Insercin Ordenada busca la posicin en donde ser Insertado el Elemento y la posicin anterior donde ser Insertado, despus de encontrar la posicin en la que ser Insertado el Elemento nos regresa ese valor y lo mandamos al mtodo de la Insercin despus de un Nodo. Explicacin: En esta ocasin usaremos dos variables para determinar la posicin deseada, comparamos si Inicio es igual a Nill si Elemento es menor al dato que se encuentra en Info[Inicio], si alguna de las dos cumple regresamos Nill, de esta manera Indicamos que el Elemento ser el primero de todo el Arreglo Info, si no es as Temp tomara el valor de Inicio y Temp2 de la posicin que le sigue a Inicio. Hace un ciclo hasta encontrar la posicin en donde se insertara el Nuevo Elemento y va movindose de posicin con las variables Temp y Temp2 para as determinar qu posicin debe de regresar.

ALGORITMO: InsOrd(Inicio, Info, Indice, Elemento) Si Inicio = Nill Elemento < Info[Inicio] entonces: Regresar Nill Temp - Inicio Temp2 - Indice[Inicio] Repetir mientras Temp2 Nill Si Elemento < Info[Temp2] Regresar Temp Temp - Temp2 Temp2 - Indice[Temp2] Regresar Temp DIAGRAMA:

PROGRAMA:
#include <conio.h> #include <iostream.h> int InsOrd(int Info[8],int Indice[8],int Inicio,int Elemento); void Recorrido(int Info[8],int Indice[8],int Inicio,int Disp); void InsNd(int Info[8],int Indice[8],int Inicio,int Disp, int Elemento, int Npos); void main() { int Info[8]={12,10,0,9,5,3,0,20}; int Indice[8]={5,7,6,1,-999,3,-999,4}; int Inicio=0,Disp=2,Elemento,Res; cout<<"Lista Original\n"; Recorrido(Info,Indice,Inicio,Disp); cout<<"Que Numero deseas Insertar?"; cin>>Elemento; Res=InsOrd(Info,Indice,Inicio,Elemento); InsNd(Info,Indice,Inicio,Disp,Elemento,Res);

getch(); } void Recorrido(int Info[8],int Indice[8],int Inicio,int Disp) { int Apuntador=Inicio; while(Apuntador!=-999) { cout<<Info[Apuntador]<<endl; Apuntador=Indice[Apuntador]; } } void InsNd(int Info[8],int Indice[8],int Inicio,int Disp, int Elemento, int Npos) { if(Disp!=-999) { int Apuntador=Disp; Disp=Indice[Disp]; Info[Apuntador]=Elemento; if(Npos==-999) { Indice[Apuntador]=Inicio; Inicio=Apuntador; } else { Indice[Apuntador]=Indice[Npos]; Indice[Npos]=Apuntador; } Recorrido(Info,Indice,Inicio,Disp); } else cout<<"Overflow..."; } int InsOrd(int Info[8],int Indice[8],int Inicio,int Elemento) { int Temp=-999,Temp2; if(Inicio==Temp||Elemento<Info[Inicio]) return Temp; Temp=Inicio; Temp2=Indice[Inicio]; while(Temp2!=-999) { if(Elemento<Info[Temp2]) return Temp; Temp=Temp2; Temp2=Indice[Temp2]; } return Temp; }

ELIMINACIN POR BSQUEDA La Eliminacin simplemente cambia los nodos para que el dato que se desea eliminar sea el primer disponible, de esta forma ya no estar en el Arreglo de Info. Explicacin: Lo primero que hace es ver si existe algn dato en la lista para eliminar, si Inicio es igual a Nill entonces solo desplegara Imposible Eliminar. De otra formas cambiar de Posicin en Posicin hasta encontrar el Elemento que sea desea Eliminar con ayudar de dos variables que guardan la Posicin actual y la anterior en donde se encuentre el dato. Ya que lo encuentra cambia ese dato como la primera posicin Disponible y lo apunta al siguiente nodo disponible. Si no encuentra el dato simplemente desplegara Dato no encontrado ALGORITMO: EliBusq(Inicio, Info, Indice, Elemento) Temp - Inicio Si Temp = Nill Imprimir Lista Vacia Imposible Eliminar y Retornar Repetir mientras Temp Nill Si Elemento = Info[Temp] entonces: Si Temp = Inicio entonces: Inicio - Indice[Inicio] Si no: Indice[Temp2] - Indice[Temp] Indice[Temp] Disp Disp - Temp Recorrido(Inicio, Info, Indice) y Retornar Si no: Temp2 - Temp Temp - Indice[Temp] Imprimir Dato no encontrado Imposible Eliminar y Retornar

DIAGRAMA:

PROGRAMA:
#include <conio.h> #include <iostream.h> void Recorrido(int Info[8],int Indice[8],int Inicio,int Disp); void EliBusq(int Info[8],int Indice[8],int Inicio,int Disp,int Elemento); void main() { int Info[8]={12,10,0,9,5,3,0,20}; int Indice[8]={5,7,6,1,-999,3,-999,4}; int Inicio=0,Disp=2,Elemento,Res; cout<<"Lista Original\n"; Recorrido(Info,Indice,Inicio,Disp); cout<<"Que Numero deseas Eliminar?"; cin>>Elemento; EliBusq(Info,Indice,Inicio,Disp,Elemento); getch(); } void Recorrido(int Info[8],int Indice[8],int Inicio,int Disp) { int Apuntador=Inicio; while(Apuntador!=-999) { cout<<Info[Apuntador]<<endl; Apuntador=Indice[Apuntador]; } } void EliBusq(int Info[8],int Indice[8],int Inicio,int Disp,int Elemento) { int Temp=Inicio,Temp2; if(Temp==-999) { cout<<"Lista Vacia... Imposible Eliminar"; return; }

while(Temp!=-999) { if(Elemento==Info[Temp]) { if(Temp==Inicio) Inicio=Indice[Inicio]; else Indice[Temp2]=Indice[Temp]; Indice[Temp]=Disp; Disp=Temp; Recorrido(Info,Indice,Inicio,Disp); return; } else { Temp2=Temp; Temp=Indice[Temp]; } } cout<<"Dato no encontrado... Imposible Eliminar"; return; }

CONCLUSIN.

Se puede definir como Estructura de Datos, a las aplicaciones ms interesantes y potentes de la memoria dinmica y de los punteros, sin duda, las estructuras de datos bsicas disponibles se representan en C y C++ (struct y arrays) que posee una importante limitacin: no pueden cambiar de tamao durante la ejecucin. Los arrays estn compuestos por un determinado nmero de elementos, nmero que se decide en la fase de diseo, antes de que el programa ejecutable sea creado.

Una pila es una lista ordinal en la que el modo de acceso a sus elementos es del tipo LIFO. Los aadidos y extracciones de elementos de una estructura se realizan solo por un extremo, luego el nico elemento accesible de la pila es el que se encuentre en la cima. Esto exigir que la manipulacin sobre un elemento, necesite que el mismo ocupe la posicin de cima. En estas surgen de forma natural las operaciones que permiten aadir elementos y quitar elementos.

En cuanto a los arboles binarios: son rboles donde cada nodo slo puede apuntar a dos nodos. Arboles binarios de bsqueda (ABB): son rboles binarios ordenados. Desde cada nodo todos los nodos de una rama sern mayores, segn la norma que se haya seguido para ordenar el rbol, y los de la otra rama sern menores. Y las listas son las que nos permite almacenar datos de una forma organizada, al igual que los vectores pero, a diferencia de estos, esta estructura es dinmica, por lo que no tenemos que saber "a priori" los elementos que puede contener.

BIBLIOGRAFA.

http://www.programacionfacil.com/estructura_de_datos:arbol_binario http://es.scribd.com/doc/19189608/17/La-estructura-de-datos-Pila-en-C-C++ http://www.calcifer.org/documentos/librognome/glib-lists-queues.html http://www.monografias.com/trabajos10/esda/esda.shtm http://www.monografias.com/trabajos14/estrucdinamicas/estrucdinamicas.shtml#ixzz2Ighs 7zYM http://www.monografias.com/trabajos24/estructura-datos/estructura datos.shtml#ixzz2IgkyKmax