Instituto Tecnolgico de Tuxtepec

MATERIA: Estructura de Datos

PRESENTA: Daniela Gpe. Balbuena Saldivar CATEDRATICO: L.I. Tomas Torres Ramrez

TUXTEPEC, OAX. .15 de Diciembre del 2011

INSTITUTO TECNOLOGICO de Tuxtepec

Estructura de Datos

Unidad 1
Introduccin a las Estructuras de Datos

Prof.: Tomas Torres Ramrez Alumna: Daniela Guadalupe Balbuena Saldivar Ingeniera en Informtica Tercer Semestre Grupo A

ndice
Introduccin Tipo de Dato Abstracto (TDA) Modularidad Uso de TDA Mapa conceptual de TDAs Ejemplo de TDA en Java Memoria esttica y dinmica 3 4 6 7 8 9 10

Introduccin
La principal razn para que las personas aprendan lenguajes y tcnicas de programacin es utilizar la computadora como una herramienta para resolver problemas. La abstraccin de datos es la tcnica de inventar nuevos tipos de datos que sean ms adecuados y por consiguiente, facilitar la estructura del programa. La tcnica de abstraccin de datos es una tcnica potente de propsito general que cuando se utiliza adecuadamente, puede producir programas cortos, mas legibles y flexibles. Los lenguajes de programacin soportan tipos de datos fundamentales o bsicos (predefinidos), tales como int, char y float en C++ y Java. Un tipo de dato definido por el programador se denomina tipo abstracto de dato TAD (Abstract Data Type, ADT). El trmino abstracto se refiere al medio en que un programador abstrae algunos conceptos de programacin, creando un nuevo tipo de dato. La popularizacin de un programa utiliza la nocin tipo abstracto de dato (TAD), siempre que sea posible si el lenguaje de programacin soporta los tipos que desea el usuario y el conjunto de operaciones sobre cada tipo, se obtiene un nuevo tipo de dato denominado TAD.

Tipo de Dato Abstracto (TDA)

Un tipo de dato abstracto es un modelo matemtico compuesto por una coleccin de operaciones definidas sobre un conjunto de datos para el modelo. El concepto de tipo de dato abstracto (TDA, Abstract Data Type), fue propuesto por primera vez hacia 1974 por John Guttag y otros, pero no fue hasta 1975 que por primera vez Liskov lo propuso para el lenguaje CLU. El lenguaje Turbo Pascal fue determinante para la comn aceptacin de los TDAs con la introduccin de las Units, si bien estas no cumplen con las caractersticas bsicas de un Tipo de dato Abstracto como por ejemplo la encapsulacin de los datos. El lenguaje Ada pudo implementar exitosamente los TDAs con sus Packages. Con mucha frecuencia se utilizan los trminos TDA y Abstraccin de Datos de manera equivalente, y esto es debido a la similitud e interdependencia de ambos. Sin embargo, es importante definir por separado los dos conceptos. Como ya se mencion, los Lenguajes de Programacin Orientados a Objetos son lenguajes formados por diferentes mtodos o funciones y que son llamados en el orden en que el programa lo requiere, o el usuario lo desea. La abstraccin de datos consiste en ocultar las caractersticas de un objeto y obviarlas, de manera que solamente utilizamos el nombre del objeto en nuestro programa. Al hecho de guardar todas las caractersticas y habilidades de un objeto por separado se le llama Encapsulamiento y es tambin un concepto importante para entender la estructuracin de datos. Es frecuente que el Encapsulamiento sea usado como un sinnimo del Ocultacin de informacin.

Caracterizacin
Un TDA est caracterizado por un conjunto de operaciones (funciones) al cual se denomina usualmente como interfaz pblica y representa el comportamiento del TDA; mientras que la implementacin como la parte privada del TDA est oculta al programa cliente que lo usa. Los TDA que nos van a interesar de ahora en adelante son aquellos que reflejen cierto comportamiento organizando cierta variedad de datos estructuradamente. A esta forma estructurada de almacenar los datos ser a la que nos refiramos para caracterizar cada TDA. Los TDA que tienen informaciones simples pero dependientes de un comportamiento estructural sern llamados polilticos y aquellos TDA simples, como son los tipos predefinidos donde la informacin no es relacionada mediante ninguna estructura y no admiten ms que un valor en cada momento sern denominados TDA monolticos. Un TDA tendr una parte que ser invisible al usuario la cual hay que proteger y que se puede decir que es irrelevante para el uso del usuario y est constituida tanto por la maquinaria algortmica que implemente la semntica de las operaciones como por los datos que sirvan de enlace entre los elementos del TDA, es decir, informacin interna necesaria para la implementacin que se est haciendo para ese comportamiento del TDA. Resumiendo podemos decir, que tanto la implementacin de las operaciones como los elementos internos del TDA sern privados al acceso externo y ocultos a cualquier otro nivel. Un TDA representa una abstraccin:

Se destacan los detalles (normalmente pocos) de la especificacin (el qu). Se ocultan los detalles implementacin (el cmo). (casi siempre numerosos) de la

Modularidad
Se denomina Modularidad a la propiedad que permite subdividir una aplicacin en partes ms pequeas (llamadas mdulos), cada una de las cuales debe ser tan independiente como sea posible de la aplicacin en s y de las restantes partes. Estos mdulos que se puedan compilar por separado, pero que tienen conexiones con otros mdulos. Al igual que la encapsulacin, los lenguajes soportan la Modularidad de diversas formas. Segn Bertrand Meyer "El acto de particionar un programa en componentes individuales para reducir su complejidad en algn grado. . . . A pesar de particionar un programa es til por esta razn, una justificacin ms poderosa para particionar un programa es que crea una serie de lmites bien definidos y documentados en el programa. Estos lmites, o interfaces, son muy valiosos en la comprensin del programa". Por su parte Barbara Liskov establece que "modularizacin consiste en dividir un programa en mdulos que pueden ser compilados de forma separada, pero que tienen conexiones con otros mdulos". Ventajas de la Modularizacin Un programa modular es fcil de mantener y modificar. Un programa modular es ms fcil de escribir y depurar (ejecutar, probar y poner a punto). Un programa modular es ms fcil de controlar. El desglose de un problema en mdulos permite encomendar los mdulos ms complejos a los programadores ms experimentados y los ms sencillos a los programadores nveles. Posibilita el uso repetitivo de las rutinas en el mismo o en diferentes programas. Desventajas de la Modularizacin

No se dispone de algoritmos formales de modularidad, por lo que a veces los programadores no tienen claras las ideas de los mdulos. La programacin modular requiere ms memoria y tiempo de ejecucin.

Uso de los TDA

Algunos ejemplos de utilizacin de TDAs en programacin son:

Conjuntos: Implementacin de conjuntos con sus operaciones bsicas (unin, interseccin y diferencia), operaciones de insercin, borrado, bsqueda... rboles Binarios de Bsqueda: Implementacin de rboles de elementos, utilizados para la representacin interna de datos complejos. Aunque siempre se los toma como un TDA separado son parte de la familia de los grafos. Pilas y Colas: Implementacin de los algoritmos FIFO y LIFO. Grafos: Implementacin de grafos; una serie de vrtices unidos mediante una serie de arcos o aristas.

Mapa conceptual de TDAs

Ejemplo de TDA en Java

public class TDA { public static int valor; TDA () {valor = 0;}; public static void Mdato (){ Valor = Integer.parseInt (JOptionPane.showInputDialog(Valor));} public static int Sdato () { return valor; } }

Memoria esttica y dinmica

Memoria esttica:
Es la asignacin de memoria para algunos elementos fijos del programa que es controlada por el compilador. Define la cantidad de memoria necesaria para un programa durante el tiempo de compilacin. El tamao no puede cambiar durante el tiempo de ejecucin del programa. Algunos lenguajes de programacin utilizan la palabra static para especificar elementos del programa que deben almacenarse en memoria esttica. Elementos que residen en memoria esttica: o Cdigo del programa. o Las variables definidas en la seccin principal del programa, las cuales pueden solo cambiar su contenido no su tamao. o Todas aquellas variables declaradas como estticas en otras clases o mdulos.

Memoria dinmica:
Es la asignacin y posible recuperacin de memoria durante la ejecucin de un programa y bajo su control. Define el tamao del espacio de memoria necesario para un programa en tiempo de ejecucin.

10

 El tamao de los elementos puede cambiar durante la ejecucin del programa. Almacena todos los elementos definidos con la palabra new en un programa. Sus variables crecen de tamao o se reducen durante la ejecucin del programa. Estas se almacenan en un espacio de memoria llamado heap; el cual se localiza en la regin de memoria que esta encima del stack. Algunos lenguajes de programacin permiten que el programador asigne y desasigne manualmente la memoria Pero JAVA utiliza un recolector de basura.

11

INSTITUTO TECNOLOGICO de Tuxtepec

Estructura de Datos

Unidad 2
Recursividad

Prof.: Tomas Torres Ramrez Alumna: Daniela Guadalupe Balbuena Saldivar Ingeniera en Informtica Tercer Semestre Grupo A

12

ndice
Investigacin sobre recursividad Ejemplos de casos recursivos 14 20

13

Recursividad La recursividad consiste en realizar una definicin de un concepto en trminos del propio concepto que se est definiendo. Ejemplo: La ensima potencia de un nmero x, es 1 si n es igual a 0, o el producto de x por la potencia (n-1)-ensima de x, cuando n es mayor que 0. En este ejemplo se utiliza el concepto definido en la propia definicin. 2.2.- Diseo de mdulos recursivos. Mdulo M con una llamada a s mismo: mdulo recursivo directo. Mdulo M con una llamada a otro F, que hace una llamada a M: Mdulo recursivo indirecto. Ejemplo: Implementacin del factorial de un nmero. public long factorial (long n) { if (n == 0) return 1; else return n * factorial(n-1); } Dos partes principales: 8. La llamada recursiva, que expresa el problema original en trminos de otro ms pequeo, y 9. El valor para el cual se conoce una solucin no recursiva. Esto es lo que se conoce como caso base: una instancia del problema cuya solucin no requiere de llamadas recursivas. El caso base

