[MÚSICA] Hola y bienvenidos. Esta vez vamos a ver cómo traducimos del pseudocódigo al código, para java, el algoritmo de ordenamiento por inserción. Veamos nuestra aplicación que se llama M4, ordenamiento e inserción. Primero, corrámosla para ver qué hay. Tenemos una interfaz con cartas que no se ordenan. y podemos elegir siempre unas cartas iniciales, seis, para ser exactos, de manera aleatoria sin repetirse, pero que no podemos ordenar de ninguna manera. Nuestro reto va a ser crear o escribir el algoritmo de inserción a partir de lo que ya sabemos. Tenemos, entonces, cinco clases, tenemos tres clases de la interfaz y dos clases del mundo; las clases de la interfaz no nos van a interesar. Veremos la clase ordenador inserción que es la clase principal del mundo. Tiene un arreglo de cartas que siempre va a iniciar en seis, un método que elige aleatoriamente las cartas al principio, el método que retorna el arreglo, el método que elige las cartas, la implementación, y que no nos va a interesar por el momento, y el método de ordenar cartas por inserción que está vacío. Miremos, además, la clase carta. La clase carta modela un objeto de tipo carta con su valor, la pinta de la carta y nos permite además muy fácilmente compararlas; tiene un método que se llama compare to que nos hace las comparaciones, recibe el objeto de tipo carta por parámetro, C1 y que funciona así: Si los valores de C1 y de la carta, la carta que está aquí, son iguales, los retorna a cero. Si, por el contrario, el valor de la carta que entra por parámetro es mayor que el de la carta actual, pues retorna a uno, y si no, retorna a menos uno. Bien, sabiendo eso ya podemos implementar nuestro algoritmo, vamos aquí y vamos a empezar a escribir. Es el momento en el que podríamos saltar y mirar un momento al pseudocódigo si no nos acordamos bien; si sí, pues empecemos a echar código. Bueno, en primer lugar pues recordemos que hay dos ciclos, el primer ciclo, el de la progresión, y el segundo ciclo, el que va en orden inverso. El primer ciclo, entonces, vamos a ponerlo aquí ya, y el segundo ciclo. Nuestro primer ciclo va a comenzar, entonces, en uno. ¿Por qué no en cero? Porque el elemento que está en la posición cero va a ser parte, según nosotros hemos asumido, de un subarreglo que ya está ordenado. Entonces, declaramos N igual a uno y vamos a iterar en este primer ciclo hasta el tamaño de nuestro arreglo de tipo carta, es decir, length y vamos a aumentar de uno en uno el valor de N, es decir N más más. Nuestro primer ciclo ya está hecho. Nuestro segundo ciclo requiere pensarlo un poco más porque es el ciclo que va en sentido inverso. Vamos a crear nuestra variable M y vamos a comenzar siempre desde el elemento que está en N y nos vamos a devolver hacia el subarreglo ordenado. Entonces cuando N está en uno, comienza en uno, pero si N está en cuatro, en este caso, pues comenzamos cuatro y nos devolvemos en los otros tres elementos que ya deberían estar ordenados para esa iteración. Entonces, comenzamos en N y siempre vamos a ir hasta el elemento antes del final, es decir, no vamos a llegar en orden inverso, no vamos a pasarnos y a tener posiciones extrañas como menos uno y vamos en orden inverso, es decir, M menos N, M menos menos. Lo que significa que M va a ser igual a M menos uno al final del ciclo. ¿Cuál es la condición entonces para la progresión de este ciclo? Pues, simplemente, que si el elemento que está en la posición M resulta ser de valor menor, o la carta resulta ser de valor menor que el elemento que está anterior a él, es decir, en la posición M menos uno, intercambiamos sus posiciones. Eso se hace con un condicional, muy fácilmente. Entonces, nuevamente si el elemento que está en la posición M de cartas resulta ser, comparado con elemento en la posición M menos uno, resulta ser menor, o sea que mayor que cero. De acuerdo con el método compare to de cartas, intercambiamos ¿Cómo intercambiamos? Pues simplemente decimos: cartas en M va a ser igual a cartas en M menos uno; cartas en M menos uno va a ser igual a cartas en N. Ahí está, ¿o no? Bueno, resulta que en este método hay un error. Si nos acordamos cómo se manejan las referencias y las variables, resulta que cuando hicimos este intercambio, la referencia a la posición M cambió por el valor que está en la posición M menos uno; así cuando vamos a utilizar M menos uno pues estamos solamente sobrescribiendo lo que acabamos de poner, o sea que vamos a tener M menos uno dos veces en nuestro arreglo. ¿Cómo solucionamos eso? creamos una variable del tipo carta que se va a llamar Temporal, no importa mucho el nombre, y ahí vamos a guardar la referencia al objeto en la posición M. Así cuando vayamos a ponerlo acá, en lugar de acceder una posición del arreglo que ya ha sido cambiada pues simplemente ponemos el objeto Temp que tiene nuestro valor. Ahora, recordemos que hay una condición adicional, recordemos que si no hacemos ningún intercambio significa que ya todos los elementos están ordenados y que el elemento que estábamos tratando de ordenar en el subarreglo ordenado ya está en su posición. Así que no deberíamos gastar más iteraciones. ¿Cómo hacemos eso? Simple, ponemos una condición que si no se cumple esto para intercambiar, no deberíamos hacer nada más. Así que utilizamos nuestro Zoom Break que rompe el ciclo en orden inverso y nos permite seguir avanzando con las cartas que falta por ordenar. Bien, guardamos y vamos a ver si funciona. Nuevamente, abrimos nuestra interfaz, tenemos las cartas y ordenamos. tres, siete, siete, nueve, jota y jota. Todo parece en orden, la jota equivale a 10, así que está bien. Generamos nuevas cartas. Esta vez tenemos, afortunadamente, dos figuras, y las ordenamos. cuatro, cinco, cinco, nueve, la reina y el rey. Como la reina es menor que el rey, entonces está bien ordenado. Bien, hemos hecho nuestro algoritmo por inserción en sintaxis java, hemos pasado del pseudocódigo al código java y tenemos un muy bonito resultado. Muchas gracias por escucharme. [MÚSICA]