Portafolio

997
-1

Published on

0 Comments
1 Like
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
997
On Slideshare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
Downloads
30
Comments
0
Likes
1
Embeds 0
No embeds

No notes for slide

Portafolio

  1. 1. INSTITUTO TECNOLÓGICO INSTITUTO TECNOLÓGICO 1 DE TUXTEPEC DE TUXTEPEC Ingeniería en informática Portafolio de evidencias Actiiviidad: Act v dad: Temas de la unidad Grupo “A”Turno: vespertino Presentado por: Margarita Antonio Gómez Profesor(a): Lic. Tomas Torres Ramírez 5 de diciembre 20011
  2. 2. 2 ÍndiceIntroducción…………..………………………………………….3Introducción a las estructuras dedatos………………………………………4Recursividad…………………………………………………………………………………….7Estructuraslineales………………………………………………………………………13Estructuras nolineales…………………………………………………………………43Métodos deordenamiento…………………………………………………………..63
  3. 3. Métodos de 3búsqueda………………………………………………………………….68Análisis de los algoritmosConclusión……………………………………………………………………………………… INTRODUCCIONEn este trabajo hablaremos de todos lostemas del semestre, relacionados conla carrera de informática, en la materiaestructura de datos.
  4. 4. También algunos ejemplos de 4programas en java que complementa loaprendido en este semestre.INTRODUCCIÓN A LAS ESTRUCTURAS DE DATOS. TIPOS DE DATOS ABSTRACTOS (TDA) Un TDA es un tipo de dato definido por el programador que se puede manipular de un modo similar a los tipos de datos definidos por el sistema.
  5. 5. Está formado por un conjunto válido de elementos y un número de 5 operaciones primitivas que se pueden realizar sobre ellos. Ejemplo: - Definición del tipo Numero racional: Conjunto de pares de elementos (a,b) de tipo entero, con b<>0.MAPA CONCEPTUAL TAD PROGRAMA RECURSIONES ARCHIVO DE TEXTO/* * Programa que utiliza metodos recursivos * Fibonaci, Factorial, Potencia y Division por estas sucesivas */package packRecursiones;import javax.swing.*;public class claseRecursivas {public static int a, b, n;
  6. 6. claseRecursivas(){ 6a=0; b=0; n=0;};public static int potencia(int b, int n) {if(n == 0) { //caso basereturn 1;} else {return b * potencia(b, n -1); // llamada recursiva} }public static int factorial(int n){if(n==0) return 1; //Caso baseelse return n*factorial(n-1); //Formula recursiva}public static int fibonaci( int n){if(n==1 || n==2) return 1;else return fibonaci(n-1)+fibonaci(n-2);}public static int division( int a, int b) {if(b > a) return 0;elsereturn division(a-b, b) + 1;}public static void menu(){String k="";int e=5, r=0;k+="Menú de operacionesnn1) Fibonacin2) Factorialn3) potencian";k+="4) Division por restas sucesivasn5) Salir";k+="nnElige una opción";do{e=Integer.parseInt(JOptionPane.showInputDialog(k));switch(e){case 1:n=Integer.parseInt(JOptionPane.showInputDialog("Valor maximo para fibonaci"));r=fibonaci(n);JOptionPane.showMessageDialog(null,"Los numero fibonaci son "+r);break;case 2:n=Integer.parseInt(JOptionPane.showInputDialog("Valor para obtener elfactorial"));r=factorial(n);JOptionPane.showMessageDialog(null,"El factorial es. "+r);break;case 3:b=Integer.parseInt(JOptionPane.showInputDialog("Valor para la base"));n=Integer.parseInt(JOptionPane.showInputDialog("Valor para potencia"));
  7. 7. r=potencia(b,n); 7JOptionPane.showMessageDialog(null,"La potencia es: "+r);break;case 4: a=Integer.parseInt(JOptionPane.showInputDialog("Valor para dividendo")); b=Integer.parseInt(JOptionPane.showInputDialog("Valor para la divisor"));r=division(b,n);JOptionPane.showMessageDialog(null,"El resultado de la division es: "+r);break;case 5:JOptionPane.showMessageDialog(null,"Fin del programa"); }}while(e!=5); }; public static void main(String[] args) { // claseRecursivas obj1=new claseRecursivas(); claseRecursivas.menu(); }} RECURSIVIDAD RESUMENLa recursividad es una técnica de programación importante. Se utiliza para realizaruna llamada a una función desde la misma función.La recursividad consiste en realizar una definición de un concepto en términos delpropio concepto que se está definiendo.
  8. 8. La recursividad forma parte del repertorio para resolver problemas en 8Computación y es de los métodos más poderosos y usados.Los algoritmos recursivos ofrecen soluciones estructuradas, modulares yelegantemente simples.La recursividad es un concepto fundamental en matemáticas y en computación.Una definición recursiva dice cómo obtener conceptos nuevos empleando elmismo concepto que intenta describir.En toda situación en la cual la respuesta pueda ser expresada como unasecuencia de movimientos, pasos o transformaciones gobernadas por un conjuntode reglas no ambiguas, la fórmula recursiva es un buen candidado para resolver elproblema.Ejemplos: Los números naturales se pueden definir de la siguiente forma: 0 es un Número natural y el sucesor de un número natural es también un número natural. El factorial de un número natural n, es 1 si dicho número es 0, o n multiplicado por el factorial del número n-1, en caso contrario. La n-ésima potencia de un número x, es 1 si n es igual a 0, o el producto de x por la potencia (n-1)-ésima de x, cuando n es mayor que 0. Diseño de módulos recursivos. Módulo M con una llamada a sí mismo: módulo recursivo directo. Módulo M con una llamada a otro F, que hace una llamada a M: Módulo recursivo indirecto.Ejemplo: Implementación del factorial de un número.public long factorial (long n){if (n == 0) return 1;else return n * factorial(n-1);}Búsqueda de soluciones recursivas: cuatro preguntas básicas.¿Cómo se puede definir el problema en términos de uno o más problemas máspequeños del mismo tipo que el original?
  9. 9. ¿Qué instancias del problema harán de caso base? 9Conforme el problema se reduce de tamaño ¿se alcanzará el caso base?¿Cómo se usa la solución del caso base para construir una solución correcta alproblema original?Ejemplo: La pila del ordenador y la recursividad.La memoria de un ordenador a la hora de ejecutar un programa queda dividida endos partes:·la zona donde se almacena el código del programa y·la zona donde se guardan los datos: pila (utilizada para llamadas recursivas).Programa principal llama a una rutina M, se crea en la pila de un registro deactivación o entorno, E almacena constantes, variables locales y parámetrosformales. Estos registros se van apilando conforme se llama sucesivamente desdeuna función a otras.Cuando finaliza la ejecución, se va liberando el espacioProfundidad de la recursión: número de registros de activación en la pila en unmomento dado.
  10. 10. 10Problema:Si profundidad es muy grande => desbordamiento pila.Representación gráfica del registro de activación:Ejemplo de evolución de la pila: impresión de palabras en sentido contrario alleído.Función recursiva: imp_OrdenInverso.Parámetros: número de palabras que quedan por leer (n).Respuestas:1. Se lee la primera palabra, y recursivamente se llama a la función para que lea eimprima el resto de palabras, para que finalmente se imprima la primera leída.2. El caso base: cuando sólo quede una palabra (n== 1), en cuyo caso seimprimirá directamente.3. Como en cada llamada recursiva hay que leer una palabra menos del total, enn-1 llamadas se habrá alcanzado el caso base.4. Una vez se haya alcanzado el caso base al devolver continuamente el control alas funciones invocantes se irán imprimiendo de atrás a delante las palabrasobtenidas desde la entrada estándar.public void imp_OrdenInverso(int n){String palabra;if (n == 1){palabra =Console.in.readln();System.out.println(palabra);}else{palabra =Console.in.readln();imp_OrdenInverso(n-1);Las definiciones recursivas de funciones en matemáticas que tienen comoargumentos números enteros, se llaman relaciones de recurrencia.Forma de una ecuación de recurrencia: coar +c1ar-1 + c2ar-2 + ....+ ckar-k = f(r) funciónmatemática discreta donde ci son constantes, es llamada una ecuación derecurrencia de coeficientes constantes de orden k, condicionada a que c 0 y ck = 0.Una definición recursiva dice cómo obtener conceptos nuevos empleando elmismo concepto que intenta definir.
  11. 11. El poder de la recursividad es que los procedimientos o conceptos complejos 11pueden expresarse de una forma simple.Un razonamiento recursivo tiene dos partes: la base y la regla recursiva deconstrucción. La base no es recursiva y es el punto tanto de partida como determinación de la definición.Ejemplo:Base: La secuenciación, iteración condicional y selección son estructuras válidasde control que pueden ser consideradas como enunciados.Regla recursiva: Las estructuras de control que se pueden formar combinando demanera válida la secuenciación iteración condicional y selección también sonválidos.Un conjunto de objetos está definido recursivamente siempre que:(B) algunos elementos del conjunto se especifican explícitamente1. El procedimiento se llama a si mismo2. El problema se resuelve, resolviendo el mismo problema pero de tamaño menor3. La manera en la cual el tamaño del problema disminuye asegura que el casobase eventualmente se alcanzaráLa recursividad es un método poderoso usado en inteligencia artificial, su poder esque algunos conceptos complejos pueden expresarse en una forma simple. Unadefinición recursiva difiere de una definición circular en que tiene una forma deescapar de su expansión infinita. Este escape se encuentra en la definición oporción no recursiva o terminal de la definición.Las fórmulas recursivas pueden aplicarse a situaciones tales como prueba deteoremas, solución de problemas combinatorios, algunos acertijos, etc. Cuando una llamada recursiva es la última posición ejecutada del procedimientose llama recursividad de cola, recursividad de extremo final o recursión e extremode cola.Cuando un procedimiento incluye una llamada a si mismo se conoce comorecursión directa. Cuando un procedimiento llama a otro procedimiento y este causa que elprocedimiento original sea invocado, se conoce como recursión indirecta.Al principio algunas personas se sienten un poco incómodas con la recursividad,tal vez porque da la impresión de ser un ciclo infinito, pero en realidad es menospeligrosa una recursión infinita que un ciclo infinito, ya que una recursividad infinitapronto se queda sin espacio y termina el programa, mientras que la iteracióninfinita puede continuar mientras no se termine en forma manual.
  12. 12. Cuando un procedimiento recursivo se llama recursivamente a si mismo varias 12veces, para cada llamada se crean copias independientes de las variablesdeclaradas en el procedimiento. PROGRAMA CON MENÚ Y MÉTODOS RECURSIVOS Programa que llama a los métodos recursivospackage packRecursiones;import javax.swing.*;public class claseRecursivas {public static int a, b, n;claseRecursivas(){a=0; b=0; n=0;};public static int potencia(int b, int n) {if(n == 0) { //caso basereturn 1;} else {return b * potencia(b, n -1); // llamada recursiva}}public static int factorial(int n){if(n==0) return 1; //Caso baseelse return n*factorial(n-1); //Formula recursiva}
  13. 13. public static int fibonaci( int n){ 13if(n==1 || n==2) return 1;else return fibonaci(n-1)+fibonaci(n-2);}public static int division( int a, int b){if(b > a) {return 0;}else {return division(a-b, b) + 1;}}public static void menu(){String k="";int e=5, r=0;k+=" MENU DE OPERACIONESnn1) Fibonacin2) Factorialn3) potencian4)Division por restas sucesivasn5) SalirnnElige una opción";do{e=Integer.parseInt(JOptionPane.showInputDialog(k));switch(e){case 1:n=Integer.parseInt(JOptionPane.showInputDialog("Valor maximo para fibonaci"));r=fibonaci(n);JOptionPane.showMessageDialog(null,"Los numero fibonaci son: "+r);break;
  14. 14. case 2: 14n=Integer.parseInt(JOptionPane.showInputDialog("Valor para obtener elfactorial"));r=factorial(n);JOptionPane.showMessageDialog(null,"El factorial de "+n+"!="+r);break;case 3:b=Integer.parseInt(JOptionPane.showInputDialog("Valor para la base"));n=Integer.parseInt(JOptionPane.showInputDialog("Valor para potencia"));r=potencia(b,n);JOptionPane.showMessageDialog(null,"La potencia es: "+r);break;case 4:b=Integer.parseInt(JOptionPane.showInputDialog("Valor para dividendo"));n=Integer.parseInt(JOptionPane.showInputDialog("Valor para la divisor"));r=division(b,n);JOptionPane.showMessageDialog(null,"El resultado de la division es: "+r);break;case 5:JOptionPane.showMessageDialog(null,"Fin del programa... :)");}}while(e!=5);};public static void main(String[] args) {// claseRecursivas obj1=new claseRecursivas();claseRecursivas.menu();
  15. 15. } 15} PANTALLAS
  16. 16. 16ESTRUCTURAS LINEALES TRABAJO DE INVESTIGACION INTRODUCCIÓN
  17. 17. Las estructuras lineales son importantes porque aparecen con mucha frecuencia 17en situaciones de la vida: Una cola de clientes de un banco, las instrucciones deun programa, los caracteres de una cadena o las páginas de un libroCaracterísticas: existe un único elemento, llamado primero, existe un únicoelemento, llamado último, cada elemento, excepto el primero, tiene un únicopredecesor y cada elemento, excepto el último, tiene un único sucesor.Operaciones: crear la estructura vacía, insertar un elemento, borrar y obtener unelemento. Para definir claramente el comportamiento de la estructura es necesariodeterminar en qué posición se inserta un elemento nuevo y qué elemento se borrao se obtiene.Principales estructuras lineales: pilas, colas y listas. ESTRUCTURAS LINEALES Listas (estructura de datos)Una lista enlazada es una de las estructura de datos fundamentales, y puede ser
  18. 18. usada para implementar otras estructuras de datos. Consiste en una secuencia de 18nodos, en los que se guardan campos de datos arbitrarios y una o dos referencias(punteros) al nodo anterior y/o posterior. El principal beneficio de las listasenlazadas respecto a los array convencionales es que el orden de los elementosenlazados puede ser diferente al orden de almacenamiento en la memoria o eldisco, permitiendo que el orden de recorrido de la lista sea diferente al dealmacenamiento.Una lista enlazada es un tipo de dato auto-referenciado porque contienen unpuntero o link a otro dato del mismo tipo. Las listas enlazadas permiteninserciones y eliminación de nodos en cualquier punto de la lista en tiempoconstante (suponiendo que dicho punto está previamente identificado olocalizado), pero no permiten un acceso aleatorio. Existen diferentes tipos de listasenlazadas: Lista Enlazadas Simples, Listas Doblemente Enlazadas, ListasEnlazadas Circulares y Listas Enlazadas Doblemente Circulares.Lenguajes imperativos u orientados a objetos tales como C o C++ y Java,respectivamente, disponen de referencias para crear listas enlazadas. Operaciones básicas con listasEl alterador de lista es un objeto que permite recorrer los elementos de la lista yoperar con ellaDispone de un cursor que se sitúa entre dos elementos: previo ypróximoLas operaciones básicas de las listas son:• Constructor: Crea la lista vacía
  19. 19. • hazNula: Elimina todos los elementos de la lista, dejándolo vacía 19• estaVacia: Si la lista está vacía retorna true. En otro caso, retorna false• Tamaño: Retorna un entero que dice cuántos elementos hay en la lista• iteradorDeLista: Retorna un iterador de lista asociado a la lista, para poderrecorrer sus elementosOperaciones básicas de los iteradores de listaInicialmente el iterador de lista tiene el cursor situado antes del primer elementoLas operaciones básicas que se pueden hacer con un iterador de lista son: añade: Añade elElemento a la lista entre los elementos previo y próximo, si existen; si no existen, lo añade como el único elemento de la lista. El cursor queda situado justo después del nuevo elemento. Borra: borra el último elemento obtenido de la lista con previo() o proximo(). Si no hay tal elemento, lanza estadoIncorrecto. cambiaElemento: modifica el último elemento obtenido de la lista con previo() o proximo() sustituyéndolo por el nuevoElemento. Si no hay tal elemento, o si se ha llamado a borra () o añade() después de previo() o proximo(), lanza estadoIncorrecto. hayPrevio: Retorna true si existe un elemento previo al cursor y false en caso contrario. hayProximo: Retorna true si existe un elemento proximo al cursor y false en caso contrario.
  20. 20. Previo: Retorna el elemento previo al cursor, y hace que éste retroceda un 20 elemento en la lista. Si no existe elemento previo, lanza noExiste. Próximo: Retorna el elemento próximo al cursor, y hace que éste avance un elemento en la lista. Si no existe elemento próximo, lanza noExiste. Observar que si se llama a previo () después de llamar a proximo() se obtiene el mismo elemento.La interfaz List de Javapublic interface List<E> extends Collection<E>{// Positional accessE get(int index);E set(int index, E element); //optionalboolean add(E element); //optionalvoid add(int index, E element); //optionalE remove(int index); //optionalboolean addAll(int index,Collection<? extends E> c); //optional// Searchint indexOf(Object o);int lastIndexOf(Object o);// IterationListIterator<E> listIterator();ListIterator<E> listIterator(int index);// Range-viewList<E> subList(int from, int to);} Tipos de listas Listas simples enlazadas
  21. 21. 21La lista enlazada básica es la lista enlazada simple la cual tiene un enlace pornodo. Este enlace apunta al siguiente nodo en la lista, o al valor NULL o a la listavacía, si es el último nodo.Una lista enlazada simple contiene dos valores: el valor actual del nodo y unenlace al siguiente nodo Lista Doblemente EnlazadaUn tipo de lista enlazada más sofisticado es la lista doblemente enlazada o listaenlazadas de dos vías. Cada nodo tiene dos enlaces: uno apunta al nodo anterior,o apunta al valor NULL o a la lista vacía si es el primer nodo; y otro que apunta alsiguiente nodo siguiente, o apunta al valor NULL o a la lista vacía si es el últimonodo.Una lista doblemente enlazada contiene tres valores: el valor, el link al nodosiguiente, y el link al anteriorEn algún lenguaje de muy bajo nivel, XOR-Linking ofrece una vía paraimplementar listas doblemente enlazadas, usando una sola palabra para ambosenlaces, aunque el uso de esta técnica no se suele utilizar. Listas enlazadas circulares
  22. 22. 22En una lista enlazada circular, el primer y el último nodo están unidos juntos. Estose puede hacer tanto para listas enlazadas simples como para las doblementeenlazadas. Para recorrer un lista enlazada circular podemos empezar porcualquier nodo y seguir la lista en cualquier dirección hasta que se regrese hastael nodo original. Desde otro punto de vista, las listas enlazadas circulares puedenser vistas como listas sin comienzo ni fin. Este tipo de listas es el más usado paradirigir buffers para “ingerir” datos, y para visitar todos los nodos de una lista a partirde uno dado.Una lista enlazada circular que contiene tres valores enteros Listas enlazadas circulares simplesCada nodo tiene un enlace, similar al de las listas enlazadas simples, excepto queel siguiente nodo del último apunta al primero. Como en una lista enlazada simple,los nuevos nodos pueden ser solo eficientemente insertados después de uno queya tengamos referenciado. Por esta razón, es usual quedarse con una referenciasolamente al último elemento en una lista enlazada circular simple, esto nospermite rápidas inserciones al principio, y también permite accesos al primer nododesde el puntero del último nodo. Lista Enlazada Doblemente CircularEn una lista enlazada doblemente circular, cada nodo tiene dos enlaces, similares
  23. 23. a los de la lista doblemente enlazada, excepto que el enlace anterior del primer 23nodo apunta al último y el enlace siguiente del último nodo, apunta al primero.Como en una lista doblemente enlazada, las inserciones y eliminaciones puedenser hechas desde cualquier punto con acceso a algún nodo cercano. Aunqueestructuralmente una lista circular doblemente enlazada no tiene ni principio ni fin,un puntero de acceso externo puede establecer el nodo apuntado que está en lacabeza o al nodo cola, y así mantener el orden tan bien como en una listadoblemente enlazada. Aplicaciones de las listasLas listas enlazadas son usadas como módulos para otras muchas estructuras dedatos, tales como pilas, colas y sus variaciones.El campo de datos de un nodo puede ser otra lista enlazada. Mediante estemecanismo, podemos construir muchas estructuras de datos enlazadas con listas;esta practica tiene su origen en el lenguaje de programación Lisp, donde las listasenlazadas son una estructura de datos primaria (aunque no la única), y ahora esuna característica común en el estilo de programación funcional.A veces, las listas enlazadas son usadas para implementar arrays asociativos, yestas en el contexto de las llamadas listas asociativas. Hay pocas ventajas en esteuso de las listas enlazadas; hay mejores formas de implementar éstas estructuras,por ejemplo con árboles binarios de búsqueda equilibrados. Sin embargo, a vecesuna lista enlazada es dinámicamente creada fuera de un subconjunto propio denodos semejante a un árbol, y son usadas más eficientemente para recorrer éstaserie de datos. BIBLIOGRAFIACómo programar en Java - Página 978
  24. 24. Harvey M. Deitel, Paul J. Deitel, Guillermo Trujano Mendoza – 2004 24http://estdatosgrupo8a.blogspot.com/2009/03/estructuras-lineales.html PROGRAMA DE LISTAS
  25. 25. Subir el programa de listas armado con los métodos que están en 25la presentación. Program a::import javax.swing.JOptionPane;public class ListEnlaza{static ListEnlaza accion=new ListEnlaza();int n=Integer.parseInt(JOptionPane.showInputDialog("TAMAÑO"));public static void main(String[] args) {int opc=0;while(true){opc=Integer.parseInt(JOptionPane.showInputDialog(null,"__¿ACCION AREALIZAR?__nn"+"1. INCERTAR AL INICIOn"+"2. INCERTAR AL FINALn"+"3. BORRARAL FINAL n"+"4.BORRAR AL INICIO n"+"5. TAMAÑO DE LA LISTA n"+"6. DATOS DE LALISTA FINALn"+"7. DATOS DE LA LISTA INICIO n"+"8. SALIRn"));switch(opc){case 1: accion.Insercion();break;case 2: accion.addLast(100);break;case 3: accion.deleteLast();
  26. 26. break; 26case 4: accion.Eliminar();break;case 5: accion.tamano();break; case 6: accion.imprimir(); break; case 7: accion.Recorrido(); break; case 8: System.exit(0); break;default: JOptionPane.showMessageDialog(null,"OPCION INVALIDA","ERROR",JOptionPane.ERROR_MESSAGE);;break;}} }public class Nodo {Nodo nodoDer; int dato; public Nodo(int dato) { this.dato = dato; this.nodoDer = null; }}private Nodo primero; private Nodo ultimo; private int tamano;
  27. 27. public ListEnlaza() { 27 this.primero = null; this.ultimo = null; this.tamano = 0; }//Metodo utilizado para denotar que la lista se encuentra vacia. public boolean siVacio() { return (this.primero == null); }//Metodo para agregar al inicioString LIS[]=new String [n]; int Final=-1; int Frente=0; int Max=LIS.length-1; public void Insercion()throws ArrayIndexOutOfBoundsException{ if(Final==Max){ JOptionPane.showMessageDialog(null,"¡DESBORDAMIENTO, LLENA!","ERROR", JOptionPane.ERROR_MESSAGE);; } else { Frente=-1; Final++;
  28. 28. LIS[Final]=JOptionPane.showInputDialog(null,"INSERTA UN DATO:"); 28 JOptionPane.showMessageDialog(null,"SE INSERTO EL DATO ("+LIS[Final]+" )"); } }public void Eliminar()throws ArrayIndexOutOfBoundsException{ if(Final==-1) JOptionPane.showMessageDialog(null,"¡VACIA","ERROR!", JOptionPane.ERROR_MESSAGE); else{ JOptionPane.showMessageDialog(null, "¡DATO ("+LIS[ 0 ]+")ELIMINADO!"); for (int i=0; i<Final-1; i++) LIS[ i ] = LIS[ i+1 ]; Final--;}} public void Recorrido()throws ArrayIndexOutOfBoundsException{ if(Final==-1){ JOptionPane.showMessageDialog(null,"COLA VACIA","ERROR", JOptionPane.ERROR_MESSAGE); } else{ String Recorrido= ""; Recorrido+= "n ELEMENTOS EN COLA:"; for(int i=0; i<=Final; i++) Recorrido+= "nLISTA["+i+"] = "+LIS[i];
  29. 29. JOptionPane.showMessageDialog(null, Recorrido); 29 } }//Metodo para agregar al final de la lista. public ListEnlaza addLast(int dato) { dato=Integer.parseInt(JOptionPane.showInputDialog("Ingresa un 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; ultimo = nuevo; } this.tamano++; return this; }//Metodo para borrar al final de la lista. public Nodo deleteLast() { Nodo eliminar = null;
  30. 30. if(siVacio()) { 30 JOptionPane.showMessageDialog(null,"LA LISTA SE ENCUENTRAVACIA","ERROR", JOptionPane.ERROR_MESSAGE); return null; } if(primero == ultimo) { primero = null; ultimo = null; } else { Nodo actual = primero; while(actual.nodoDer != ultimo) { actual = actual.nodoDer; } eliminar = actual.nodoDer; actual.nodoDer = null; ultimo = actual; } JOptionPane.showMessageDialog(null,"SE ELIMINO EL DATO DE LA POSICION ("+tamano+" )"); this.tamano--; return eliminar; }
  31. 31. //Metodo que imprime el tamaño de la lista. 31 public void tamano() { JOptionPane.showMessageDialog(null, "El tamaño es:n " + this.tamano); }//Metodo que imprime la lista y los valores ingresados. public Nodo imprimir() { Nodo imprimir = null; if(siVacio()) { JOptionPane.showMessageDialog(null,"LA LISTA SE ENCUENTRAVACIA","ERROR", JOptionPane.ERROR_MESSAGE); return null; } if(tamano != 0) { Nodo temp = primero; String str = ""; for(int i = 0; i < this.tamano; i++) { str = str + temp.dato + "n"; temp = temp.nodoDer; } JOptionPane.showMessageDialog(null, "Lista:n" + str); } return imprimir; }
  32. 32. } 32 Pantall as:Hacer un programa que utilice las
  33. 33. operaciones sobre las pilas o colas (push, pop y recorrido). 33import javax.swing.*;public class Colas { static Cola accion=new Cola(); public static void main(String[] args) { int opc=0; while(true){ opc=Integer.parseInt(JOptionPane.showInputDialog(null,"__¿ACCION AREALIZAR?__nn" +"1. INSERCIÓNn"+"2. RECORRIDOn"+"3. BUSCARn"+"4.ELIMINAR n"+"5. SALIRn")); switch(opc){ case 1: accion.Insercion(); break; case 2: accion.Recorrido(); break; case 3: accion.Buscar(); break; case 4: accion.Eliminar(); break; case 5: System.exit(0); break; default: JOptionPane.showMessageDialog(null,"OPCIONINVALIDA","ERROR", JOptionPane.ERROR_MESSAGE);; break;
  34. 34. } 34 } }}class Cola{ int n=Integer.parseInt(JOptionPane.showInputDialog("INTRODUCE ELTAMAÑO DE LA COLA")); String cola[]=new String [n]; int Final=-1; int Frente=0; int Max=cola.length-1; public void Insercion()throws ArrayIndexOutOfBoundsException{ if(Final==Max){ JOptionPane.showMessageDialog(null,"¡DESBORDAMIENTO, COLALLENA!","ERROR", JOptionPane.ERROR_MESSAGE);; } else { Frente=-1; Final++; cola[Final]=JOptionPane.showInputDialog(null,"INSERTA UN DATO:"); JOptionPane.showMessageDialog(null,"SE INSERTO ELDATO ( "+cola[Final]+" )"); } } public void Recorrido()throws ArrayIndexOutOfBoundsException{
  35. 35. if(Final==-1){ 35 JOptionPane.showMessageDialog(null,"COLA VACIA","ERROR", JOptionPane.ERROR_MESSAGE); } else{ String Recorrido= ""; Recorrido+= "n ELEMENTOS EN COLA:"; for(int i=0; i<=Final; i++) Recorrido+= "ncola["+i+"] = "+cola[i]; JOptionPane.showMessageDialog(null,Recorrido); } } public void Buscar()throws ArrayIndexOutOfBoundsException{ int ban=0; String encontrado=""; String elemento=JOptionPane.showInputDialog(null,"¿QUE DATOBUSCAS?"); for(int i=0;i<=Final;i++){ if(elemento.equals(cola[i])){ encontrado=encontrado+cola[i]; ban=ban+1; } } if(ban==0){
  36. 36. JOptionPane.showMessageDialog(null,"DATO ("+elemento+") 36NO ENCONTRADO ","ERROR", JOptionPane.ERROR_MESSAGE); } else{ JOptionPane.showMessageDialog(null, ""+ban+" DATOENCONTRADO= ( "+elemento+" )"); }}public void Eliminar()throws ArrayIndexOutOfBoundsException{ if(Final==-1) JOptionPane.showMessageDialog(null,"¡COLA VACIA","ERROR!", JOptionPane.ERROR_MESSAGE); else{ JOptionPane.showMessageDialog(null, "¡DATO ("+cola[ 0 ]+")ELIMINADO!"); for (int i=0; i<Final-1; i++) cola[ i ] = cola[ i+1 ]; Final--; } }} Programa de pila personalizado
  37. 37. 37mport 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; } else { nuevo. sig=raiz;
  38. 38. raiz=nuevo; 38 } } public int extraer () { if(raiz!=null) { int informacion=raiz. info; raiz = raiz. sig; return informacion; } 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+"-"); reco=reco.sig; }
  39. 39. System.out.println(); 39 } public static void main (String[] ar) { Pila2 pila1=new Pila2(); int op=4,dato; do { String menu ="nn menu de opcionesnn1)Insertarn2)Eliminarn3)Listan4)SalirnnElije 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 datoeliminado es:"+dato); break; case 3:pila1.imprimir(); break; case 4:JOptionPane.showMessageDialog(null,"Fin delprograma"); } }
  40. 40. while(op!=4) 40}}Hacer un programa que manipule una cola. Debe tener los métodos parainsertar, eliminar y recorrer la cola en una lista enlazada.ColasLas colas son una subclase de las listas lineales que siguen elorden FIFO (First Input First Output - Primero en entrar Primero ensalir). Este orden es que siguen las filas que hacemos en la vidacotidiana al ir al banco, las tortillas, etc. En las colas la inserciónse hace al final y la eliminación se hace al frente, por lo que sehace necesario el uso de una variable Primero y otra variableÚltimo por medio de las cuales se llevaran a cabo las operaciones.Import javax.swing.*;public class colas1 { static cola accion=new cola(); public static void main(string[] args) { int opc=0; while(true){ opc=integer.parseint(joptionpane.showinputdialog(null,"__¿accion arealizar?__nn" +"1. Insertarn"+"2. Recorrern"+"3. Eliminar n"+"4. Salirn")); switch(opc){
  41. 41. case 1: accion.insercion(); 41 break; case 2: accion.recorrido(); break; case 4: accion.eliminar(); break; case 5: system.exit(0); break; default: joptionpane.showmessagedialog(null,"opcioninvalida","error", joptionpane.error_message);; break; } } }}Class cola{ int n=integer.parseint(joptionpane.showinputdialog("introduce el tamaño dela cola")); string cola[]=new string [n]; int final=-1; int frente=0; int max=cola.length-1; public void insercion()throws arrayindexoutofboundsexception{
  42. 42. if(final==max){ 42 joptionpane.showmessagedialog(null,"¡desbordamiento, cola llena!","error", joptionpane.error_message);; } else { frente=-1; final++; cola[final]=joptionpane.showinputdialog(null,"inserta un dato:"); joptionpane.showmessagedialog(null,"se inserto el dato ("+cola[final]+" )"); } } public void recorrido()throws arrayindexoutofboundsexception{ if(final==-1){ joptionpane.showmessagedialog(null,"cola vacia","error", joptionpane.error_message); } else{ string recorrido= ""; recorrido+= "n elementos en cola:"; for(int i=0; i<=final; i++) recorrido+= "ncola["+i+"] = "+cola[i]; joptionpane.showmessagedialog(null, recorrido); } }
  43. 43. Public void eliminar()throws arrayindexoutofboundsexception{ 43 if(final==-1) joptionpane.showmessagedialog(null,"¡cola vacia","error!", joptionpane.error_message); else{ joptionpane.showmessagedialog(null, "¡dato ("+cola[ 0 ]+")eliminado!"); for (int i=0; i<final-1; i++) cola[ i ] = cola[ i+1 ]; final--; } }}
  44. 44. ESTRUCTURAS NO LINEALES 44Arboles Concepto de arbolesUn árbol se define como una colección de nodos organizados en forma recursiva.Cuando hay 0 nodos se dice que el árbol está vacío, en caso contrario el árbolconsiste en un nodo denominado raíz, el cual tiene 0 o más referencias a otrosárboles, conocidos como subárboles. Las raíces de los subárboles se denominanhijos de la raíz, y consecuentemente la raíz se denomina padre de las raíces desus subárboles. Una visión gráfica de esta definición recursiva se muestra en lasiguiente figura:Los nodos que no poseen hijos se denominan hojas. Dos nodos que tienen elpadre en común se denominan hermanos.Un camino entre un nodo n1 y un nodo nk está definido como la secuencia denodos n1, n2,..., nk tal que ni es padre de ni+1, 1 <= i < k. El largo del camino es elnúmero de referencias que componen el camino, que para el ejemplo son k-1.Existe un camino desde cada nodo del árbol a sí mismo y es de largo 0. Nóteseque en un árbol existe un único camino desde la raíz hasta cualquier otro nodo delárbol. A partir del concepto de camino se definen los conceptos de ancestro ydescendiente: un nodo n es ancestro de un nodo m si existe un camino desde n am; un nodo n es descendiente de un nodo m si existe un camino desde m a n.Se define la profundidad del nodo nk como el largo del camino entre la raíz delarbol y el nodo nk. Esto implica que la profundidad de la raíz es siempre 0. Laaltura de un nodo nk es el máximo largo de camino desde nk hasta alguna hoja.Esto implica que la altura de toda hoja es 0. La altura de un árbol es igual a laaltura de la raíz, y tiene el mismo valor que la profundidad de la hoja másprofunda. La altura de un árbol vacío se define como -1.La siguiente figura muestra un ejemplo de los conceptos previamente descritos:
  45. 45. 45 A es la raíz del árbol. A es padre de B, C y D. E y F son hermanos, puesto que ambos son hijos de B. E, J, K, L, C, P, Q, H, N y O son las hojas del árbol. El camino desde A a J es único, lo conforman los nodos A-B-F-J y es de largo 3. D es ancestro de P, y por lo tanto P es descendiente de D. L no es descendiente de C, puesto que no existe un camino desde C a L. La profundidad de C es 1, de F es 2 y de Q es 4. La altura de C es 0, de F es 1 y de D es 3. La altura del árbol es 4 (largo del camino entre la raíz A y la hoja más profunda, P o Q). Clasificación de árboles binarios:1.-arbol binario distinto: Se dice que un árbol es distinto cuando su estructuragrafica es diferente.2.-arbol binario similar.- Se dice que un árbol es similar cuando su estructuragrafica es idéntica pero la información que contiene entre sus nodos es diferente.3.-arbol binario equivalente.-Son aquellos que su estructura grafica es idénticapero además la información entre sus nodos.4.-arbol binario completo.-son aquellos que todos nus nodos excepto el últimonivel tienen sus dos hijos.5.-arbol binario lleno: Es aquel que tiene su número máximo de posibles nodos.Operaciones básicas sobre arboles binariosÁrboles binarios
  46. 46. Un árbol binario es un árbol en donde cada nodo posee 2 referencias a subárboles 46(ni más, ni menos). En general, dichas referencias se denominan izquierda yderecha, y consecuentemente se define el subárbol izquierdo y subárbol derechodel arbol.Como en toda estructura de datos hay dos operaciones básicas, inserción yeliminación.InserciónEl procedimiento de inserción en un árbol binario de búsqueda es muy sencillo,únicamente hay que tener cuidado de no romper la estructura ni el orden del árbol.Cuando se inserta un nuevo nodo en el árbol hay que tener en cuenta que cadanodo no puede tener más de dos hijos, por esta razón si un nodo ya tiene 2 hijos,el nuevo nodo nunca se podrá insertar como su hijo. Con esta restricción nosaseguramos mantener la estructura del árbol, pero aún nos falta mantener elorden.Para localizar el lugar adecuado del árbol donde insertar el nuevo nodo se realizancomparaciones entre los nodos del árbol y el elemento a insertar. El primer nodoque se compara es la raíz, si el nuevo nodo es menor que la raíz, la búsquedaprosigue por el nodo izquierdo de éste. Si el nuevo nodo fuese mayor, la búsquedaseguiría por el hijo derecho de la raíz.Este procedimiento es recursivo, y su condición de parada es llegar a un nodo queno tenga hijo en la rama por la que la búsqueda debería seguir. En este caso elnuevo nodo se inserta en ese hueco, como su nuevo hijo.Vamos a verlo con un ejemplo sobre el siguiente árbol:
  47. 47. 47Se quiere insertar el elemento 6.Lo primero es comparar el nuevo elemento con la raíz. Como 6 > 4, entonces labúsqueda prosigue por el lado derecho. Ahora el nuevo nodo se compara con elelemento 8. En este caso 6 < 8, por lo que hay que continuar la búsqueda por larama izquierda. Como la rama izquierda de 8 no tiene ningún nodo, se cumple lacondición de parada de la recursividad y se inserta en ese lugar el nuevo nodo.BorrarEl borrado en árboles binarios de búsqueda es otra operación bastante sencillaexcepto en un caso. Vamos a ir estudiando los distintos casos.Tras realizar la búsqueda del nodo a eliminar observamos que el nodo no tienehijos. Este es el caso más sencillo, únicamente habrá que borrar el elemento y yahabremos concuído la operación.Si tras realizar la búsqueda nos encontramos con que tiene un sólo hijo. Este casotambién es sencillo, para borrar el nodo deseado, hacemos una especie depuente, el padre del nodo a borrar pasa a apuntar al hijo del nodo borrado.
  48. 48. 48Por último, el caso más complejo, si el nodo a borrar tiene dos hijos. En este casose debe sustitui el nodo a borrar por mayor de los nomdos menores del nodoborrado, o por el menor de los nodos mayores de dicho nodo. Una vez realizadaesta sustitución se borrra el nodo que sustituyó al nodo eliminado (operaciónsencilla ya que este nodo tendrá un hijo a lo sumo).Sobre el siguiente árbol queremos eliminar el elemento 6. Tenemos dos opcionespara sustituirlo: El menor de sus mayores: 7. El mayor de sus menores: 4.Vamos a sustituirlo por el 7 (por ejemplo). El árbol resultante sería el siguiente,tras eliminar también el elemento 7 de su ubicación original.
  49. 49. 49Otras operacionesEn los árboles de búsqueda la operación buscar es muy eficiente. El algoritmocompara el elemento a buscar con la raíz, si es menor continua la búsqueda por larama izquierda, si es mayor continua por la izquierda. Este procedimiento serealiza recursivamente hasta que se encuentra el nodo o hasta que se llega al finaldel árbol.Otra operación importante en el árbol es el recorridod el mismo. El recorrido sepuede realizar de tres formas diferentes: Preorden: Primero el nodo raíz, luego el subárbol izquierdo y a continuación el subárbol derecho. Inorden: Primero el subárbol izquierdo, luego la raíz y a continuación el subárbol derecho. Postorden: Primero el subárbol izquierdo, luego el subárbol derecho y a continuación la raíz. Aplicaciones:Aplicaciones de árboles binariosUn árbol binario es una estructura de datos útil cuando se trata de hacer modelosde procesos en donde se requiere tomar decisiones en uno de dos sentidos encada parte del proceso. Por ejemplo, supongamos que tenemos un arreglo endonde queremos encontrar todos los duplicados. Esta situación es bastante útil enel manejo de las bases de datos, para evitar un problema que se llamaredundancia.
  50. 50. Una manera de encontrar los elementos duplicados en un arreglo es recorrer todo 50el arreglo y comparar con cada uno de los elementos del arreglo. Esto implica quesi el arreglo tiene elementos, se deben hacer comparaciones, claro, no esmucho problema si es un número pequeño, pero el problema se vacomplicando más a medida que aumenta.Si usamos un árbol binario, el número de comparaciones se reduce bastante,veamos cómo.El primer número del arreglo se coloca en la raíz del árbol (como en este ejemplosiempre vamos a trabajar con árboles binarios, simplemente diremos árbol, parareferirnos a un árbol binario) con sus subárboles izquierdo y derecho vacíos.Luego, cada elemento del arreglo se compara son la información del nodo raíz yse crean los nuevos hijos con el siguiente criterio: Si el elemento del arreglo es igual que la información del nodo raíz, entonces notificar duplicidad. Si el elemento del arreglo es menor que la información del nodo raíz, entonces se crea un hijo izquierdo. Si el elemento del arreglo es mayor que la información del nodo raíz, entonces se crea un hijo derecho.Una vez que ya está creado el árbol, se pueden buscar los elementos repetidos.Si x el elemento buscado, se debe recorrer el árbol del siguiente modo:Sea k la información del nodo actual p. Si entonces cambiar el nodo actuala right(p), en caso contrario, en caso de que informar una ocurrenciaduplicada y en caso de que cambiar el nodo actual a left(p).El siguiente algoritmoleer numero buscado >> ntree=makeTree(n)while(hay numeros en el arreglo){ leeSiguienteNumero >> k p=q=tree; while(k!=info(p)&&q!=NULL){ p=q if(k<info(p)) q=left(p) else q=right(p) } if(k==info(p))
  51. 51. despliega<<" el numero es duplicado"; 51 else if (k<info(p)) setLeft(p,k) else setRight(p,k)} Figura 28: Árbol binario para encontrar números duplicadosPara saber el contenido de todos los nodos en un árbol es necesario recorrer elárbol. Esto es debido a que solo tenemos conocimiento del contenido de ladirección de un nodo a la vez. Al recorrer el árbol es necesario tener la direcciónde cada nodo, no necesariamente todos al mismo tiempo, de hecho normalmentese tiene la dirección de uno o dos nodos a la vez; de manera que cuando se tienela dirección de un nodo, se dice que se visita ese nodo.Aunque hay un orden preestablecido (la enumeración de los nodos) no siempre esbueno recorrer el árbol en ese orden, porque el manejo de los apuntadores sevuelve más complejo. En su lugar se han adoptado tres criterios principales pararecorrer un árbol binario, sin que de omita cualquier otro criterio diferente.Los tres criterios principales para recorrer un árbol binario y visitar todos susnodos son, recorrer el árbol en:preorden: Se ejecutan las operaciones: 1. Visitar la raíz 2. recorrer el subárbol izquierdo en preorden 3. recorrer el subárbol derecho en preordenentreorden: Se ejecutan las operaciones: 1. recorrer el subárbol izquierdo en entreorden 2. Visitar la raíz
  52. 52. 3. recorrer el subárbol derecho en entreorden 52postorden: Se ejecutan las operaciones: 1. recorrer el subárbol izquierdo en postorden 2. recorrer el subárbol derecho en postorden 3. Visitar la raízAl considerar el árbol binario que se muestra en la figura 28 usando cada uno delos tres criterios para recorrer el árbol se tienen las siguientes secuencias denodos:En preorden:En entreorden:En postorden:Esto nos lleva a pensar en otra aplicación, el ordenamiento de los elementos deun arreglo.Para ordenar los elementos de un arreglo en sentido ascendente, se debeconstruir un árbol similar al árbol binario de búsqueda, pero sin omitir lascoincidencias.El arreglo usado para crear el árbol binario de búsqueda fue<14,15,4,9,7,18,3,5,16,4,20,17,9,14,5>El árbol de ordenamiento es el que se muestra en la figura 29
  53. 53. Figura 29: Árbol binario para ordenar una secuencia de números 53 Arboles balanceados (avl)Un árbol AVL (llamado así por las iniciales de sus inventores: Adelson-Velskii yLandis) es un árbol binario de búsqueda en el que para cada nodo, las alturas desus subárboles izquierdo y derecho no difieren en más de 1.No se trata de árboles perfectamente equilibrados, pero sí son lo suficientementeequilibrados como para que su comportamiento sea lo bastante bueno como parausarlos donde los ABB no garantizan tiempos de búsqueda óptimos.El algoritmo para mantener un árbol AVL equilibrado se basa en reequilibradoslocales, de modo que no es necesario explorar todo el árbol después de cadainserción o borrado.Operaciones en AVLLos AVL son también ABB, de modo que mantienen todas las operaciones queposeen éstos. Las nuevas operaciones son las de equilibrar el árbol, pero eso sehace como parte de las operaciones de insertado y borrado.Factor de equilibrioCada nodo, además de la información que se pretende almacenar, debe tener losdos punteros a los árboles derecho e izquierdo, igual que los ABB, y además unmiembro nuevo: el factor de equilibrio.El factor de equilibrio es la diferencia entre las alturas del árbol derecho y elizquierdo:FE = altura subárbol derecho - altura subárbol izquierdo;Por definición, para un árbol AVL, este valor debe ser -1, 0 ó 1.Rotación simple a la derecha (SD)Esta rotación se usará cuando el subárbol izquierdo de un nodo sea 2 unidadesmás alto que el derecho, es decir, cuando su FE sea de -2. Y además, la raíz delsubárbol izquierdo tenga una FE de -1 ó 0, es decir, que esté cargado a laizquierda o equilibrado.
  54. 54. Grafos: 54GrafosDesafortunadamente no existe una terminología estandarizada en la teoría de losgrafos, por lo tanto es oportuno aclarar que las presentes definiciones puedenvariar ligeramente entre diferentes publicaciones de estructura de datos y de teoríade grafos, pero en general se puede decir que un grafo como indica su nombre loindica es la representación (para nuestro caso) gráfica de los datos de unasituación particular, ejemplo: Los datos contienen, en algunos casos, relaciones entre ellos que no esnecesariamente jerárquica. Por ejemplo, supongamos que unas líneas aéreasrealizan vuelos entre las ciudades conectadas por líneas como se ve en la figuraanterior (más adelante se presentaran grafos con estructuras de datos); laestructura de datos que refleja esta relación recibe el nombre de grafo.Se suelen usar muchos nombres al referirnos a los elementos de una estructurade datos. Algunos de ellos son "elemento", "ítem", "asociación de ítems","registro", "nodo" y "objeto". El nombre que se utiliza depende del tipo deestructura, el contexto en que usamos esa estructura y quien la utiliza.En la mayoría de los textos de estructura de datos se utiliza el termino "registro" alhacer referencia a archivos y "nodo" cuando se usan listas enlazadas, árboles ygrafos.También un grafo es una terna G = (V,A,j ), en donde V y A son conjuntos finitos, yj es una aplicación que hace corresponder a cada elemento de A un par deelementos de V. Los elementos de V y de A se llaman, respectivamente, "vértices"y "aristas" de G, y j asocia entonces a cada arista con sus dos vértices.Esta definición da lugar a una representación gráfica, en donde cada vértice es unpunto del plano, y cada arista es una línea que une a sus dos vértices.AristasSon las líneas con las que se unen las aristas de un grafo y con la que seconstruyen también caminos.Si la arista carece de dirección se denota indistintamente {a, b} o {b, a}, siendo a yb los vértices que une.Si {a ,b} es una arista, a los vértices a y b se les llama sus extremos. Aristas Adyacentes: Se dice que dos aristas son adyacentes si convergen en el mismo vértice.
  55. 55. 55 Aristas Paralelas: Se dice que dos aristas son paralelas si vértice inicial y el final son el mismo. Aristas Cíclicas: Arista que parte de un vértice para entrar en el mismo. Cruce: Son dos aristas que cruzan en un punto.VérticesSon los puntos o nodos con los que esta conformado un grafo. Llamaremos gradode un vértice al número de aristas de las que es extremo. Se dice que un vérticees `par o `impar según lo sea su grado. Vértices Adyacentes: si tenemos un par de vértices de un grafo (U, V) y si tenemos un arista que los une, entonces U y V son vértices adyacentes y se dice que U es el vértice inicial y V el vértice adyacente. Vértice Aislado: Es un vértice de grado cero. Vértice Terminal: Es un vértice de grado 1.CaminosSean x, y " V, se dice que hay un camino en G de x a y si existe una sucesiónfinita no vacía de aristas {x,v1}, {v1,v2},..., {vn,y}. En este caso x e y se llaman los extremos del camino El número de aristas del camino se llama la longitud del camino. Si los vértices no se repiten el camino se dice propio o simple. Si hay un camino no simple entre 2 vértices, también habrá un camino simple entre ellos. Cuando los dos extremos de un camino son iguales, el camino se llama circuito o camino cerrado.
  56. 56. Llamaremos ciclo a un circuito simple 56 Un vértice a se dice accesible desde el vértice b si existe un camino entre ellos. Todo vértice es accesible respecto a si mismo Terminología delos grafosUn grafo está formado por un conjunto de nodos(o vértices) y un conjunto dearcos. Cada arco en un grafo se especifica por un par de nodos.El conjunto de nodos es {A, B, C, D, F, G, H} y el conjunto de arcos {(A, B), (A, D),(A,C), (C, D), (C, F), (E, G), (A, A)} para el siguiente grafo Operaciones básicas sobre grafosSuponga que un grafo G se mantiene en memoria mediante la representaciónenlazadaGRAFO (NODO, SIG, ADY, PRINCIPIO, NDISP, ENL, ADISP)Discutida en la sección anterior. Esta sección discute las operaciones, debúsqueda inserción y eliminación de nodos y aristas en el grafo G. La operaciónde recorrido se trata en la siguiente sección.ProcedimientoBusca(INFO, ENL, PRINCIPIO, ITEM, POS) [Algoritmo 5.2]
  57. 57. Busca la posición POS del primer nodo que contiene a ITEM, o hace 57POS : = NULO.1.-Hacer PTR : =PRINCIPIO.2.-Repetir mientras PTR sea diferente de NULO:Si ITEM = INFO[PTR], entonces; Hacer POS := PTR yVolver.Si no hacer PTR : = ENL [PTR].[Fin del Bucle].3.-Hacer POS : = NULO y volver.Diferente que en el capítulo 5. Por supuesto, si se usan listas enlazadas circularesa árboles binarios de búsqueda en vez de listas enlazadas, se deben de usar losprocedimientos análogos.BÚSQUEDA EN UN GRAFOSuponga que queremos encontrar la posición POS de un nodo N de un grafo C .Esto sepuede llevar a cabo mediante el Procedimiento 8.3, tal como sigue:Llamar BUSCA (NODO, SIG, PRINCIPIO, N, POS)O sea, que esta sentencia de llamada busca en la lista NODO el nodo N.Procedimiento 8.4 ELIMINAR (INFO, ENL, PRINCIPIO, DISP, ITEM, INDIC)[Algoritmo 5.10]Elimina el primer nodo de la lista que contenga a ITEM, o haceINDIC:=FALSO si ITEM no aparece en la lista.1.-[¿Lista vacia?] Si PRINCIPIO = NULO, entonces: HacerINDIC : = FALSO y volver .2.-[¿ITEM en primer nodo?] Si INFO [PRINCIPIO] = ITEM,Entonces: Hacer PTR : = PRINCIPIO,PRINCIPIO: =ENL[PRINCIPIO],ENL[PTR]: = DISP, DISP : = PTR,INDIC : = VERDADERO y volver.[Fin del condicional].
  58. 58. 3.-Hacer PTR : = ENL[PRINCIPIO] y SALVA : = PRINCIPIO. 58[Inicializar punteros].4.-Repetir pasos 5 y 6 mientras PTR sea diferente a NULO:5.- Si INFO [PTR] = ITEM entonces:Hacer ENL [SALVA]: = ENL[PTR],ENL[PTR]: = DISP, DISP: = PTR,INDIC: =VERDADERO y volver.[Fin de la condicional].6.- Hacer SALVA := PTR y PTR := ENL [PTR].[Actualizar punteros].[Fin Bucle del paso 4].7.- Hacer INDIC : = FALSO y Volver.INSERCIÓN EN UN GRAFOSuponga que se va a insertar un nodo N en el grafo G. Observe que N seráasignado aNODO [NDISP], el primer nodo disponible. Mas aún, como N será un nodoaislado, se debe hacer ADY[NDISP]: = NULO. El procedimiento 8.6 hace estomediante una variable lógica INDIC que indica si hay desbordamiento.Por supuesto, el Procedimiento 8.6 debe ser modificado si la lista NODO semantiene como una lista ordenada o como un árbol binario de búsqueda.Procedimiento INSNODO(NODO, SIG, ADY, PRINCIPIO, NDISP, N, INDIC)Este procedimiento inserta el nodo N en le grafo G.1.-[¿DESBORDAMIENTO?] Si NDISP= NULO, entonces: HacerINDIC := FALSO y volver.2.- Hacer ADY[NDISP] : = NULO.3.-[Quitar el nodo de la lista NDISP].Hacer NUEVO: =NDISP y NDISP :=SIG[NDISP].4.-[Insertar nodo N en la lista NODO].Hacer NODO[NUEVO] : = N, SIG[NUEVO] :=PRINCIPIO y
  59. 59. PRINCIPIO : = NUEVO. 595.-Hacer INDIC := VERDADERO y Volver.ELIMINACIÓN DE UN ARCO EN UN GRAFOSuponga que se va a eliminar una arista (A, B) del grafo G. (Nuestroprocedimiento asumirá que A y B son nodos de G). De nuevo debemos encontrarprimero la posiciónPOSA de A y la posición POSB de B en la lista de nodos. Entonces simplementeeliminamos POSB de la lista de sucesores de A, que tiene el puntero de la listaADY[POSA].Se usa una variable INDIC lógica para indicar si no existe tal arista enel grafo G. El procedimiento es el siguiente:Procedimiento 8.8 ELIMARISTA(NODO, SIG, ADY, PRINCIPIO, DEST, ENL,ADISP, A, B, INDIC).Este procedimiento elimina la arista (A, B) del grafo G .1.-Llamar BUSCA(NODO, SIG, PRINCIPIO, A, POSA)[LocalizarNodo A].2.- Llamar BUSCA(NODO, SIG, PRINCIPIO, B, POSB) [LocalizarNodo B].3.-Llamar ELIMINAR (DEST, ENL, ADY[POSA], ADISP, POSB,INDIC).[Usar el procedimiento 8.4].4.-Volver.
  60. 60. BIBLIOGRAFIA 60Técnicas de Diseño de Algoritmos en Java-Escrito por Sonia JaramilloValbuena,Sonia Jaramillo Valbuena, Sergio Augusto Cardona Torres, Maria LiliVillegas Ramirez Página 162Estructuras de datos y algoritmos con Java-Escrito por Adam Drozdek Página261Introducción a las Estructuras de datos en Java- Escrito por Sonia JaramilloValbuena,Sonia Jaramillo Valbuena, Sergio Augusto Cardona Torres, DumarAntonio Villa Zapata Página 209
  61. 61. Hacer un programa que manipule una lista o una pila o una cola 61 pero que se vea la animación de la operación realizadapackage Clases;import java.awt.*;import javax.swing.JPanel;public class PanelDibujo extends JPanel {public int x=20;public int y=100;public pila Pila;public boolean swborrar=false;public PanelDibujo(pila p){Pila=p;}public void paintComponent(Graphics g){super.paintComponents(g);Graphics2D g2d=(Graphics2D)g;g2d.setColor(Color.WHITE);g2d.fillRect(0,0,400,200);
  62. 62. g2d.setColor(Color.BLACK); 62g2d.setStroke(new BasicStroke(2));for(int i=0;i<Pila.getNodos().size();i++){if(i!=0){g2d.drawLine(2*x*(i+1)-10, y+15, 2*x*(i+1), y+15);}g2d.drawRoundRect(2*x*(i+1), y, 30, 30, 10, 10);g2d.drawString(""+Pila.getNodos().get(i), 2*x*(i+1)+12, y+20);}if(swborrar){g2d.setColor(Color.WHITE);g2d.fillRect(0,0,400,200);Pila.resetear(true);swborrar=false;}}public boolean isSwborrar() {return swborrar;}public void setSwborrar(boolean swborrar) {
  63. 63. this.swborrar = swborrar; 63}public static void main(String[] args) { }}
  64. 64. MÉTODOS DE ORDENAMIENTO 64Ordenamiento por burbujapackage BurbujaPaq;public class Burbujamilenteros { public static void main(String[] args) { int x[]= new int [100]; int i,j, aux; System.out.println("---------NUMEROS GENERADOS-------"); for (i=0; i<x.length; i++) { x[i]=(int)(Math.random()*1000); System.out.println(x[i] + " | "); } System.out.println(""); System.out.println("---------NUMEROS ORDENADOS-------"); for (i=0; i<x.length; i++) { for (j=0; j<x.length-1; j++) { if (x[j] > x[j+1]){ aux=x[j]; x[j]=x[j+1]; x[j+1]=aux; } } }for (i=0; i<x.length; i++) { System.out.println(x[i] + " | "); } }}Hacer un programa en Java que muestre el siguiente menú:1. Burbuja2. Shell3. Quicksort4. Radix
  65. 65. Para cada opción se ordenaran primero 500 elementos y se le 65toma el tiempo, luego 1000 y se le toma el tiempo y por último2000 elementos y se le toma el tiempo. Al final imprimir losarreglos originales y su tiempo de ordenamiento./ Crea un archivo de acceso aleatorio, escribiendo 100 registros vacíos en el disco.import java.io.*;import javax.swing.*;public class CrearArchivoAleatorio { private static final int NUMERO_REGISTROS = 100; // permitir al usuario seleccionar el archivo a abrir private void crearArchivo() { // mostrar cuadro de diálogo para que el usuario pueda seleccionar el archivo JFileChooser selectorArchivo = new JFileChooser(); selectorArchivo.setFileSelectionMode( JFileChooser.FILES_ONLY ); int resultado = selectorArchivo.showSaveDialog( null ); // si el usuario hizo clic en el botón Cancelar del cuadro de diálogo, regresar if ( resultado == JFileChooser.CANCEL_OPTION ) return;
  66. 66. // obtener el archivo seleccionado 66File nombreArchivo = selectorArchivo.getSelectedFile();// mostrar error si el nombre del archivo es inválidoif ( nombreArchivo == null || nombreArchivo.getName().equals( "" ) ) JOptionPane.showMessageDialog( null, "Nombre de archivo incorrecto", "Nombre de archivo incorrecto", JOptionPane.ERROR_MESSAGE );else { // abrir el archivo try { RandomAccessFile archivo = new RandomAccessFile( nombreArchivo, "rw" ); RegistroCuentasAccesoAleatorio registroEnBlanco = new RegistroCuentasAccesoAleatorio(); // escribir 100 registros en blanco for ( int cuenta = 0; cuenta < NUMERO_REGISTROS; cuenta++ ) registroEnBlanco.escribir( archivo ); archivo.close(); // cerrar el archivo // mostrar mensaje indicando que el archivo se creó
  67. 67. JOptionPane.showMessageDialog( null, "Se creó el archivo " + 67 nombreArchivo, "Estado", JOptionPane.INFORMATION_MESSAGE ); System.exit( 0 ); // terminar el programa } // fin del bloque try // procesar excepciones durante operaciones de apertura, escritura o cierredel archivo catch ( IOException excepcionES ) { JOptionPane.showMessageDialog( null, "Error al procesar el archivo", "Error al procesar el archivo", JOptionPane.ERROR_MESSAGE ); System.exit( 1 ); } } // fin de instrucción else } // fin del método crearArchivo public static void main( String args[] ) { CrearArchivoAleatorio aplicacion = new CrearArchivoAleatorio(); aplicacion.crearArchivo(); }
  68. 68. 68} // fin de la clase CrearArchivoAleatorio
  69. 69. 69 MÉTODOS DE BÚSQUEDAPrograma de los hombres búsqueda binariaimport java.awt.*;import java.awt.event.*;import java.io.*;import javax.swing.*;public class PruebaFile extends JFrame implements ActionListener { private JTextField campoEntrada; private JTextArea areaSalida; public PruebaFile() { super( "Prueba de la clase File" );
  70. 70. 70 campoEntrada = new JTextField( "Escriba aquí el nombre del archivo o directorio" ); campoEntrada.addActionListener( this ); areaSalida = new JTextArea(); ScrollPane panelDesplazable = new ScrollPane(); panelDesplazable.add( areaSalida ); Container contenedor = getContentPane(); contenedor.add( campoEntrada, BorderLayout.NORTH ); contenedor.add( panelDesplazable, BorderLayout.CENTER ); setSize( 400, 400 ); setVisible( true );}public void actionPerformed( ActionEvent eventoAccion ){ File nombre = new File( eventoAccion.getActionCommand() );
  71. 71. 71if ( nombre.exists() ) { areaSalida.setText( nombre.getName() + " existen" + ( nombre.isFile() ? "es un archivon" : "no es un archivon" ) + ( nombre.isDirectory() ? "es un directorion" : "no es un directorion" ) + ( nombre.isAbsolute() ? "es una ruta absolutan" : "no es una ruta absolutan" ) + "Última modificación: " + nombre.lastModified() + "nLongitud: " + nombre.length() + "nRuta: " + nombre.getPath() + "nRuta absoluta: " + nombre.getAbsolutePath() + "nPadre: " + nombre.getParent() ); if ( nombre.isFile() ) { try { BufferedReader entrada = new BufferedReader( new FileReader( nombre ) ); StringBuffer bufer = new StringBuffer(); String texto; areaSalida.append( "nn" );
  72. 72. 72 while ( ( texto = entrada.readLine() ) != null ) bufer.append( texto + "n" ); areaSalida.append( bufer.toString() ); } catch( IOException excepcionES ) { JOptionPane.showMessageDialog( this, "ERROR EN ARCHIVO", "ERROR EN ARCHIVO", JOptionPane.ERROR_MESSAGE ); }}else if ( nombre.isDirectory() ) { String directorio[] = nombre.list(); areaSalida.append( "nnContenido del directorio:n"); for ( int i = 0; i < directorio.length; i++ ) areaSalida.append( directorio[ i ] + "n" );
  73. 73. } 73 } else { JOptionPane.showMessageDialog( this, eventoAccion.getActionCommand() + " no existe", "ERROR", JOptionPane.ERROR_MESSAGE ); } } public static void main( String args[] ) { PruebaFile aplicacion = new PruebaFile(); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }}
  74. 74. Programa de las mujeres búsqueda secuencial 74import java.util.*;class programa8{public static void main(String[]args){int a[],n,n1,indice;Scanner sc=new Scanner(System.in);System.out.print("Ingresa tamaño del vector: ");n=sc.nextInt();a=new int[n];a=inicializa(n);muestra(a);System.out.print("Ingresa numero a buscar: ");n1=sc.nextInt();
  75. 75. indice=busquedaLineal(a,n1); 75if(indice==-1){System.out.println("tu número no esta en la lista");}else{System.out.println("tu número esta en el indice: "+indice);}}static int[] inicializa(int n){int i,j,a[]=new int[n];for(i=0;i<n;i++){a[i]=randomxy(1,50);}return a;}static int busquedaLineal(int a[],int n)
  76. 76. { 76int i;for (i=0;i<a.length;i++){if (a[i] == n){return i+1;}}return -1;}static void muestra(int a[]){int n=a.length;for(int i=0;i<n;i++){System.out.print(a[i]+" ");}System.out.print("nn");}
  77. 77. static int randomxy(int x,int y) 77{int ran=(int) (Math.floor(Math.random()*(y-x+1))+x);return ran;}}Programa De Examenimport java.util.*;class busqueda{ public static void main(String[]args) { int a[],n,n1,indice; Scanner sc=new Scanner(System.in); System.out.print("Ingresa tamaño del arreglo: "); n=sc.nextInt(); a=new int[n];
  78. 78. 78 a=inicializa(n); muestra(a); System.out.print("Ingresa numero a buscar: "); n1=sc.nextInt(); indice=busqueda1(a,n1); if(indice==-1) { System.out.println("tu número no esta en lalista"); } else { System.out.println("tu número esta en elindice: "+indice); }} static int[] inicializa(int n) { int i,j,a[]=new int[n]; for(i=0;i<n;i++) { a[i]=randomxy(1,50);
  79. 79. } 79 return a;}static int busqueda1(int a[],int n){ int i; for (i=0;i<a.length;i++) { if (a[i] == n) { return i+1; } } return -1;}static void muestra(int a[]){ int n=a.length; for(int i=0;i<n;i++) { System.out.print(a[i]+" "); }
  80. 80. System.out.print("nn"); 80 } static int randomxy(int x,int y) { int ran=(int) (Math.floor(Math.random()*(y-x+1))+x); return ran; }}
  81. 81. ANÁLISIS DE LOS ALGORITMOS 81 INTRODUCCIÓNLos algoritmos se pueden clasificarse según la complejidades de tiempo y espacio, y aeste respecto pueden distinguirse varias clases de algoritmos, como lo ilustran lasiguiente figura. Su crecimiento también se muestra, por ejemplo, los algoritmo se llamaconstante si su tiempo de ejecución sigue siendo el mismo para cualquier número deelementos; se llama cuadrático si su tiempo de ejecución es O (n2).para cada una deestas clases de algoritmos y sus tiempo de ejecución en una computadora que realizaun millón de operaciones por segundo (1s=106µs=103ms). Clase complejidad 10 102 103 n constante O(1) 1 1µs 1 1µs 1 1µs Logarítmica O(1gn) 3.32 3µs 6.64 7µs 9.97 10µs Lineal O(n) 10 10µs 102 100µs 103 1ms O(n1gn) O(n1gn) 33.2 33µs 664 664µs 9970 10ms Cuadrática O(n2) 102 100µs 104 10ms 106 1s
  82. 82. 82 ANÁLISIS DE LOS ALGORITMOS.Es una disciplina de las ciencias de la computación y, en la mayoría de los casos, suestudio es completamente abstracto sin usar ningún tipo de lenguaje deprogramación ni cualquier otra implementación. Así, el análisis de los algoritmos secentra en los principios básicos del algoritmo, no en los de la implementación particular.Una forma de plasmar (o algunas veces "codificar") un algoritmo es escribirloen pseudocódigo o utilizar un lenguaje muy simple tal como Léxico, cuyos códigospueden estar en el idioma del programador.Por ejemplo:Un algoritmo que verifica que hay más ceros que unos en una secuencia binaria infinitadebe ejecutarse siempre para que pueda devolver un valor útil. Si se implementacorrectamente, el valor devuelto por el algoritmo será válido, hasta que evalúe elsiguiente dígito binario. De esta forma, mientras evalúa la siguiente secuencia podránleerse dos tipos de señales: una señal positiva (en el caso de que el número de cerossea mayor que el de unos) y una negativa en caso contrario. Finalmente, la salida deeste algoritmo se define como la devolución de valores exclusivamente positivos si haymás ceros que unos en la secuencia y, en cualquier otro caso, devolverá una mezcla deseñales positivas y negativas.
  83. 83. 83 COMPLEJIDAD EN EL TIEMPO Y ESPACIOComplejidad en el tiempo:Cantidad de tiempo necesario para la ejecuciónÓrdenes de ComplejidadSe dice que O (f(n)) define un "orden de complejidad". Escogeremos comorepresentante de este orden a la función f(n) más sencilla del mismo. Así tendremosO(1) orden constanteO(log n) orden logarítmicoO(n) orden linealO(n log n)O(n2) orden cuadráticoO(na) orden polinomiol (a > 2)O(an) orden exponencial (a > 2)O (n!) orden factorialEs más, se puede identificar una jerarquía de órdenes de complejidad que coincide conel orden de la tabla anterior; jerarquía en el sentido de que cada orden de complejidadsuperior tiene a los inferiores como subconjuntos. Si un algoritmo A se puede demostrarde un cierto orden O1, es cierto que también pertenece a todos los órdenes superiores(la relación de orden cota superior de es transitiva); pero en la práctica lo útil esencontrar la "menor cota superior", es decir el menor orden de complejidad que locubra. Los algoritmos de complejidad O(n) y O(n log n) son los que muestran uncomportamiento más "natural": prácticamente a doble de tiempo, doble de datos procesables.Los algoritmos de complejidad logarítmica son un descubrimiento fenomenal, pues en el doblede tiempo permiten atacar problemas notablemente mayores, y para resolver un problema eldoble de grande sólo hace falta un poco más de tiempo (ni mucho menos el doble).
  84. 84. Los algoritmos de tipo polinómico no son una maravilla, y se enfrentan con dificultad a 84problemas de tamaño creciente. La práctica viene a decirnos que son el límite de lo"tratable".Sobre la tratabilidad de los algoritmos de complejidad polinómicahabria mucho quehablar, y a veces semejante calificativo es puro eufemismo. Mientras complejidades delorden O (n2) y O (n3) suelen ser efectivamente abordables, prácticamente nadie aceptaalgoritmos de orden O(n100), por muy polinómicos que sean. La frontera es imprecisa.Cualquier algoritmo por encima de una complejidad polinómico se dice "intratable" ysólo será aplicable a problemas ridículamente pequeños.Por ejemplo, si disponemos de dos algoritmos para el mismo problema, con tiempos deejecución respectivos: algoritmo tiempo complejidad f 100 n O(n) 2 g n O(n2)Asintóticamente, "f" es mejor algoritmo que "g"; pero esto es cierto a partir de N >100.Si nuestro problema no va a tratar jamás problemas de tamaño mayor que 100,es mejor solución usar el algoritmo "g". El ejemplo anterior muestra que lasconstantes que aparecen en las fórmulas para T(n), y que desaparecen al calcularlasfunciones de complejidad, pueden ser decisivas desde el punto de vista de ingeniería.Pueden darse incluso ejemplo: algoritmo tiempo complejidad f 100 n O(n) g n2 O(n2)
  85. 85. 85Las siguientes propiedades se pueden utilizar como reglas para el cálculo de órdenesde complejidad. Toda la maquinaria matemática para el cálculo de límites se puedeaplicar directamente:C. Lim (n->inf) f (n)/g (n) = 0 => f IN O (g) =>g NOT_IN O(f)=>O(f) es subconjunto de O(g)D. Lim (n->inf) f (n)/g (n) = k => f IN O(g) =>g IN O(f) => O(f) = O(g)E. Lim(n->inf)f(n)/g(n)= INF => f NOT_IN O(g) =>g IN O(f) =>O(f) es superconjunto de O(g)Las que siguen son reglas habituales en el cálculo de límites:F. Si f, g IN O(h) =>f+g IN O(h)G. Sea k una constante, f(n) IN O(g) => k*f(n) IN O(g)H. Si f IN O(h1) y g IN O(h2) =>f+g IN O(h1+h2)I. Si f IN O(h1) y g IN O(h2) => f*g IN O(h1*h2)J. Sean los reales 0 < a < b =>O(na) es subconjunto de O(nb)K. Sea P(n) un polinomio de grado k => P(n) IN O(nk)L. Sean los reales a, b > 1 =>O(loga) = O(logb)La regla [L] nos permite olvidar la base en la que se calculan los logaritmos enexpresiones de complejidad. La combinación de las reglas [K, G] es probablemente lamás usada, permitiendo de un plumazo olvidar todos los componentes de un polinomio,menos su grado.Por último, la regla [H] es la basica para analizar el concepto de secuencia en unprograma: la composición secuencial de dos trozos de programa es de orden decomplejidad el de la suma de sus partes.
  86. 86. Costes en tiempo y en espacio 86La característica básica que debe tener un algoritmo es que sea correcto, es decir, queproduzca el resultado deseado en tiempo finito. Adicionalmente puede interesarnos quesea claro, que este bien estructurado, que sea fácil de usar, que sea fácil deimplementar y que sea eficiente.Entendemos por eficiencia de un algoritmo la cantidad de recursos de computo querequiere; es decir, cual es su tiempo de ejecución que cantidad de memoria utiliza.A la cantidad de tiempo que requiere la ejecución de un cierto algoritmo se le suelellamar coste en tiempo mientras que a la cantidad de memoria que requiere se le suelellamar coste en espacio.Es evidente que conviene buscar algoritmos correctos que mantengan tan bajo comosea posible el consumo de recursos que hacen del sistema, es decir, que sean lo maseficientes posible. Cabe hacer notar que el concepto de eficiencia de un algoritmo es unconcepto relativo, esto quiere decir que ante dos algoritmos correctos que resuelven elmismo problema, uno es mas eficiente que otro si consume menos recursos. Por tanto,podemos observar que el concepto de eficiencia y en consecuencia el concepto decoste nos permitirá comparar distintos algoritmos entre ellos.Si consideramos los algoritmos elementales de ordenación por selección y por Inserción¿Cómo podríamos elegir cual de ellos utilizar en una aplicación dada?}Veremos másadelante que para efectos prácticos ambos algoritmos son similares y que soneficientes solo para ordenar secuencias con un número pequeño de elementos. Sinembargo hay varias comparaciones que se pueden hacer entre ellos.Tamaño del vector Núm. Comparaciones Núm. IntercambiosSelección n(n − 1)/2 0 (min.)n− 1 (max.)n− 1 (min.) 0 (min.)Insertion prop.n2/4 (prom.) prop. N2/4 (prom.)Prop. N2/2 (max.) prop. N2/2De la tabla anterior podemos inferir que para ordenar secuencias cuyos elementosSean difíciles de comparar (las comparaciones son caras) es más conveniente Utilizarel método de ordenación por inserción, y que este método es más eficiente mientras
  87. 87. más ordenada este la secuencia de entrada. Si por el contrario queremos ordenar 87secuencias de elementos que son fáciles de comparar (o que tienen claves asociadasfáciles de comparar) y en cambio los intercambios son carosseria más convenienteutilizar el algoritmo de ordenación por selección.En general, ¿cómo podemos elegir entre un algoritmo y otro si ambos resuelven elmismo problema?Pero este método tiene varios inconvenientes ya que los resultados dependen: delsubconjunto de pruebas escogidas del ordenador en el que se realicen las pruebas dellenguaje de programación utilizado o del compilador, entre otros factores.Ejemplo. Análisis de la funciona os min, que encuentra la posición del elemento mínimoen un vector de enteros.El coste en tiempo de un algoritmo depende del tipo de operaciones que realiza y delcoste especifico de estas operaciones. Este coste suele calcularse únicamente enfunción del tamaño de las entradas para que sea independiente del tipo de maquina,lenguaje de programación, compilador, etc. en que se implementa el algoritmo.Definición 1.1 Dado un algoritmo A cuyo conjunto de entradas es A, su eficiencia ocoste (en tiempo, en espacio, en número de operaciones de entrada/ salida, etc.) esuna función tal que:T: A! R+∞ 7! T (∞)COMPARACION DE COMPLEJIDAD Y TIEMPO EN ALGORITMOS.Se analizara el tiempo de ejecución y el tiempo empleado por los algoritmos deinserción directa, selección directa, el método de la burbuja y el método de la burbujamejorado, ordenando una arreglo de enteros en 3 casos: en orden ascendente (mejorcaso), un orden descendente (peor caso) y un orden al azar (caso promedio).ALGORITMOS:- INSERCION DIRECTA:Para x=2 hasta n (+)
  88. 88. Y x-1 88Sw 0Mientras (y<>0) y (sw=0)Si A[y-1]>A[y]AuxA[y-1]A[y-1]A[y]A[y]AuxDe lo contrarioSw1Yy-1SELECCIÓN DIRECTA:Para x=1 hasta n-1 (+)MenorxPara y=x+1 hasta n (+)Si A[y] <A [menor]MenorySi menor<>xAuxA[x]A[x] A[menor]
  89. 89. A[menor] Aux 89- METODO DE LA BURBUJA:Para i=1 hasta n-1Para j=i+1 hasta nSi A[i]>A[j]AuxA[i]A[i]A[j]A[j]AuxMETODO DE LA BURBUJA MEJORADO:Sw1Mientras sw=1Sw 0Para i=1 hasta n-1 (+)Si A[i] >A[i+1]AuxA[i]A[i]A[i+1]A[i+1]Aux
  90. 90. COMPARACION DE COMPLEJIDADES: 90 ORDEN DE COMPLEJIDAD INSERCION SELECCION BURBUJA BURBUJA DIRECTA DIRECTA (MEJORADO) MEJOR O(N) O(N2) O(N2) O(N) CASO CASO O(N2) O(N2) O(N2) O(N2) PROMEDIO PEOR CASO O(N2) O(N2) O(N2) O(N log N)TIEMPO EN COMPARACIONES Y ASIGNACIONES:Probar que son equivalentes las condiciones siguientes:1. G es un grafo bipartito.2. G es un grafo 2{coloreable.3. G es un grafo que carece de ciclos de longitud impar.1. COMPLEJIDAD ALGORÍTMICAUn algoritmo será mas eficiente comparado con otro, siempre que consuma menosrecursos, como el tiempo y espacio de memoria necesarios para ejecutarlo.La eficiencia de un algoritmo puede ser cuantificada con las siguientes medidas decomplejidad:1. Complejidad Temporal o Tiempo de ejecución: Tiempo de cómputo necesariopara ejecutar algún programa.2. Complejidad Espacial: Memoria que utiliza un programa para su ejecución, Laeficiencia en memoria de un algoritmo indica la cantidad de espacio requerido paraejecutar el algoritmo; es decir, el espacio en memoria que ocupan todas las variables
  91. 91. propias al algoritmo. Para calcular la memoria estática de un algoritmo se suma la 91memoria que ocupan las variables declaradas en el algoritmo. Para el caso de lamemoria dinámica, el cálculo no es tan simple ya que, este depende de cada ejecucióndel algoritmo. Este análisis se basa en las Complejidades Temporales, con este fin,para cada problema determinaremos una medida N, que llamaremos tamaño de laentrada o número de datos a procesar por el programa, intentaremos hallar respuestasen función de dicha N.El concepto exacto que cuantifica N dependerá de la naturalezadel problema, si hablamos de un array se puede ver a N como el rango del array, parauna matriz, el número de elementos que la componen; para un grafo, podría ser elnúmero de nodos o arcos que lo arman, no se puede establecer una regla para N, puescada problema acarrea su propia lógica y complejidad.Tiempo de Ejecución: El tiempo de Ejecución de un programa se mide en función deN, lo que designaremos como (N).Esta función se puede calcular físicamenteejecutando el programa acompañados de un reloj, o calcularse directamente sobre elcódigo, contando las instrucciones a ser ejecutadas y multiplicando por el tiemporequerido por cada instrucción. Así, un trozo sencillo de código como:S1;for(x = 0; x < N; x++)S2;Demanda: T(N) = t1 + t2 * NDonde t1 es el tiempo que lleva ejecutar la serie S1 de sentencias, y t2 es el que llevala serie S2.Habitualmente todos los algoritmos contienen alguna sentencia condicionalo selectiva, haciendo que las sentencias ejecutadas dependan de la condición lógica,esto hace que aparezca más de un valor para T(N), es por ello que debemos hablar deun rango de valores:Tmin(N) ≤ T(N) ≤ Tmax(N)

×