03.o Ejercicios Resueltos, ordenar con Java (2472) Vemos un ejemplo resuelto para ordenar, y aplicando lo que vimos anteriormente usamos un menú en pantalla para que el usuario elija opciones. contact Created,Modified 2009-04-10 08:37:26, 2009-06-14 16:54:46 Author,Nick Gustavo Guillermo Perez, (madgus) [myblog]

Ejercicios

Los ejercicios del capítulo III son los últimos antes de proceder con objetos, es recomendable que todo aquello que se ha visto hasta el momento quede perfectamente asimilado ya que en el próximo tema los objetos comenzarán a ser la herramienta principal.

Ejercicio 3.1

Realizar un programa cuyo método principal pida 10 valores numéricos y los asigne a un arreglo, posteriormente imprimir en pantalla el resultado ordenado creciente, y decreciente utilizando el método de la burbuja, computar la cantidad de comparaciones realizadas entre elementos del arreglo y mostrarlas al final como estadística.

1. package com.compunauta.aprendiendojava;

2. import java.io.*;

3. /**

4. * <p>Título: Aprendiendo Java</p>

5. * <p>Descripción: Ejemplos del Libro Aprendiendo Java de Compunauta</p>

6. * <p>Copyright: Copyright (c) 2006 www.compunauta.com</p>

7. * <p>Empresa: COMPUNAUTA</p>

8. * @author Gustavo Guillermo Pérez

9. * @version 2007.10.01

10. */

12. public class Cap3_ej1 {

13. public static int comparaciones=0;

14. public static void main(String[] args) {

15. BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

16. int[] listado=new int[10];

17. System.out.println("Ingrese 10 números, de a uno presionando ENTER");

18. for(int i=0;i<10;i++){

19. listado[i]=leerInt(br);

20. }

22. burbuja_mayormenor(listado);

23. for(int i=0;i<10;i++){

24. System.out.println("NRO >:["+i+"] "+listado[i]);

25. }

26. System.out.println("Comparaciones:"+comparaciones);

27. burbuja_menormayor(listado);

28. for(int i=0;i<10;i++){

29. System.out.println("NRO <:["+i+"] "+listado[i]);

30. }

32. }

33. public static int leerInt(BufferedReader buff){

34. int lee=0;

35. boolean error;

36. do {

37. error=false;

38. try {lee = Integer.parseInt(buff.readLine());}

39. catch (NumberFormatException ex) {

40. System.out.println("Entrada erronea, repetir:?");

41. error=true;}

42. catch (Exception ex){ex.printStackTrace(System.err);}

43. } while (error);

44. return lee;

45. }//final de la función leer

47. public static void ordenar_burbuja_mayormenor(int[] listado){

48. int temporal;

49. for (int j = listado.length - 1; j > 0; j--) {

50. for (int i = 0; i < j; i++) {

51. comparaciones++;

52. if (listado[i] < listado[i + 1]) {

53. temporal = listado[i + 1];

54. listado[i + 1] = listado[i];

55. listado[i] = temporal;

56. }

57. }

58. }

59. }//final método ordenar burbuja mayor menor

61. public static void burbuja_mayormenor(int[] listado){

62. int temporal;

63. for (int j = 0; j < listado.length - 1; j++) {

64. for (int i = 0; i < listado.length - 1; i++) {

65. comparaciones++;

66. if (listado[i] < listado[i + 1]) {

67. temporal = listado[i + 1];

68. listado[i + 1] = listado[i];

69. listado[i] = temporal;

70. }

71. }

72. }

73. } //final método ordenar burbuja mayor menor

75. public static void ordenar_burbuja_menormayor(int[] listado){

76. int temporal;

77. for (int j = 0; j < listado.length - 1; j++) {

78. for (int i = listado.length - 1; i > j; i--) {

79. comparaciones++;

80. if (listado[i] < listado[i - 1]) {

81. temporal = listado[i - 1];

82. listado[i - 1] = listado[i];

83. listado[i] = temporal;

84. }

85. }

86. }

87. }//final método ordenar burbuja menor mayor

89. public static void burbuja_menormayor(int[] listado){

90. int temporal;

91. for (int j = 0; j < listado.length - 1; j++) {

92. for (int i = listado.length - 1; i > 0; i--) {

93. comparaciones++;

94. if (listado[i] < listado[i - 1]) {

95. temporal = listado[i - 1];

96. listado[i - 1] = listado[i];

97. listado[i] = temporal;

98. }

99. }

100. }

101. } //final método ordenar burbuja menor mayor

102. }

Línea 1, declaración del paquete, línea 2 importamos java.io para usar los métodos de lectura del teclado, Línea 12 declaración de la clase, línea 13 declaramos la variable estática a la clase comparaciones que es la que usaremos para computar la cantidad de comparaciones para ordenar el arreglo.

El programa en sí comienza en el método principal línea 14, línea 15 se construye un objeto BufferedReader para lectura por teclado, línea 16 se inicializa un arreglo de 10 elementos que será el tamaño del arreglo a trabajar.

Líneas 17 a 20 es la entrada por teclado de los números del arreglo utilizando la función leerInt(BufferedReader) utilizada en ejercicios anteriores.

Línea 22 se invoca a la función que ordena sobre el arreglo listado de números enteros, y en las líneas 23 a 26 se imprime en pantalla la información correspondiente y la estadística de las comparaciones. Línea 33 a 45 Función leer.

Línea 47 – 59 la función ordenar de mayor a menor con la optimización de acotación de índices, y las demás variantes con y sin optimización.

Ejercicio 3.2

Realizar un programa cuyo fin sea el del ejercicio 3.1 pero utilizando el procedimiento quicksort.

Ejercicio 3.3

Integrar con un pequeño menú en pantalla la selección del método que se utilizará para ordenar el arreglo reutilizando el código de los ejercicios anteriores 3.1 y 3.2, pero añadir al cómputo las comparaciones en total incluyendo las de los índices en bucles.