14

10. Acta como condicin de finalizacin de la funcin recursiva. Sin el caso base la rutina recursiva se llamara indefinidamente y no finalizara nunca. 11. Es el cimiento sobre el cual se construir la solucin completa al problema.

La recursividad forma parte del repertorio para resolver problemas en Computacin y es de los mtodos ms poderosos y usados. Los algoritmos recursivos ofrecen soluciones estructuradas, modulares y elegantemente simples. La recursividad es un concepto fundamental en matemticas y en computacin. Una definicin recursiva dice cmo obtener conceptos nuevos empleando el mismo concepto que intenta describir. En toda situacin en la cual la respuesta pueda ser expresada como una secuencia de movimientos, pasos o transformaciones gobernadas por un conjunto de reglas no ambiguas, la frmula recursiva es un buen candidato para resolver el problema. Los razonamientos recursivos se encuentran en la base misma de las matemticas porque son necesarios para describir conceptos centrales como el de nmero: Ejemplo: 1. Factorial Definicin: factorial (n) = n! si n > 0 factorial (n) = n*n-1*n-2* ... * 1 si n > 0 el valor de 0! se define como factorial (0) = 1

15

Su definicin recursiva es: factorial (n) = 1 si n = 0 factorial (n) = n* factorial (n-1) si n > 0 as para calcular el factorial de 4: factorial (4) = 4 * factorial (3) = 4 * 6 = 24 factorial (3) = 3 * factorial (2) = 3 *2 = 6 factorial (2) = 2 * factorial (1) = 2 * 1 = 2 factorial (1) = 1 * factorial (0) = 1 * 1 = 1 esttica int factorial (int n) comienza si n = 0 entonces regresa 1 otro regresa factorial (n-1) * n termina Versin iterativa: esttica int factorial (int n) comienza fact 1 para i 1 hasta n fact i * fact regresa fact termina

16

Las definiciones recursivas de funciones en matemticas que tienen como argumentos nmeros enteros, se llaman relaciones de recurrencia. Forma de una ecuacin de recurrencia: coar +c1ar-1 + c2ar-2 + ....+ ckar-k = f(r) funcin matemtica discreta donde ci son constantes, es llamada una ecuacin de recurrencia de coeficientes constantes de orden k, condicionada a que c0 y ck = 0. Una definicin recursiva dice cmo obtener conceptos nuevos empleando el mismo concepto que intenta definir. El poder de la recursividad es que los procedimientos o conceptos complejos pueden expresarse de una forma simple. Un razonamiento recursivo tiene dos partes: la base y la regla recursiva de construccin. La base no es recursiva y es el punto tanto de partida como de terminacin de la definicin. Ejemplo: Base: La secuenciacin, iteracin condicional y seleccin son estructuras vlidas de control que pueden ser consideradas como enunciados. Regla recursiva: Las estructuras de control que se pueden formar combinando de manera vlida la secuenciacin iteracin condicional y seleccin tambin son vlidos. Un conjunto de objetos est definido recursivamente siempre que: (B) algunos elementos del conjunto se especifican explcitamente (R) el resto de los elementos del conjunto se definen en trminos de los elementos ya definidos donde (B) se llama base (R) se llama clusula recursiva

17

Observaciones: 1. El procedimiento se llama a si mismo 2. El problema se resuelve, resolviendo el mismo problema pero de tamao menor 3. La manera en la cual el tamao del problema disminuye asegura que el caso base eventualmente se alcanzar La recursividad es un mtodo poderoso usado en inteligencia artificial, su poder es que algunos conceptos complejos pueden expresarse en una forma simple. Una definicin recursiva difiere de una definicin circular en que tiene una forma de escapar de su expansin infinita. Este escape se encuentra en la definicin o porcin no recursiva o terminal de la definicin. Las frmulas recursivas pueden aplicarse a situaciones tales como prueba de teoremas, solucin de problemas combinatorios, algunos acertijos, etc. Ejemplo: 1. Nmeros de Fibonacci Los nmeros de Fibonacci se definen como: FN = FN-1 + FN-2 para N > 2 F0 = F1 = 1 que definen la secuencia: 1,1,2,3,5,8,13,21,34,55,89,144, ..... Por ejemplo, si quisiramos encontrar Fibonacci de 5, entonces: Fibonacci (5) = Fibonacci (4) + Fibonacci (3) Fibonacci (4) = Fibonacci (3) + Fibonacci (2) Fibonacci (3) = Fibonacci (2) + Fibonacci (1)

18

Fibonacci (2) = Fibonacci (1) + Fibonacci (0) De manera iterativa el algoritmo podra ser: esttica int Fibonacci (int n) // versin iterativa 3 comienza fibo [0] 1 fibo [1] 1 para i 1 hasta n fibo [i] fibo [i-1]+ fibo [i-2] regresa fibo [n] termina Resolviendo el mismo problema pero de manera recursiva, obtenemos: esttica int Fibonacci (int n) //versin recursiva comienza si n < 1 entonces regresa 1 otro regresa Fibonacci (n-1) + Fibonacci (n-2) termina Definicin: Cuando una llamada recursiva es la ltima posicin ejecutada del procedimiento se llama recursividad de cola, recursividad de extremo final o recursin de extremo de cola.

19

Definicin: Cuando un procedimiento incluye una llamada a si mismo se conoce como recursin directa. Definicin: Cuando un procedimiento llama a otro procedimiento y este causa que el procedimiento original sea invocado, se conoce como recursin indirecta. Al principio algunas personas se sienten un poco incmodas con la recursividad, tal vez porque da la impresin de ser un ciclo infinito, pero en realidad es menos peligrosa una recursin infinita que un ciclo infinito, ya que una recursividad infinita pronto se queda sin espacio y termina el programa, mientras que la iteracin infinita puede continuar mientras no se termine en forma manual. Cuando un procedimiento recursivo se llama recursivamente a si mismo varias veces, para cada llamada se crean copias independientes de las variables declaradas en el procedimiento. Ejemplos de casos recursivos El factorial de un numero natural es 1 si dicho numero es 0, o n multiplicado por el factorial del numero n-1, en caso contrario n= 4 24=4! 4*3!= 4 3*2!=3 2*1!=2 1*0!=1 1=0 Modelo recursivo directo: se llama asi mismo (m) (m) Modelo recursivo indirecto: llama a otros dentro del mismo programa. Otros ejemplos de recursividad:

20

Potencias de nmeros Divisin de restas sucesivas Factorial de nmeros Secuencia de Fibonacci

21

INSTITUTO TECNOLOGICO de Tuxtepec

Estructura de Datos

Unidad 3
Estructuras Lineales

Prof.: Tomas Torres Ramrez Alumna: Daniela Guadalupe Balbuena Saldivar Ingeniera en Informtica Tercer Semestre Grupo A

22

ndice
Investigacin sobre Pilas Cdigo fuente programa Pilados Cdigo fuente programa Pila modificado Cdigo fuente programa operaciones con pilas Investigacin sobre Listas Cdigo fuente programa Lista Cdigo fuente programa Colas 24 27 30 33 38 42 47

23

Investigacin sobre Pilas

Una pila (stack en ingls) es una estructura de datos de tipo LIFO (del ingls Last In First Out, ltimo en entrar, primero en salir) que permite almacenar y recuperar datos. Para el manejo de los datos se cuenta con dos operaciones bsicas: Apilar (push), que coloca un objeto en la pila, y su operacin inversa, Retirar (o desapilar, pop), que retira el ltimo elemento apilado.

En cada momento slo se tiene acceso a la parte superior de la pila, es decir, al ltimo objeto apilado (denominado TOS, top of stack en ingls). La operacin retirar permite la obtencin de este elemento, que es retirado de la pila permitiendo el acceso al siguiente (apilado con anterioridad), que pasa a ser el nuevo TOS. TDA Pilas Las pilas son una subclase de las listas lineales, en las que las operaciones sobre ellas se llevan a cabo por uno de los extremos, por lo que obedecen a una orden LIFO (Last Input First Output) (Ultimo en Entrar, Primero en Salir). Las operaciones bsicas de las pilas son Meter (Push) y sacas (Pop), adems del recorrido. La operacin Push inserta elementos en la pila y Pop elimina elementos de la pila. Las operaciones de insercin y eliminacin se hacen por el extremo final de la pila. Para controlar los elementos en la pila se uso de una variable auxiliar llamada Tope, el cual indica el ltimo elemento insertado en la pila, que es el mismo que debe eliminarse.

Operaciones con pilas

Las operaciones elementales que pueden realizarse en una pila son: Poner un elemento (Push)

24

Quitar un elemento (Pop)

Considerando que se tiene una pila que puede almacenar un mximo nmero de elementos y que el ltimo de ellos est indicando por TOPE, los algoritmos son los siguientes: Pone (Push) Pone (Pila, Max, Tope, Dato) (Este algoritmo pone el elemento Dato en Pila. Actualiza el valor de Tope. Max es el mximo nmero de elementos que puede almacenar Pila). 1. Si Tope < Max {Verifica que haya espacio libre} entonces Hacer Tope Tope + 1 {actualiza Tope} y Pila [Tope] Dato {pone el nuevo elemento en el Tope de Pila} Si no Escribir Desbordamiento 2. {Fin del condicional del paso 1} Quita (Pop) Quita (Pila, Top, Dato) {Este algoritmo saca el ltimo elemento de Pila y lo guarda en Dato. Actualiza el valor de tope} 1. Si Tope > 0 {verifica que la pila no este vaca} Entonces Hacer Dato Pila [Tope] y Tope Tope-1 {actualiza Tope} Si no

25

Escribir Subdesbordamiento 2. {fin del condicional del paso 1} Algoritmo para insertar en Pila Push (Dato) Si Pila llena Pila llena De otro modo Tope ++ Pila [Tope] Dato Fin Si Algoritmo para quitar en Pila Si Pila Vacia Pila Vacia De otro modo Dato Pila [Tope] Tope Fin Si

