Crear actividad
Jugar Test
1. 
1. Es el algoritmo más sencillo a la hora de implementar, pero es uno de los más demorados ya que evalúa los mismos datos muchas que resultan incensarios, usualmente se aplica para ordenar cierta cantidad de datos ya sea de una forma descendente o ascendente, estos datos además son ordenados muchas veces por array y estructuras.
A.
Método de Inserción.
B.
Método Quicksort.
C.
Búsqueda Secuencial.
D.
Método Bubble Sort
2. 
2. En este método buscas el elemento más pequeño de la lista., Lo intercambias con el elemento ubicado en la primera posición de la lista., Buscas el segundo elemento más pequeño de la lista., Lo intercambias con el elemento que ocupa la segunda posición en la lista., Repites este proceso hasta que hayas ordenado toda la lista. A la hora de crear el algoritmo tiene en cuenta Requerimientos de Memoria: este algoritmo sólo necesita una variable adicional para realizar los intercambios. Tiempo de Ejecución: El ciclo externo se ejecuta n veces para una lista de n elementos. Cada búsqueda requiere comparar todos los elementos no clasificados. De acuerdo a la Anterior el método se conoce como y una de sus ventajas y desventajas es
A.
A. Rendimiento constante: poca diferencia entre el peor y el mejor caso; es el más usado (Método de Inserción)
B.
No requiere memoria adicional (Método Shell short)
C.
Fácil implementación y realiza número de comparaciones. ( Método de Selección)
D.
No requiere memoria adicional es el método más veloz (Método Quicksort)
3. 
3. Es un algoritmo relativamente sencillo y se comporta razonablemente bien en gran cantidad de situaciones. Se basa en intentar construir una lista ordenada en el interior del array a ordenar. Es el que mejor resultado da a efectos prácticos. Realiza una cantidad de comparaciones bastante equilibrada con respecto a los intercambios, Este ordenamiento se llama y se basa en hacer comparaciones, así que para que realice su trabajo de ordenación son imprescindibles dos cosas:
A.
A. Un array o estructura similar de elementos comparables y un criterio claro de comparación, tal que dados dos elementos nos diga si están en orden o no. Y En cada iteración del ciclo externo los elementos 0 a i forman una lista ordenada. (Método ordenamiento inserción)
B.
B. Requerimientos de Memoria Y Tiempo en ejecución. (Método selección.)
C.
C. Recorrer el conjunto de elementos en forma secuencial varias veces. (Método Bubble Sort.)
D.
D. Proponer que las comparaciones entre elementos se efectúen con saltos de mayor tamaño pero con incrementos decrecientes, así, los elementos quedarán ordenados en el arreglo más rápidamente y tener su entrada ordenada. (Método de ordenamiento SHELL)
4. 
Consiste básicamente en recorrer el arreglo de izquierda a derecha hasta que se encuentre el elemento buscado o se termine el arreglo, lo que ocurra primero. Normalmente cuando una función de búsqueda concluye con éxito, interesa conocer en qué posición fue hallado el elemento que se estaba buscando. Como se le conoce a este método de ordenamiento o búsqueda.
A.
Método binario
B.
Método inserción
C.
Método Quicksort
D.
Método secuencial
5. 
La FIFA quiere organizar el orden de puntajes que tiene cada una de las selecciones de los países dependientes el número de puntos que tiene cada selección, pero como son muchas desea generar un algoritmo que Ingrese Nombres De Equipos de Futbol Con Su Respectivo Puntaje Visualizarlo Ordenados Por el Puntaje, Utilizando Métodos rápido Y Burbuja.El código es el siguiente: import javax.swing.JOptionPane; public class MetodosDeOrdenamientoJugadores { public static void main(String [] args){ int x =Integer.parseInt(JOptionPane.showInputDialog("Ingrese Total De Equipos",0)); int puntos[]= new int[x]; String equipos[]= new String[x]; for(int i =0;i < x;i++){ equipos[i]= JOptionPane.showInputDialog("Ingrese Nombre De Equipo" ); puntos[i]= Integer.parseInt(JOptionPane.showInputDialog("Ingrese Puntos",0)); } Burbuja(puntos,equipos); String Cadena = "Equipos Y Sus Puntos \n"; for(int i =0;i < x;i++){ Cadena = Cadena + equipos[i] + " " + puntos[i] + "\n"; } JOptionPane.showMessageDialog(null, Cadena); } public static void Burbuja(int[]matrix,String[]equipos){ int temp; String tempe; for(int i=1;i < matrix.length;i++){ for (int j=0 ; j < matrix.length- 1; j++){ if (matrix[j] < matrix[j+1]){ temp = matrix[j]; matrix[j] = matrix[j+1]; matrix[j+1] = temp; tempe = equipos[j]; equipos[j] = equipos[j+1]; equipos[j+1] = tempe; } } } } //a = Inicio ; b = Final public static void Rapido(int matrix[], int a, int b){ matrix = new int[matrix.length]; int buf; int from = a; int to = b; int pivot = matrix[(from+to)/2]; do{ while(matrix[from] pivot){ to--; } if(!(from < = to)){ } else { buf = matrix[from]; matrix[from] = matrix[to]; matrix[to] = buf; from++; to--; } }while(from < = to); if(a < to){ Rapido(matrix, a, to); } if(from < b){ Rapido(matrix, from, b); } } } Partiendo de la anterior se puede deducir que:
A.
Método binario.
B.
Método selección
C.
Método inserción.
D.
D. Método secuencial
6. 
Esta búsqueda utiliza un método de “divide y vencerás” para localizar el valor deseado. Con este método se examina primero el elemento central de la lista; si este es el elemento buscado entonces la búsqueda ha terminado. En caso contrario se determina si el elemento buscado está en la primera o segunda mitad de la lista y a continuación se repite el proceso anterior, utilizando el elemento central de esta sublista. Este tipo de búsqueda se utiliza en vectores ordenados.
A.
Método binario.
B.
Método selección.
C.
Método inserción.
D.
Método secuencial.
7. 
La señora Andrea Gómez trabaja en el banco de la república de Colombia y requiere organizar el dinero que ha recibido tanto monedas como billetes según su denominación tanto en forma descendente como ascendente para poder saber que billete o que moneda le hace falta en su inventario. class seleccion { public static void ordenar(int[] arreglo){ int contador = 1;//solo util para contar las comparaciones for (int i = 0; i < arreglo.length - 1; i++){ int min = i; for (int j = i + 1; j < arreglo.length; j++){ //System.out.println("Comparacion #" + contador); contador++; if (arreglo[j] < arreglo[min]){ min = j; } } if (i != min){ int aux= arreglo[i]; arreglo[i] = arreglo[min]; arreglo[min] = aux; } } } public static void imprimirLista(int[] arreglo){ for(int i = 0; i < arreglo.length;i++){ System.out.print(arreglo[i]+","); } System.out.println(); } public static void main(String[] args){ int lista[] = {100,200,500,2000,50000,10000,100000,50,}; System.out.print("Lista desordenada: "); imprimirLista(lista); ordenar(lista); System.out.print("Lista ordenada: "); imprimirLista(lista); } }
A.
Método binario.
B.
metodo selecion
C.
Método inserción.
D.
Método secuencial.
8. 
El ordenamiento de la burbuja es un sencillo algoritmo de ordenamiento. Funciona revisando cada elemento de lista que va a ser ordenada con el siguiente, intercambiadolo de posición si están en el orden equivocado. que codigo es el correcto
A.
public class array2 { /** Método de la Burbuja * Ordenaremos de forma Ascendente */ public static void main(String[ ] args){ int []nums = {34,25,13,24,8,1,11}; int aux; //Vamos a recorrer la matriz for(int i = 0; i < nums.length; i++){ /**Utilizamos un for anidado para comparar * los valores contenidos en la matriz */ for (int j = i + 1; j < nums.length; j++){ /** Si i = 0 el valor es 34 al entrar al segundo for * el valor j = i + 1 será en este caso j = 1… */ if(nums[j]< nums[i]){ /**Si el valor de nums[j] es menor que el valor de * nums[i] este se intercambiará de la siguiente forma, * si queremos ordenar de manera Descendente solo tenemos * que cambiar este signo. */ aux = nums[i]; /**Se guarda en un auxiliar para *no perder el valor y volver a utilizarlo */ nums[i] = nums[j]; nums[j] = aux; /**En las dos líneas anteriores lo que hicimos * fue intercambiar valores con el fin de ordenarlos, * por último vamos a imprimir la matriz. */ } } } System.out.println(“La matriz ordenada es “); for (int i = 0; i < nums.length; i++){ System.out.print(nums[i] + ” “); } } }
B.
for (int j = i + 1; j < nums.length; j++){ /** Si i = 0 el valor es 34 al entrar al segundo for * el valor j = i + 1 será en este caso j = 1… */ if(nums[j]< nums[i]){ /**Si el valor de nums[j] es menor que el valor de * nums[i] este se intercambiará de la siguiente forma, * si queremos ordenar de manera Descendente solo tenemos * que cambiar este signo. */ aux = nums[i]; /**Se guarda en un auxiliar para *no perder el valor y volver a utilizarlo */ nums[i] = nums[j]; nums[j] = aux; /**En las dos líneas anteriores lo que hicimos * fue intercambiar valores con el fin de ordenarlos, * por último vamos a imprimir la matriz. */ } } } System.out.println(“La matriz ordenada es “); for (int i = 0; i < nums.length; i++){ System.out.print(nums[i] + ” “); } } } Anuncios
C.
public class array2 { /** Método de la Burbuja * Ordenaremos de forma Ascendente */ public static void main(String[ ] args){ int []nums = {34,25,13,24,8,1,11}; int aux; //Vamos a recorrer la matriz for(int i = 0; i < nums.length; i++){ /**Utilizamos un for anidado para comparar * los valores contenidos en la matriz */ for (int j = i + 1; j < nums.length; j++){ /** Si i = 0 el valor es 34 al entrar al segundo for * el valor j = i + 1 será en este caso j = 1… */ if(nums[j]< nums[i]){ /**Si el valor de nums[j] es menor que el valor de * nums[i] este se intercambiará de la siguiente forma, * si queremos ordenar de manera Descendente solo tenemos * que cambiar este signo. */
D.
public class array2 { /** Método de la Burbuja * Ordenaremos de forma Ascendente */ public static void main(String[ ] args){ int aux; //Vamos a recorrer la matriz for(int i = 0; i < nums.length; i++){ /**Utilizamos un for anidado para comparar * los valores contenidos en la matriz */ for (int j = i + 1; j < nums.length; j++){ /** Si i = 0 el valor es 34 al entrar al segundo for * el valor j = i + 1 será en este caso j = 1… */ if(nums[j]< nums[i]){ /**Si el valor de nums[j] es menor que el valor de * nums[i] este se intercambiará de la siguiente forma, * si queremos ordenar de manera Descendente solo tenemos * que cambiar este signo. */ aux = nums[i]; /**Se guarda en un auxiliar para *no perder el valor y volver a utilizarlo */ nums[i] = nums[j]; nums[j] = aux; /**En las dos líneas anteriores lo que hicimos * fue intercambiar valores con el fin de ordenarlos, * por último vamos a imprimir la matriz. */ } } } System.out.println(“La matriz ordenada es “); for (int i = 0; i < nums.length; i++){ System.out.print(nums[i] + ” “); } } } Anuncios
9. 
Este método de ordenación ubica el elemento con el mayor valor de la lista y una vez ubicado se intercambian los valores de este elemento con el ultimo elemento de la lista, de esta manera (al igual que sucedia con e metodo de Burbuja), el ultimo elemento queda con el valor correcto (el mayor). sabiendo lo anterior y teniendo en cuenta la siguiente imagen diga cual es el algoritmo correcto en java para poder darle solución al algoritmo
A.
import java.util.Random; 02 /** 03 * @web http://jc-mouse.blogspot.com/ 04 * @author Mouse 05 */ 06 public class Main { 07 08 public static void main(String[] args) { 09 //creamos un array y llenamos este con numeros al azar 10 int[] c = null ; 11 c = generarlista(5); 12 seleccion s = new seleccion(); 13 System.out.println("ORIGINAL : "+ s.Mostrar(c)); 14 System.out.println("ORDENADO : "+ s.Mostrar(s.ordenar(c))); 15 } 16
B.
import java.util.Random; 02 /** 03 * @web http://jc-mouse.blogspot.com/ 04 * @author Mouse 05 */ 06 public class Main { 07 08 public static void main(String[] args) { 09 //creamos un array y llenamos este con numeros al azar 10 int[] c = null ; 11 c = generarlista(5); 12 seleccion s = new seleccion(); 13 System.out.println("ORIGINAL : "+ s.Mostrar(c)); 14 System.out.println("ORDENADO : "+ s.Mostrar(s.ordenar(c))); 15 } 16 17 //genera un array de n elementos enteros 18 public static int[] generarlista(int n){ 19 int[] v = new int[n]; 20 Random rand = new Random(); 21 for (int i=0; i
C.
import java.util.Random; 02 /** 03 * @web http://jc-mouse.blogspot.com/ 04 * @author Mouse 05 */ 06 public class Main { 07 08 public static void main(String[] args) { 09 //creamos un array y llenamos este con numeros al azar 10 int[] c = null ; 11 c = generarlista(5); 12 seleccion s = new seleccion(); 13 System.out.println("ORIGINAL : "+ s.Mostrar(c)); 14 System.out.println("ORDENADO : "+ s.Mostrar(s.ordenar(c))); 15 } 16 17 //genera un array de n elementos enteros 18 public static int[] generarlista(int n){
D.
import java.util.Random; 02 /** 03 * @web http://jc-mouse.blogspot.com/ 04 * @author Mouse 05 */ 06 public class Main { 07 08 public static void main(String[] args) { 09 //creamos un array y llenamos este con numeros al azar 10 int[] c = null ; 11 c = generarlista(5); 12 seleccion s = new seleccion(); 13 System.out.println("ORIGINAL : "+ s.Mostrar(c)); 14 System.out.println("ORDENADO : "+ s.Mostrar(s.ordenar(c))); 15 } 16 17 //genera un array de n elementos enteros 18 public static int[] generarlista(int n){ 19 int[] v = new int[n]; 20 Random rand = new Random(); 21 for (int i=0; i
10. 
32 equipos calificaron para la Copa del Mundo 2014. Si los nombres de los equipos estuvieran ordenados (en un arreglo), ¿cuántos elementos en el arreglo tendría que examinar la búsqueda binaria para encontar la ubicación de un equipo particular en el arreglo, en el peor caso?
A.
16
B.
6
C.
32
D.
40