26

Cdigo fuente programa Pilados

public class pilados{ class Nodo{ int info; Nodo sig; } private Nodo raiz; public pilados(){ raiz=null; } public void insertar(int x){ Nodo nuevo; nuevo= new Nodo(); nuevo.info=x; if (raiz==null) { nuevo.sig=null; raiz=nuevo; } System.out.println("\n"+x); } public int extraer(){

if(raiz!=null){ int informacion=raiz.info; raiz=raiz.sig; return informacion;

27

} else{ return Integer.MAX_VALUE;} // } public void imprimir(){ Nodo reco=raiz; System.out.println("listado de todos los elementos de la pila."); while (reco!=null){ System.out.print(reco.info+"."); } System.out.println(); } public static void main(String[]ar){ pilados pila1=new pilados(); int op=4,dato; do{ String menu="\n\n Menu de opciones \n\n 1)Insertar \n\n 2)Eliminar \n\n 3)Listar \n\n 4)Salir \n\n Elige una opcion:"; op=Integer.parseInt(JOptionPane.showInputDialog(menu)); switch(op){ case 1:dato=Integer.parseInt(JOptionPane.showInputDialog("Dato a insertar:")); pila1.insertar(dato); break; case 2:dato=pila1.extraer(); JOptionPane.showMessageDialog(null,"El dato eliminado es:"+dato); break; case 3:pila1.imprimir(); break; System.out.println(raiz);

28

case 4: JOptionPane.showMessageDialog(null,"Fin del programa"); } } while(op!=4); } }

29

Cdigo fuente programa Pila modificado

import javax.swing.*; public class Pila2{ class Nodo{ int info; Nodo sig; } private Nodo raiz; public Pila2(){ raiz=null; } public void insertar(int x){ Nodo nuevo; nuevo= new Nodo(); nuevo.info=x; if (raiz==null) { nuevo.sig=null; raiz=nuevo; } System.out.println("\n"+x); } public int extraer(){

if(raiz!=null){ int informacion=raiz.info; raiz=raiz.sig; return informacion;

30

else{ return Integer.MAX_VALUE;} // } public void imprimir(){ Nodo reco=raiz; System.out.println("listado de todos los elementos de la pila."); while (reco!=null){ System.out.print(reco.info+"."); } System.out.println(); } public static void main(String[]ar){ Pila2 pila1=new Pila2(); int op=4,dato; do{ String menu="\n\n Menu de opciones \n\n 1)Insertar \n\n 2)Eliminar \n\n 3)Listar \n\n 4)Salir \n\n Elige una opcion:"; op=Integer.parseInt(JOptionPane.showInputDialog(menu)); switch(op){ case 1:dato=Integer.parseInt(JOptionPane.showInputDialog("Dato a insertar:")); pila1.insertar(dato); break; case 2:dato=pila1.extraer(); JOptionPane.showMessageDialog(null,"El dato eliminado es:"+dato); break; case 3:pila1.imprimir(); break; case 4: JOptionPane.showMessageDialog(null,"Fin del programa"); } System.out.println(raiz);

31

} while(op!=4); } }

32

Cdigo fuente programa operaciones con pilas

import javax.swing.*; import java.awt.*; import java.awt.event.*; public class operacionespila { public static void main(String args[]) { menupila obj=new menupila(); int maxpila=Integer.parseInt(JOptionPane.showInputDialog("Ingresa la cantidad de numeros que se almacenara en la pila")); int vector[]=new int[maxpila]; int ultele=0, e=0, a=0, cn; String txt=""; String txt1=""; while(a==0) { int opc=obj.opciones(); if (opc>=1 && opc<6) { switch (opc) { case 1://insertar { cn=0; if(ultele==maxpila) JOptionPane.showMessageDialog(null, "overflow: no puedes insertar mas elementos"); for (e=ultele;e<maxpila;e++) { vector[e]=Integer.parseInt(JOptionPane.showInputDialog("Ingresa el nmero del vector"));

33

int result = JOptionPane.showConfirmDialog((Component)null,"Desea Continuar Llenando? ","SN",JOptionPane.YES_NO_OPTION); if(result == JOptionPane.NO_OPTION) { JOptionPane.showMessageDialog(null,"Se suspende la captura antes de llenar vector, se lleno hasta:"+ultele); txt+=" \nvalor del elemento del vector["+e+"]= "+vector[e]; ultele++; break; } ultele++; if(result==JOptionPane.YES_OPTION) { txt+=" \nvalor del elemento del vector["+e+"]= "+vector[e]; } //ultele++;//incremento de posiciones en el vector } JOptionPane.showMessageDialog(null,txt); // e=ultele;// asignamos el valor del elemento break; } case 2://recorrido { if (ultele<=0) { JOptionPane.showMessageDialog(null, " underflow: pila vacia "); } else { int ap=0; while(ap<ultele) { txt1+="\nvalor del elemento del vector["+ap+"]= "+vector[ap];

34

ap++; } JOptionPane.showMessageDialog(null, txt1); txt1=" "; } break; } case 3://busqueda { int ban=0; if(ultele<=0) { JOptionPane.showMessageDialog(null, "underflow: pila vacia "); } else { int ap1=0,d=0; int num=Integer.parseInt(JOptionPane.showInputDialog("ingresa el numero que desee buscar en la pila")); if(ultele==maxpila) { d=ultele-1; } else { d=ultele; } while (ap1<d) { if(vector[ap1]==num) {

35

JOptionPane.showMessageDialog(null, "El dato fue encontrado"); JOptionPane.showMessageDialog(null,"Valor del elemento del vector ["+ap1+"]= "+vector[ap1]); ban=1; break; } ap1++; } if(ban==0) { JOptionPane.showMessageDialog(null, "el dato que ingresaste, no fue encontrado en la pila " + num); } } break; } case 4://eliminacion { if(ultele<=0) { JOptionPane.showMessageDialog(null, "underflow: pila vacia "); } else { ultele--; JOptionPane.showMessageDialog(null,"El elemento se elimino"); } txt=" "; for (e=0;e<ultele;e++) {

36

txt+=" \nvalor del elemento del vector["+e+"]= "+vector[e]; } break; } default: { JOptionPane.showMessageDialog(null,"Muchas Gracias, Termina el programa"); a=1; } } } else { JOptionPane.showMessageDialog(null,"Lo siento se oprimi un nmero diferente de 1, 2 ,3, 4,5"); } } } }

37

Investigacin sobre listas

Las listas enlazadas fueron desarrolladas en 1955-56 por Cliff Shaw y Herbert Simon en RAND Corporation como la principal estructura de datos para su Lenguaje de Procesamiento de la Informacin (IPL). IPL fue usado por los autores para desarrollar varios programas relacionados con la inteligencia artificial, incluida la Mquina de la Teora General, el Solucionador de Problemas Generales, y un programa informtico de ajedrez. Se public en IRE Transactions on Information Theory en 1956, y en distintas conferencias entre 1957-1959, incluida Proceedings of the Western Joint Computer en 1957 y 1958, y en Information Processing (Procendents de la primera conferencia internacional del procesamiento de la informacin de la Unesco) en 1959. El diagrama clsico actual, que consiste en bloques que representan nodos de la lista con flechas apuntando a los sucesivos nodos de la lista, apareci en Programming the Logic Theory Machine, de Newell y Shaw. Newell y Simon fueron reconocidos por el ACM Turing Award en 1975 por hacer contribuciones bsicas a la inteligencia artificial, a la psicologa del conocimiento humano y al procesamiento de las listas.

38

Operaciones Bsicas con Listas

Con las listas tendremos un pequeo repertorio de operaciones bsicas que se pueden realizar:

Aadir o insertar elementos. Buscar o localizar elementos. Borrar elementos. Moverse a travs de una lista, anterior, siguiente, primero.

Cada una de estas operaciones tendr varios casos especiales, por ejemplo, no ser lo mismo insertar un nodo en una lista vaca, o al principio de una lista no vaca, o la final, o en una posicin intermedia.

Tipos de Listas
Una lista enlazada es una de las estructuras de datos fundamentales, y puede ser usada para implementar otras estructuras de datos. Consiste en una secuencia de nodos, en los que se guardan campos de datos arbitrarios y una o dos referencias (punteros) al nodo anterior o posterior. El principal beneficio de las listas enlazadas respecto a los array convencionales es que el orden de los elementos enlazados puede ser diferente al orden de almacenamiento en la memoria o el disco, permitiendo que el orden de recorrido de la lista sea diferente al de almacenamiento. Una lista enlazada es un tipo de dato auto-referenciado porque contienen un puntero o link a otro dato del mismo tipo. Las listas enlazadas permiten inserciones y eliminacin de nodos en cualquier punto de la lista en tiempo constante (suponiendo que dicho punto est previamente identificado o localizado), pero no permiten un acceso aleatorio. Existen diferentes tipos de listas enlazadas: Lista Enlazadas Simples, Listas Doblemente Enlazadas, Listas Enlazadas Circulares y Listas Enlazadas Doblemente Circulares. A continuacin hablaremos de algunas de ellas.

39

Listas Simplemente Enlazadas

La lista enlazada bsica es la lista enlazada simple la cual tiene un enlace por nodo. Este enlace apunta al siguiente nodo en la lista, o al valor NULL o a la lista vaca, si es el ltimo nodo.

Una lista enlazada simple contiene dos valores: el valor actual del nodo y un enlace al siguiente nodo

Listas Doblemente Enlazadas

Un tipo de lista enlazada ms sofisticado es la lista doblemente enlazada o lista enlazadas de dos vas. Cada nodo tiene dos enlaces: uno apunta al nodo anterior, o apunta al valor NULL si es el primer nodo; y otro que apunta al nodo siguiente, o apunta al valor NULL si es el ltimo nodo.

Una lista doblemente enlazada contiene tres valores: el valor, el link al nodo siguiente, y el link al anterior

En algn lenguaje de muy bajo nivel, XOR-Linking ofrece una va para implementar listas doblemente enlazadas, usando una sola palabra para ambos enlaces, aunque el uso de esta tcnica no se suele utilizar.

40

Listas Circulares
En una lista enlazada circular, el primer y el ltimo nodo estn unidos juntos. Esto se puede hacer tanto para listas enlazadas simples como para las doblemente enlazadas. Para recorrer una lista enlazada circular podemos empezar por cualquier nodo y seguir la lista en cualquier direccin hasta que se regrese hasta el nodo original. Desde otro punto de vista, las listas enlazadas circulares pueden ser vistas como listas sin comienzo ni fin. Este tipo de listas es el ms usado para dirigir buffers para ingerir datos, y para visitar todos los nodos de una lista a partir de uno dado.

Una lista enlazada circular que contiene tres valores enteros

Aplicaciones de las listas

Las listas enlazadas son usadas como mdulos para otras muchas estructuras de datos, tales como pilas, colas y sus variaciones. El campo de datos de un nodo puede ser otra lista enlazada. Mediante este mecanismo, podemos construir muchas estructuras de datos enlazadas con listas; esta prctica tiene su origen en el lenguaje de programacin Lisp, donde las listas enlazadas son una estructura de datos primaria (aunque no la nica), y ahora es una caracterstica comn en el estilo de programacin funcional. A veces, las listas enlazadas son usadas para implementar arrays asociativos, y estas en el contexto de las llamadas listas asociativas. Hay pocas ventajas en este uso de las listas enlazadas; hay mejores formas de implementar stas estructuras, por ejemplo con rboles binarios de bsqueda equilibrados. Sin embargo, a veces una lista enlazada es dinmicamente creada fuera de un subconjunto propio de nodos semejante a un rbol, y son usadas ms eficientemente para recorrer sta serie de datos.

41

Cdigo fuente programa Lista

Las limport javax.swing.*; public class Lista { private Nodo primero; private Nodo ultimo; private int tamano; public Lista() { this.primero = null; this.ultimo = null; this.tamano = 0; } //lista vacia. public boolean siVacio() { return (this.primero == null); }

//Metodo para agregar a la lista. public Lista addLast(int dato) { if(siVacio()) { Nodo nuevo = new Nodo(dato); primero = nuevo; ultimo = nuevo; nuevo.nodoDer = nuevo; } else { Nodo nuevo=new Nodo(dato); nuevo.nodoDer=null; ultimo.nodoDer=nuevo;

42

ultimo=nuevo; } this.tamano++; return this; } //Metodo para borrar de la lista. public Nodo deleteLast() { Nodo eliminar = null; if(siVacio()) { JOptionPane.showMessageDialog(null, "La lista se encuentra vacia"); return null; }

else { //si no hay nodos int borrar=Integer.parseInt(JOptionPane.showInputDialog("Inserta el numero a borrar")); //si el nodo a eliminar fuera el ultimo if(ultimo.getDato()==borrar){

Nodo actual=primero; while(actual.nodoDer!=ultimo) { actual=actual.nodoDer; } eliminar=actual.nodoDer; actual.nodoDer=null; ultimo=actual;} else{ ultimo=primero; while (ultimo.nodoDer!=null){

43

//si el nodo a eliminar fuera el primero if (primero.getDato()==borrar) primero = ultimo.nodoDer;

//si el nodo no es el primero de la lista else if (ultimo.nodoDer.getDato()==borrar){ //guardamos en un auxiliar del siguiente //del que vamos a eliminar Nodo aux=ultimo.nodoDer.nodoDer; ultimo.nodoDer=null; ultimo.nodoDer=aux; }

ultimo=ultimo.nodoDer; } } } this.tamano--; return eliminar; } //Metodo que imprime el tamao de la lista. public void tamano() { JOptionPane.showMessageDialog(null, "El tamao es:\n " + this.tamano); } //Metodo que imprime la lista y los valores ingresados. public void imprimir() { if(tamano != 0) { Nodo temp = primero;

44

String str = ""; for(int i = 0; i < this.tamano; i++) { str = str + temp.dato + "\n"; temp = temp.nodoDer; } JOptionPane.showMessageDialog(null, str+this.tamano); } } public static void main(String[] args){ Lista lista = new Lista(); char opp=' '; do{ String opcion=JOptionPane.showInputDialog("Inserta la Opcin a Ejecutar:\n a)Insertar elemento en la lista\n b)Eliminar elemento de la lista\n c)Imprimir Lista\n d)Salir"); opp=opcion.charAt(0);

switch(opp){

case 'a':{

int num=Integer.parseInt(JOptionPane.showInputDialog("Dame un numero a insertar en la lista:")); lista.addLast(num);

break; } case 'b':{

lista.deleteLast();

45

break; } case 'c':{ lista.imprimir(); break; } case 'd':{ opp='d'; break; } default: JOptionPane.showMessageDialog(null,"Opcion no valida\nintentelo nuevamente"); } }while(opp!='d'); } }

46

Cdigo fuente programa Colas

import javax.swing.*; import java.awt.*; import java.awt.event.*;

public class colas { public static void main(String args[]) { mencola obj=new mencola(); int max=Integer.parseInt(JOptionPane.showInputDialog("Ingresa los datos que se almacenaran en la cola")); int cola[]=new int[max]; int e=0, a=0, end=0, open=0; String txt=""; String txt1=""; while(a==0) { int opc=obj.opciones(); if (opc>=1 && opc<6) { switch (opc) { case 1://insertar { if (end==max) { JOptionPane.showMessageDialog(null, "Overflow: Cola llena"); } for (e=end;e<max;e++)

47

{ if (open<0) { open=0; }

cola[e]=Integer.parseInt(JOptionPane.showInputDialog("Ingresa el elemento a insertar")); int result = JOptionPane.showConfirmDialog((Component)null,"Seguir Llenando? ","SN",JOptionPane.YES_NO_OPTION); if(result == JOptionPane.NO_OPTION) { JOptionPane.showMessageDialog(null,"Se suspende la captura antes de llenar la cola, se lleno hasta:"+end); txt+=" \nvalor del elemento de la cola["+e+"]= "+cola[e]; end++; break; } end++; if(result==JOptionPane.YES_OPTION) { txt+=" \nvalor del elemento de la cola["+e+"]= "+cola[e]; } } JOptionPane.showMessageDialog(null, txt); break; } case 2://recorrido { if(open<=0&&end<=0) { JOptionPane.showMessageDialog(null,"underflow: cola vacia");

48

} else { if(open==end) { JOptionPane.showMessageDialog(null,txt); } else { int i=open; while(i<end) { txt1+="\nvalor del elemento de la cola["+i+"]= "+cola[i]; i++; } JOptionPane.showMessageDialog(null, txt1); txt1=" "; } } break; } case 3://busqueda { int ban=0; if(open<=0 && end<=0) { ban=0; JOptionPane.showMessageDialog(null, "underflow: cola vacia "); }

49

else { int op=open, d=0; int num=Integer.parseInt(JOptionPane.showInputDialog("ingresa el numero que desee buscar en la cola")); if(end==max) { d=end-1; } else { d=end; } while(op<=d && ban==0) { if(num==cola[op]) { JOptionPane.showMessageDialog(null,"El dato fue encontrado"); JOptionPane.showMessageDialog(null,"Valor del elemento de la cola ["+op+"]= "+cola[op]); ban=1; } else { op++; } } } if(ban==0) {

50

JOptionPane.showMessageDialog(null,"El dato no fue encontrado"); } break; } case 4://eliminacion { if (open<=0&& end<=0) { JOptionPane.showMessageDialog(null,"underflow: cola vacia"); } else { if(open==end) { open=0; end=0; } else { open++; JOptionPane.showMessageDialog(null,"El elemento se ha eliminado de la cola"); } } txt=" "; for (e=open;e<end;e++) { txt+=" \nvalor del elemento de la cola["+e+"]= "+cola[e]; }

51

break; } default: { JOptionPane.showMessageDialog(null,"Fin del programa"); a=1; } } } else { JOptionPane.showMessageDialog(null,"Opcion Incorrecta"); } } } }

52

INSTITUTO TECNOLOGICO de Tuxtepec

Estructura de Datos

Unidad 4
Estructuras No Lineales

Prof.: Tomas Torres Ramrez Alumna: Daniela Guadalupe Balbuena Saldivar Ingeniera en Informtica Tercer Semestre Grupo A

53

ndice
Introduccin rboles Concepto de rbol Operaciones bsicas sobre rboles binarios Aplicaciones rboles balanceados (AVL) Grafos Terminologa de los grafos Operaciones bsicas sobre grafos 55 56 56 58 59 60 62

54

Introduccin
En esta investigacin analizaremos la estructura rbol, con lo cual se introducir el concepto de estructura de ramificacin entre nodos. Los arboles representan las estructuras no lineales y dinmicas de datos ms importantes en computacin. Son dinmicas porque la estructura rbol puede cambiar durante la ejecucin de un programa, y no lineales porque a cada elemento del rbol pueden seguirle varios elementos. A continuacin hablaremos sobre este tema ms extensamente.

55

Concepto de rbol
Un rbol es una estructura jerrquica aplicada sobre una coleccin de elementos u objetos llamados nodos; uno de los cuales es conocido como raz. Adems se crea una relacin o parentesco entre los nodos dando lugar a trminos como padre, hijo, hermano, antecesor, sucesor, ancestro, etc. Formalmente se define un rbol de tipo T como una estructura homognea que es la concatenacin de un elemento de tipo T junto con un numero finito de arboles disjuntos, llamados subrboles. Una forma particular de rbol puede ser la estructura vaca.

Operaciones Bsicas sobre arboles binarios

Un rbol ordenado es aquel en el que las ramas de los nodos del rbol estn ordenadas. Los arboles ordenados de grado 2 son de especial inters puesto que representan una de las estructuras de datos ms importantes en computacin, conocida como arboles binarios. En un rbol binario cada nodo puede tener como mximo dos subrboles; y siempre es necesario distinguir entre el subrbol izquierdo y el subrbol derecho. Recorridos en arboles binarios. Una de las operaciones ms importantes a realizar en un rbol binario es el recorrido de los mismos. Recorrer significa visitar los nodos del rbol en forma sistemtica; de tal manera que todos los nodos del mismo sean visitados una sola vez. Existen tres formas diferentes de efectuar el recorrido y todas ellas de naturaleza recursiva, estas son: a) Recorrido en pre orden Visitar la raz Recorrer el subrbol izquierdo Recorrer el subrbol derecho b) Recorrido en inorden Recorrer el subrbol izquierdo Visitar la raz Recorrer el subrbol derecho c) Recorrido en postorden

56

Recorrer el subrbol izquierdo Recorrer el subrbol derecho Visitar la raz

En la siguiente imagen se muestra un rbol binario con los diferentes tipos de recorrido:

PREORDEN: A B D E C F G INORDEN: D B E A F C G C

POSTORDEN: D E B F G C A G

57

rbol binario de bsqueda

El rbol binario de bsqueda es una estructura sobre la cual se pueden realizar eficientemente las operaciones de bsqueda, insercin y eliminacin. Formalmente se define un rbol binario de bsqueda de la siguiente manera: para todo nodo T del rbol debe cumplirse que todos los valores de los nodos del subrbol izquierdo de T deben ser menores o iguales al valor del nodo T. de forma similar, todos los valores de los nodos del subrbol derecho de T deben ser mayores o iguales al valor del nodo T. La siguiente imagen muestra un rbol binario de bsqueda:

87 43 99

120

140

130 135

22

65

93

56

Aplicaciones
Los arboles tienen una gran variedad de aplicaciones. Por ejemplo, se pueden utilizar para representar formulas matemticas, para organizar adecuadamente la informacin, para registrar la historia de un campeonato de tenis, para construir un rbol genealgico, para el anlisis de circuitos elctricos y para numerar los captulos y secciones de un libro.

58

Arboles Balanceados
Cuando estudiamos sobre los arboles binarios de bsqueda, mencionamos que son una estructura sobre la cual se pueden realizar las operaciones de bsqueda, insercin y eliminacin. Sin embargo, si el rbol crece o decrece descontroladamente, el rendimiento puede disminuir considerablemente. El caso ms desfavorable se produce cuando se inserta un conjunto de claves ordenadas en forma ascendente o descendente. Es de notar que el nmero promedio de comparaciones que debe realizarse para localizar una determinada clave, es un rbol binario de bsqueda con crecimiento descontrolado es N/2, cifra que muestra un rendimiento muy pobre en la estructura. Con el objeto de mejorar el rendimiento en la bsqueda, surgen los arboles balanceados. La idea central de estos es la de realizar reacomodos o balanceos, despus de inserciones o eliminaciones de elementos. Estos rboles tambin reciben el nombre de AVL en honor a sus inventores, dos matemticos rusos, G.M. Adelson-Velskii y E.M. Landis. Formalmente se define un rbol balanceado como un rbol binario de bsqueda, en el cual se debe cumplir la siguiente condicin: Para todo nodo T del rbol, la altura de los subrboles izquierdo y derecho no debe diferir en ms de una unidad. En la siguiente imagen se muestran un diagrama con arboles balanceados:

35 40

20

15

25

59

Terminologa de Grafos
Un grafo es un objeto matemtico que se utiliza para representar circuitos, redes, etc. Los grafos son muy utilizados en computacin, ya que permiten resolver problemas muy complejos. Imaginemos que disponemos de una serie de ciudades y de carreteras que las unen. De cada ciudad saldrn varias carreteras, por lo que para ir de una ciudad a otra se podrn tomar diversos caminos. Cada carretera tendr un coste asociado (por ejemplo, la longitud de la misma). Gracias a la representacin por grafos podremos elegir el camino ms corto que conecta dos ciudades, determinar si es posible llegar de una ciudad a otra, si desde cualquier ciudad existe un camino que llegue a cualquier otra, etc. Ejemplo de un grafo simple:

Un grafo consta de vrtices (o nodos) y aristas. Los vrtices son objetos que contienen informacin y las aristas son conexiones entre vrtices. Para representarlos, se suelen utilizar puntos para los vrtices y lneas para las conexiones, aunque hay que recordar siempre que la definicin de un grafo no depende de su representacin. TERMINOLOGA Al nmero de nodos del grafo se le llama orden del grafo. Dos nodos son adyacentes si hay un arco que los une. En un grafo dirigido, si A es adyacente de B, no necesariamente B es adyacente de A.

60

 Un grafo nulo es un grafo de orden 0 (cero). Camino es una secuencia de uno o ms arcos que conectan dos nodos. Un grafo se denomina conectado cuando existe siempre un camino que une dos nodos cualesquiera y desconectado en caso contrario. Un grafo es completo cuando cada nodo est conectado con todos y cada uno de los nodos restantes.

61

Operaciones Bsicas sobre grafos

En los grafos, como en todas las estructuras de datos, las dos operaciones bsicas son insertar y borrar. En este caso, cada una de ellas se desdobla en dos: Para insertar/eliminar vrtices Insertar/eliminar aristas

En la mayora de los casos los grafos son dispersos: cuanto mucho una arista entre un vrtice y otro. Insertar un vrtice La operacin de insercin de un nuevo vrtice es una operacin muy sencilla, nicamente consiste en aadir una nueva entrada en la tabla de vrtices (estructura de datos que almacena los vrtices) para el nuevo nodo. A partir de ese momento el grafo tendr un vrtice ms, inicialmente aislado, ya que ninguna arista llegar a l. Insertar una arista Esta operacin es tambin muy sencilla. Cuando se inserte una nueva arista en el grafo, habr que aadir un nuevo nodo a la lista de adyacencia (lista que almacena los nodos a los que un vrtice puede acceder mediante una arista) del nodo origen, as si se aade la arista (A,C), se deber incluir en la lista de adyacencia de A el vrtice C como nuevo destino. Eliminar un vrtice Esta operacin es inversa a la insercin de vrtice. En este caso el procedimiento a realizar es la eliminacin de la tabla de vrtices del vrtice en s. A continuacin habr que eliminar las aristas que tuviesen al vrtice borrado como origen o destino.

62

Eliminar arista Mediante esta operacin se borra un arco del grafo. Para llevar a cabo esta accin es necesario eliminar de la lista de adyacencia del nodo origen el nodo correspondiente al nodo destino. Grafos donde tambin se opera: Completo: En funcin del nmero de vrtices introducidos por el usuario se crea un grafo completo. Estrella: Muestra los vrtices circularmente excepto uno que se sita en el centro y se aaden todos los arcos posibles entre este vrtice y todos los que se encuentran en la periferia Rueda: Muestra los vrtices circularmente uniendo los vrtices consecutivos por un arco pero adems aade un vrtice en el centro y pone todos los arcos posibles entre este vrtice y los que estn en la periferia. Ciclo: Muestra los vrtices circularmente y aade arcos entre los vrtices consecutivos. Otras operaciones importantes Las operaciones adicionales que puede incluir un grafo son muy variadas. 1. Podemos encontrarnos con ejecucin de algoritmos que busquen caminos ms cortos entre dos vrtices 2. Recorridos del grafo que ejecuten alguna operacin sobre todos los vrtices visitados 3. Recorridos del grafo por citar algunas operaciones de las ms usuales. Los campos de utilizacin de los grafos son muy variados, ya que los vrtices pueden representar cualquier elemento (ciudades, aeropuertos, Pcs...), las aristas seran la conexin entre esos elementos (carreteras, pasillos areos, redes...). Por lo tanto los grafos son muy usados en la modelizacin de sistemas reales.

63

INSTITUTO TECNOLOGICO de Tuxtepec

Estructura de Datos

Unidad 5
Mtodos de Ordenamiento

Prof.: Tomas Torres Ramrez Alumna: Daniela Guadalupe Balbuena Saldivar Ingeniera en Informtica Tercer Semestre Grupo A

64

ndice
Cdigo fuente programa con mtodo burbuja Cdigo fuente programa con mtodo burbuja dos Cdigo fuente programa con mtodo quicksort 66 69 72

65

Cdigo fuente programa con mtodo burbuja

import javax.swing.*; public class burbuja { int i=0,j=0, aux=0; public void insertar (int x[],int n) { if(i<n){ x[i]=Integer.parseInt(JOptionPane.showInputDialog("Dame un numero")); i++;}else JOptionPane.showMessageDialog(null,"NO hay mas espacios en el arreglo"); } public void ordenar (int x[],int n)//Burbuja { if(i>0){ for (int b=0; b<i; b++) { for (j=0; j<i-1; j++) { if (x[j] > x[j+1]){ aux=x[j]; x[j]=x[j+1]; x[j+1]=aux; } } } }else JOptionPane.showMessageDialog(null,"Arreglo Vacio imposible ordenar"); } public void imprimir (int x[]) { if(i>0){

66

String cadena="|"; for (int a=0; a<i; a++) { cadena+=(x[a] + " | ");

} JOptionPane.showMessageDialog(null,cadena); }else JOptionPane.showMessageDialog(null,"Imposible mostrar el arreglo(Inexistente)");}

public static void main(String[] args) { JOptionPane.showMessageDialog(null,"Profesor no pude hacer lo demas :S no le entiendo a los algoritmos :S..Disculpeme :/");

int op=0; int n=Integer.parseInt(JOptionPane.showInputDialog("Dame el tamao del vector")); int x[]= new int [n];//tamao del vector burbuja llama = new burbuja();//se crea un objeto para llamar las funciones do{

op=Integer.parseInt(JOptionPane.showInputDialog("*************Ordenamiento Burbuja***************\nInserta la opcin a ejecutar\n1.-Insertar elemento\n2.-Ordenar\n3.Imprimir\n4.-Salir\n")); switch(op){ case 1:{

llama.insertar(x,n);//se envian parametros break; } case 2:{

67

llama.ordenar(x,n);//= break;} case 3:{

llama.imprimir(x);//= break; } case 4:{ break; }

default: JOptionPane.showMessageDialog(null,"Opcion no valida"); } }while(op!=4);// el programa seguira mientras no se inserte un 4 } }

68

Cdigo fuente programa con mtodo burbuja dos

import javax.swing.*; public class metodos { int i=0,j=0, aux=0; public void insertar (int x[],int n) { if(i<n){ x[i]=Integer.parseInt(JOptionPane.showInputDialog("Dame un numero")); i++;}else JOptionPane.showMessageDialog(null,"NO hay mas espacios en el arreglo"); } public void ordenar (int x[],int n)//Burbuja { if(i>0){ for (int b=0; b<i; b++) { for (j=0; j<i-1; j++) { if (x[j] > x[j+1]){ aux=x[j]; x[j]=x[j+1]; x[j+1]=aux; } } } }else JOptionPane.showMessageDialog(null,"Arreglo Vacio imposible ordenar"); } public void imprimir (int x[]) { if(i>0){

69

String cadena="|"; for (int a=0; a<i; a++) { cadena+=(x[a] + " | "); } JOptionPane.showMessageDialog(null,cadena); }else JOptionPane.showMessageDialog(null,"Imposible mostrar el arreglo(Inexistente)");} public static void main(String[] args) { int op=0; int n=Integer.parseInt(JOptionPane.showInputDialog("Dame el tamao del vector")); int x[]= new int [n];//tamao del vector metodos llama = new metodos();//se crea un objeto para llamar las funciones do{

op=Integer.parseInt(JOptionPane.showInputDialog("*************Ordenamiento Burbuja***************\nInserta la opcin a ejecutar\n1.-Insertar elemento\n2.-Ordenar\n3.Imprimir\n4.-Salir\n")); switch(op){ case 1:{ llama.insertar(x,n);//se envian parametros break; } case 2:{ llama.ordenar(x,n);//= break;} case 3:{ llama.imprimir(x);//= break; } case 4:{

70

break; }

default: JOptionPane.showMessageDialog(null,"Opcion no valida"); } }while(op!=4);// el programa seguira mientras no se inserte un 4 } }

71

Cdigo fuente programa con mtodo quicksort

package ordenamiento; import java.awt.*; import javax.swing.*; import java.awt.event.*; public class quickSort extends JFrame{ int a[]=new int[5]; int i, n, j; int max, mayor; String salida1="", salida2=""; JTextArea areaSalida=new JTextArea(6,6); JTextArea areaSalida2=new JTextArea(6,6); JTextField numero=new JTextField(15); String salida=""; public quickSort(){ super("Ordenamiento Quick Sort"); JLabel etiqueta=new JLabel("Cuales numeros desea insertar?"); JLabel etiqueta1=new JLabel("Los numeros son:"); JButton capturar=new JButton("Capturar"); capturar.addActionListener( new ActionListener(){ public void actionPerformed(ActionEvent evento){ captura(); } } ); JButton ordenar=new JButton("Ordenar"); ordenar.addActionListener(

72

new ActionListener(){ public void actionPerformed(ActionEvent evento){ quick(a,n); } } ); Container contenedor=getContentPane(); contenedor.setLayout(new FlowLayout()); contenedor.add(etiqueta); contenedor.add(numero); contenedor.add(capturar); contenedor.add(etiqueta1); contenedor.add(areaSalida); contenedor.add(ordenar); contenedor.add(areaSalida2); setSize(300,300); setVisible(true); } public void captura(){ if (numero.getText().equals("")){ JOptionPane.showMessageDialog(null,"Escriba un nombre"); numero.setText(""); } else{ a[i]=Integer.parseInt(numero.getText()); salida2+=a[i]+"\n"; i++; numero.setText("");

73

if (i==5){ n=i; JOptionPane.showMessageDialog(null,"Fin de la captura"); } areaSalida.setText(salida2); } } public void muestra(int nn,int a3[]){ for(int k=0;k<nn;k++) salida1+=a3[k]+"\n"; areaSalida2.setText(salida1); } public void quick(int lista[], int n){ partir(0,n-1); } public void partir(int primero,int ultimo){ int i,j,aux,central,cont=1; i=primero; j=ultimo; central=a[(primero+ultimo)/2]; while(cont==1){ while(a[i]<central){ i++; } while(a[j]>central){ j--; } if (i<=j){ aux=a[i]; a[i]=a[j]; a[j]=aux;

74

if (i<=j) i+=1; if (j<ultimo) j+=1; }

if (i>j) cont=0; }

if (primero<j) partir(primero,j); else if(i<ultimo) partir(i,ultimo);

else if (primero==j) muestra(n,a);

public static void main(String[] args) { quickSort aplicacion3 =new quickSort(); aplicacion3.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } }

75

INSTITUTO TECNOLOGICO de Tuxtepec

Estructura de Datos

Unidad 6
Mtodos de Bsqueda

Prof.: Tomas Torres Ramrez Alumna: Daniela Guadalupe Balbuena Saldivar Ingeniera en Informtica Tercer Semestre Grupo A

76

ndice
Bsqueda Secuencial Algoritmo de bsqueda secuencial en archivos Cdigo fuente para crear archivos Bsqueda binaria Algoritmo de bsqueda binaria 78 78 79 87 87

77

Bsqueda Secuencial
La bsqueda secuencial consiste en revisar elemento por elemento hasta encontrar el dato buscado, o hasta llegar al final de la lista de datos disponibles. La bsqueda secuencial se puede realizar tanto en arreglos como en listas. Los arreglos podrn estar ordenados o desordenados. la bsqueda secuencial tambin se puede realizar en archivos. La bsqueda en archivos secuenciales consiste en recorrer el archivo comprando la clave buscada con la clave del registro en curso. El recorrido lineal del archivo termina cuando se encuentra el elemento, o bien, cuando se alcanza el fin del archivo. Se pueden presentar algunas variantes dentro de este mtodo, dependiendo de si el archivo esta o no ordenado. A continuacin se detalla el algoritmo de bsqueda en un archivo secuencial desordenado.

ARCHIVOSECDESORDENADO (FA, K) {Este algoritmo busca secuencialmente en el archivo desordenado FA, un registro con clave K} {BANDERA es una variable de tipo booleano. R es una variable de tipo registro} 1. Abrir el archivo FA para lectura 2. Hacer BANDERA FALSO 3. Repetir mientras (no sea el fin de archivo de FA) y (BANDERA = FALSO) Leer R de FA 3.1 Si R.CLAVE = K entonces Escribir El elemento esta en el archivo

78

Hacer BANDERA VERDADERO 3.2{Fin del condicional del paso 3.1} 4. {Fin del ciclo del paso 3} 5 .Si BANDERA = FALSO entonces 6. {Fin del condicional del paso 5}

Cdigo fuente para crear archivos

import java.awt.*; import javax.swing.*; import java.awt.event.*; import java.io.*; public class archivos extends JFrame { /* Crea todos los objetos que voy a necesitar para visualizar mi Editor de Textos */ BorderLayout borderLayout1 = new BorderLayout(); JPanel panel = new JPanel(); JMenuBar barraDeMenu = new JMenuBar(); JMenu archivo = new JMenu(); JMenu editar = new JMenu(); JMenu ver = new JMenu(); JMenu buscar = new JMenu(); JMenu ayuda = new JMenu(); JTextArea areaDeTexto = new JTextArea(); JScrollPane scrollPane = new JScrollPane(); JFileChooser jfc = new JFileChooser(); /* Crea todos los SubMenus para cada Elemento(Opcion) de la barraDeMenu */ JMenuItem archivo_Nuevo = new JMenuItem(); JMenuItem archivo_Abrir = new JMenuItem(); JMenuItem archivo_Guardar = new JMenuItem(); JMenuItem archivo_GuardarComo = new JMenuItem();

79

JMenuItem archivo_Cerrar = new JMenuItem(); JMenuItem archivo_Salir = new JMenuItem(); JMenuItem editar_Deshacer = new JMenuItem(); JMenuItem editar_Rehacer = new JMenuItem(); JMenuItem editar_Cortar = new JMenuItem(); JMenuItem editar_Copiar = new JMenuItem(); JMenuItem editar_Pegar = new JMenuItem(); JMenuItem editar_Borrar = new JMenuItem(); JMenuItem editar_Preferencias = new JMenuItem(); JCheckBoxMenuItem ver_barraHerramientas = new JCheckBoxMenuItem(); JCheckBoxMenuItem ver_barraDeEstado = new JCheckBoxMenuItem(); JMenuItem buscar_Buscar = new JMenuItem(); JMenuItem buscar_Siguiente = new JMenuItem(); JMenuItem buscar_Anterior = new JMenuItem(); JMenuItem buscar_Ir_A_Linea = new JMenuItem(); JMenuItem ayuda_Contenido = new JMenuItem(); JMenuItem ayuda_acercaDe = new JMenuItem();

/* Constructor donde establece todas las caracteristicas del Editor de Texto */ public archivos() { panel.setLayout(borderLayout1); super.setTitle("Daniela Gpe. Balbuena Saldivar"); /* Establesco el Texto de cada elemento del Menu */ archivo.setText("Archivo"); archivo.setMnemonic('A'); archivo_Nuevo.setText("Nuevo"); archivo_Abrir.setText("Abrir"); archivo_Guardar.setText("Guardar"); archivo_GuardarComo.setText("Guardar como..."); archivo_Cerrar.setText("Cerrar"); archivo_Salir.setText("Salir");

80

editar.setText("Editar"); editar.setMnemonic('E'); editar_Deshacer.setText("Deshacer"); editar_Rehacer.setText("Rehacer"); editar_Cortar.setText("Cortar"); editar_Copiar.setText("Copiar"); editar_Pegar.setText("Pegar"); editar_Borrar.setText("Borrar"); editar_Preferencias.setText("Preferencias"); ver.setText("Ver"); ver.setMnemonic('V'); ver_barraHerramientas.setText("Barra de Herramientas"); ver_barraDeEstado.setText("Barra de Estado"); buscar.setText("Buscar"); buscar.setMnemonic('B'); buscar_Buscar.setText("Buscar"); buscar_Siguiente.setText("Buscar siguiente.."); buscar_Anterior.setText("Buscar Anterior.."); buscar_Ir_A_Linea.setText("Ir a Linea.."); ayuda.setText("Ayuda"); ayuda.setMnemonic('U'); ayuda_Contenido.setText("Contenido"); ayuda_acercaDe.setText("Acerca de"); /* Deshabilito las opciones de Buscar como estado incial * ya que en ningun momento se inicio una busqueda */ buscar_Siguiente.setEnabled(false); buscar_Anterior.setEnabled(false); /* Deshabilito las opciones de Editar como estado inicial * ya que en ningun momento se edito el archivo */

81

editar_Deshacer.setEnabled(false); editar_Rehacer.setEnabled(false); editar_Cortar.setEnabled(false); editar_Copiar.setEnabled(false); editar_Pegar.setEnabled(false); editar_Borrar.setEnabled(false); /* Habilito las opciones de Ver ya que al inicio de todo * editor se muestra la barra de Estado y de Herramientas */ ver_barraHerramientas.setSelected(true); ver_barraDeEstado.setSelected(true); /* Agrego todas las opciones a la barra de Menu */ barraDeMenu.add(archivo); barraDeMenu.add(editar); barraDeMenu.add(ver); barraDeMenu.add(buscar); barraDeMenu.add(ayuda); /* Agrego a las opciones los items correspondientes */ archivo.add(archivo_Nuevo); archivo.add(archivo_Abrir); archivo.add(archivo_Guardar); archivo.add(archivo_GuardarComo); archivo.add(archivo_Cerrar); archivo.add(archivo_Salir); editar.add(editar_Deshacer); editar.add(editar_Rehacer); editar.add(editar_Cortar); editar.add(editar_Copiar); editar.add(editar_Pegar); editar.add(editar_Borrar); editar.add(editar_Preferencias);

82

ver.add(ver_barraHerramientas); ver.add(ver_barraDeEstado); buscar.add(buscar_Buscar); buscar.add(buscar_Siguiente); buscar.add(buscar_Anterior); buscar.add(buscar_Ir_A_Linea); ayuda.add(ayuda_Contenido); ayuda.add(ayuda_acercaDe); /* Una vez armado el Menu lo agrego al Frame */ this.setJMenuBar(barraDeMenu); this.getContentPane().add(panel, BorderLayout.CENTER); this.getContentPane().setPreferredSize(new Dimension(500,400)); this.getContentPane().add(scrollPane, BorderLayout.CENTER); scrollPane.getViewport().add(areaDeTexto, null); /* Eventos de Todos los Elementos del Menu */ // archivo_Nuevo = Creo un Nuevo Archivo archivo_Nuevo.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { areaDeTexto.setText(""); } }); archivo_Abrir.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { if(e.getSource() == archivo_Abrir) { int abroArchivo = jfc.showOpenDialog(archivos.this); if(abroArchivo == jfc.APPROVE_OPTION) { File archivo = jfc.getSelectedFile(); FileInputStream miArchivo; int sizeArchivo = Long.valueOf(archivo.length()).intValue(); byte archivoALeer[]= new byte[sizeArchivo]; try {

83

miArchivo = new FileInputStream(archivo.getPath()); miArchivo.read(archivoALeer); areaDeTexto.append(new String(archivoALeer)); miArchivo.close(); } catch(IOException ex) { System.out.println("Error : "+ex.getMessage()); } } areaDeTexto.setCaretPosition(areaDeTexto.getDocument().getLength()); } } }); archivo_Guardar.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { File archivo = jfc.getSelectedFile(); FileOutputStream miArchivo; String contenidoTexto = new String(); try { miArchivo = new FileOutputStream(archivo.getPath()); contenidoTexto = areaDeTexto.getText(); miArchivo.write(contenidoTexto.getBytes()); miArchivo.close(); } catch(IOException ex) { System.out.println("Error : "+ex.getMessage()); } } }); // archivo_GuardarComo = Guardo mediante el Documento Abierto por el FileChooser + Stream.

84

archivo_GuardarComo.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { if(e.getSource() == archivo_GuardarComo) { int guardoArchivo = jfc.showSaveDialog(archivos.this); if(guardoArchivo == jfc.APPROVE_OPTION) { File archivo = jfc.getSelectedFile(); FileOutputStream miArchivo; String contenidoTexto = new String(); try { miArchivo = new FileOutputStream(archivo.getPath()); contenidoTexto = new String(areaDeTexto.getText()); miArchivo.write(contenidoTexto.getBytes()); miArchivo.close(); } catch(IOException ex) { System.out.println("Error : "+ex.getMessage()); } } } } }); // archivo_Cerrar = Cierro el JTextArea archivo_Cerrar.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { panel.removeAll(); borderLayout1.removeLayoutComponent(areaDeTexto); } }); // archivo_Salir = Salgo del Editor de Texto archivo_Salir.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) {

85

System.exit(0); } }); // editar_Cortar = Corta el texto seleccionado y lo guarda en el clipboard editar_Cortar.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { if(e.getSource() == editar_Cortar) { areaDeTexto.cut(); } } }); // buscar_Buscar = Busco String que ingreso buscar_Buscar.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { // JOptionPane; } }); ayuda_acercaDe.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { String texto = "Este es mi primer programa que decidi hacer porque supuse conveniente \n para poner en practica todos 'mis conocimientos' adquiridos luego de leer el book User - Java"; JOptionPane.showMessageDialog(new JOptionPane.INFORMATION_MESSAGE); } }); super.pack(); super.show(); } public static void main(String argv[]) { new archivos(); } } JFrame(), texto, "Acerca de Rami Editor",

86

Bsqueda Binaria
La bsqueda binaria consiste en dividir el intervalo de bsqueda en dos partes, comparando el elemento buscado con el central. En caso de no ser iguales se redefinen los extremos del intervalo (segn el elemento central sea mayor o menor que el buscado) disminuyendo el espacio de bsqueda. El proceso concluye cuando el elemento es encontrado, o bien cuando el intervalo de bsqueda se anula. Este mtodo funciona nicamente para arreglos ordenados. Con cada iteracin del mtodo el espacio de bsqueda se reduce a la mitad, por lo tanto el numero de comparaciones q realizar disminuye notablemente. Esta disminucin resulta significativa cuanto ms grande sea el tamao del arreglo. A continuacin se presenta el algoritmo de bsqueda binaria. BINARIA (V, N, X) {Este algoritmo busca al elemento X en el arreglo ordenado V de N componentes} {IZQ, CEN, y DER son variables de tipo entero. BANDERA es una variable de tipo booleano} 1.Hacer IZQ 1, DER N y BANDERA FALSO 2.Repetir mientras (IZQ DER) y (BANDERA = FALSO) Hacer CEN PARTE ENTERA ((IZQ + DER) / 2) 2.1Si X = V [CEN] Entonces Hacer BANDERA VERDADERO Sino {redefinir intervalo de bsqueda} 2.1.1 Si X > V [CEN] Entonces Hacer IZQ CEN + 1 Sino

87

Hacer DER CEN 1 2.1.2{Fin del condicional del paso 2.1.1} 2.2 {Fin del condicional del paso 2.1} 3 .{Fin del ciclo del paso 2} 4. Si BANDERA = VERDADERO Entonces Escribir El elemento esta en la posicin CEN Sino Escribir el elemento no esta en el arreglo 5. {Fin del condicional del paso 4}

88

INSTITUTO TECNOLOGICO de Tuxtepec

Estructura de Datos

Unidad 7
Anlisis de los algoritmos

Prof.: Tomas Torres Ramrez Alumna: Daniela Guadalupe Balbuena Saldivar Ingeniera en Informtica Tercer Semestre Grupo A

89

ndice
Introduccin Complejidad en el tiempo Complejidad en el espacio Eficiencia de los algoritmos Conclusiones 91 92 96 97 98

90

Introduccin
A travs del anlisis de los algoritmos es posible establecer la calidad de un programa y compararlo con otros programas que se puedan escribir para resolver el mismo problema, sin necesidad de desarrollarlos. Este anlisis se basa en las caractersticas estructurales del algoritmo que respalda el programa y en la cantidad de memoria que ste utiliza para resolver un problema. El anlisis de algoritmos tambin es usado para evaluar el diseo de las estructuras de datos de un programa, midiendo la eficiencia con que los algoritmos del programa son capaces de resolver el problema planteado, etc. La idea detrs del concepto de complejidad es tratar de encontrar una funcin f( n ), fcil de calcular y conocida, que acote el crecimiento de la funcin de tiempo, para poder decir "TA(n) crece aproximadamente como f" o, ms exactamente, "en ningn caso TA(n) se comporta peor que f al aumentar el tamao del problema". En la figura 0.4. aparece la manera cmo crecen algunas de las funciones ms utilizadas en el clculo de la complejidad.

Fig. 0.4 - Crecimiento de las funciones tpicas de complejidad de algoritmos Es necesario introducir este concepto para entender los temas que veremos en esta unidad.

91

Complejidad en el tiempo
El tiempo de Ejecucin de un programa se mide en funcin de N, lo que designaremos como T(N). Esta funcin se puede calcular fsicamente ejecutando el programa acompaados de un reloj, o calcularse directamente sobre el cdigo, contando las instrucciones a ser ejecutadas y multiplicando por el tiempo requerido por cada instruccin. As, un trozo sencillo de cdigo como: S1; for(x = 0; x < N; x++) S2; Demanda: T(N) = t1 + t2 * N Donde t1 es el tiempo que lleva ejecutar la serie S1 de sentencias, y t2 es el que lleva la serie S2. Habitualmente todos los algoritmos contienen alguna sentencia condicional o selectiva, haciendo que las sentencias ejecutadas dependan de la condicin lgica, esto hace que aparezca ms de un valor para T(N), es por ello que debemos hablar de un rango de valores: Tmin(N) T(N) Tmax(N) Estos extremos son llamados "el peor caso" y "el mejor caso" y entre ambos se puede hallar "el caso promedio" o el ms frecuente, siendo este el ms difcil de estudiar; nos centraremos en el "el peor caso" por ser de fcil clculo y se acerca a "el caso promedio", brindndonos una medida pesimista pero fiable. Toda funcin T(N) encierra referencias al parmetro N, y a una serie de constantes Ti dependientes de factores externos al algoritmo. Se tratar de analizar los algoritmos dndoles autonoma frente a estos factores externos, buscando estimaciones generales ampliamente vlidas, a pesar de ser demostraciones tericas.

92

rdenes de Complejidad
Se dice que O(f(n)) define un "orden de complejidad". Escogeremos como representante de este orden a la funcin f(n) ms sencilla del mismo. As tendremos O(1) orden constante O(log n) orden logartmico O(n) orden lineal O(n log n) O(n2) orden cuadrtico O(na) orden polinomial (a > 2) n) O(a orden exponencial (a > 2) O(n!) orden factorial Es ms, se puede identificar una jerarqua de rdenes de complejidad que coincide con el orden de la tabla anterior; jerarqua en el sentido de que cada orden de complejidad superior tiene a los inferiores como subconjuntos. Si un algoritmo A se puede demostrar de un cierto orden O 1, es cierto que tambien pertenece a todos los rdenes superiores (la relacin de orden ota superior de' es transitiva); pero en la prctica lo til es encontrar la "menor cota superior", es decir el menor orden de complejidad que lo cubra. Para captar la importancia relativa de los rdenes de complejidad conviene echar algunas cuentas. Sea un problema que sabemos resolver con algoritmos de diferentes complejidades. Para compararlos entre si, supongamos que todos ellos requieren 1 hora de ordenador para resolver un problema de tamao N=100. Qu ocurre si disponemos del doble de tiempo? Ntese que esto es lo mismo que disponer del mismo tiempo en un ordenador el doble de potente, y que el ritmo actual de progreso del hardware es exactamente ese: "duplicacin anual del nmero de instrucciones por segundo". Qu ocurre si queremos resolver un problema de tamao 2n? O(f(n)) N=100 t=2h N=200 log n 1 h 10000 1.15 h

93

n 1h n log n 1 h n2 1h 3 n 1h 2n 1h

200 199 141 126 101

2h 2.30 h 4h 8h 1030 h

Los algoritmos de complejidad O(n) y O(n log n) son los que muestran un comportamiento ms "natural": prcticamente a doble de tiempo, doble de datos procesables. Los algoritmos de complejidad logartmica son un descubrimiento fenomenal, pues en el doble de tiempo permiten atacar problemas notablemente mayores, y para resolver un problema el doble de grande slo hace falta un poco ms de tiempo (ni mucho menos el doble). Los algoritmos de tipo polinmico no son una maravilla, y se enfrentan con dificultad a problemas de tamao creciente. La prctica viene a decirnos que son el lmite de lo "tratable". Sobre la tratabilidad de los algoritmos de complejidad polinmica habria mucho que hablar, y a veces semejante calificativo es puro eufemismo. Mientras complejidades del orden O(n2) y O(n3) suelen ser efectivamente abordables, prcticamente nadie acepta algoritmos de orden O(n100), por muy polinmicos que sean. La frontera es imprecisa. Cualquier algoritmo por encima de una complejidad polinmica se dice "intratable" y slo ser aplicable a problemas ridiculamente pequeos. A la vista de lo anterior se comprende que los programadores busquen algoritmos de complejidad lineal. Es un golpe de suerte encontrar algo de complejidad logartmica. Si se encuentran soluciones polinomiales, se puede vivir con ellas; pero ante soluciones de complejidad exponencial, ms vale seguir buscando. No obstante lo anterior...

... si un programa se va a ejecutar muy pocas veces, los costes de codificacin y depuracin son los que ms importan, relegando la complejidad a un papel secundario. ... si a un programa se le prev larga vida, hay que pensar que le tocar mantenerlo a otra persona y, por tanto, conviene tener en cuenta su legibilidad, incluso a costa de la complejidad de los algoritmos empleados.

94

si podemos garantizar que un programa slo va a trabajar sobre datos pequeos (valores bajos de N), el orden de complejidad del algoritmo que usemos suele ser irrelevante, pudiendo llegar a ser incluso contraproducente. Por ejemplo, si disponemos de dos algoritmos para el mismo problema, con tiempos de ejecucin respectivos: algoritmo tiempo complejidad f 100 n O(n) g n2 O(n2) asintticamente, "f" es mejor algoritmo que "g"; pero esto es cierto a partir de N > 100. Si nuestro problema no va a tratar jams problemas de tamao mayor que 100, es mejor solucin usar el algoritmo "g". El ejemplo anterior muestra que las constantes que aparecen en las frmulas para T(n), y que desaparecen al calcular las funciones de complejidad, pueden ser decisivas desde el punto de vista de ingeniera. Pueden darse incluso ejemplos ms dramaticos: algoritmo tiempo complejidad f n O(n) g 100 n O(n) an siendo dos algoritmos con idntico comportamiento asinttico, es obvio que el algoritmo "f" es siempre 100 veces ms rpido que el "g" y candidato primero a ser utilizado.

... usualmente un programa de baja complejidad en cuanto a tiempo de ejecucin, suele conllevar un alto consumo de memoria; y viceversa. A veces hay que sopesar ambos factores, quedndonos en algn punto de compromiso. ... en problemas de clculo numrico hay que tener en cuenta ms factores que su complejidad pura y dura, o incluso que su tiempo de ejecucin: queda por considerar la precisin del clculo, el mximo error introducido en clculos intermedios, la estabilidad del algoritmo, etc. etc.

95

Complejidad en el Espacio
Es la memoria que utiliza un programa para su ejecucin; es decir el espacio de memoria que ocupan todas las variables propias del algoritmo. Esta se divide en: Memoria esttica. Para calcularla se suma de memoria que ocupan las variables declaradas en el algoritmo. Memoria dinmica. Su clculo no es tan simple ya que depende de cada ejecucin del algoritmo.

La misma idea que se utiliza para medir la complejidad en tiempo de un algoritmo se utiliza para medir su complejidad en espacio. Decir que un programa es O( N ) en espacio significa que sus requerimientos de memoria aumentan proporcionalmente con el tamao del problema. Esto es, si el problema se duplica, se necesita el doble de memoria. Del mismo modo, para un programa de complejidad O( N2 ) en espacio, la cantidad de memoria que se necesita para almacenar los datos crece con el cuadrado del tamao del problema: si el problema se duplica, se requiere cuatro veces ms memoria. En general, el clculo de la complejidad en espacio de un algoritmo es un proceso sencillo que se realiza mediante el estudio de las estructuras de datos y su relacin con el tamao del problema. El problema de eficiencia de un programa se puede plantear como un compromiso entre el tiempo y el espacio utilizados. En general, al aumentar el espacio utilizado para almacenar la informacin, se puede conseguir un mejor desempeo, y, entre ms compactas sean las estructuras de datos, menos veloces resultan los algoritmos. Lo mismo sucede con el tipo de estructura de datos que utilice un programa, puesto que cada una de ellas lleva implcitas unas limitaciones de eficiencia para sus operaciones bsicas de administracin. Por eso, la etapa de diseo es tan importante dentro del proceso de construccin de software, ya que va a determinar en muchos aspectos la calidad del producto obtenido.

96

Eficiencia de los algoritmos

En programacin, la eficiencia es utilizada propiedades deseables en los algoritmos. Generalmente la eficiencia puede medirse en: Velocidad: el tiempo que toma para completar una operacin. Espacio: la memoria principal y/o secundaria empleada. para describir varias

La optimizacin es el proceso de hacer un cdigo (grupo de algoritmos) lo ms eficientemente posible. A veces optimizar espacio implica una desmejora en la velocidad, o viceversa. Muchas veces, la optimizacin de los algoritmos depende de las propiedades de la mquina en donde sern ejecutados. Encontrar Algoritmos eficientes puede definir si Existe o no una Solucin al Problema. Al Anlisis de Algoritmos se centra en el estudio de los Bucles, del cual en ltima instancia, dependern las instrucciones a ser ejecutadas.

No se puede realizar un anlisis del nmero de Instrucciones pues son dependientes de las tecnologas (RISK, CISC). Eficiencia = F(n) Siendo n la cantidad de elementos a ser procesados Medicin de la Eficiencia La estimacin debe ser independiente de la plataforma y la Lenguaje con que se codificar pero debe reflejar sus diferencias. - Usamos el Orden de Magnitud (O-grande) de la Eficiencia del Tiempo y de los recursos. - Se lo complementa con la Tasa de crecimiento del programa para evaluar su comportamiento Futuro. Cmo comparar la Eficiencia Real de 2 Algoritmos?

97

- Programndolos, implementndolos y midiendo para el mismo lote de Prueba: el tiempo de ejecucin y los recursos utilizados. - Suele ser caro, y una vez realizado no suele ser sencillo volver atrs y corregir.

Anlisis de Rendimiento Mediante la complejidad en el Tiempo y en el Espacio Tiempo de Ejecucin: depender del programa y de su entrada (carga de trabajo). - El tiempo medio suele ser ms realista. Para usar todos los tipos de entradas son equiprobables. - El Tiempo Mximo depende de la Carga Mxima: y no siempre se puede establecer con claridad o es estadsticamente variable

98

Conclusiones
Con esta investigacin se ha llegado a la conclusin de que para realizar un programa es necesario elegir antes que nada un buen algoritmo, que sea ms eficiente en lo que deseamos que el programa realice, y tomar en cuenta el tiempo de ejecucin y de espacio que utilizara para llevarse a cabo.

99

Este portafolio tuvo la finalidad de agrupar todo lo visto a lo largo del semestre en la materia de Estructura de Datos. Cada uno de los temas aqu mencionados fueron vistos en el curso, unos con ms importancia que otros. En lo personal, pienso que deb aprender ms sobre estos temas, ya que en el futuro me servirn de mucho, por lo que buscare mas informacin.

100