Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Trabajo
Práctico.
Bagua-Amazonas
EJERCICIOS
1. ¿Cuál es la diferencia entre ordenación por intercambio y ordenación por el
método de la burbuja?
El algoritmo del ordenamiento por intercambio es uno de los más sencillos, pero con el
rendimiento realmente bajo, se basa en la idea de buscar cada vez el menor elemento del
conjunto y ubicarlo al principio del arreglo, repitiendo este proceso sin incluir el primero
de los datos que ya se encuentra ordenado, hasta llegar a un conjunto de un elemento que
se encuentra ya ordenado.
El algoritmo por ordenamiento de Burbuja es uno de los más conocidos y más usado por
programadores, consiste en comparar pares de elementos adyacentes en un Array y si
están desordenados intercambiarlos hasta que estés ordenados. El rendimiento de este
algoritmo es mucho más eficaz que el algoritmo de intercambio.
2. Se desea eliminar todos los números duplicados de una lista o vector (array). Por
ejemplo, si el array toma los valores
4 7 11 4 9 5 11 7 3 5
ha de cambiarse a
4 7 11 9 5 3
Escribir un método que elimine los elementos duplicados de un array.
package practica_01;
import java.util.Scanner;
for(int i=0;i<arreglo.length;i++){
for(int j=0;j<arreglo.length-1;j++){
if(i!=j){
if(arreglo[i]==arreglo[j]){
// eliminamos su valor
arreglo[i]=0;
}
}
int n=arreglo.length;
if(arreglo[k]!=0){
System.out.print( arreglo[k]+",");
if(bbinaria!=-1){
int pos= bbinaria+1;
JOptionPane.showMessageDialog(null,"El dato se encuetra en el arreglo, en la posicion
" +pos);
}else{
JOptionPane.showMessageDialog(null,"El dato no se encuentra en el arreglo");
}
}
}
3) Escribir una función de búsqueda binaria aplicado a un array ordenado
descendentemente.
int n = Integer.parseInt(JOptionPane.showInputDialog(null,"ingrese el
tamaño del arreglo"));
arreglo[i]= Integer.parseInt(JOptionPane.showInputDialog(null,"ingrese
el numero ("+i+")"));
arreglo[j]=arreglo[j+1];
arreglo[j+1]= aux;
JOptionPane.showMessageDialog(null,Arrays.toString(arreglo));
int bBinaria=bBinaria(arreglo,dato);
JOptionPane.showMessageDialog(null,
}else{
JOptionPane.showMessageDialog(null,
centro=(inferior+superior)/2;
if(arreglo[centro] == dato){
return centro;
}else {
return -1;
package insercsion;
import java.util.*;
public class Insercsion {
Scanner leer = new Scanner(System.in);
public static void main(String[] args) {
int a[]={3 ,13, 8 ,25 ,45 ,23 ,98, 58};
Insercsion op= new Insercsion();
op.ordInsercion(a);
}
public void ordInsercion (int [] a)
{
System.out.println("el vector es:");
for (int i = 0; i <a.length; i++) {
System.out.print(a[i]+"||");
}
int i, j;
int aux;
for (i = 1; i < 3; i++)
{ /*indice j es para explorar la sublista a[i-1]..a[0] buscando la
posicion correcta del elemento destino*/
j = i;
aux = a[i];
// se localiza el punto de inserción explorando hacia abajo
while (j > 0 && aux < a[j-1])
{// desplazar elementos hacia arriba para hacer espacio
a[j] = a[j-1];
j--;
}
a[j] = aux;
}
System.out.println("");
System.out.println("el vector ordenado es:");
for (int k = 0; k <a.length ; k++) {
System.out.print(a[k]+"||");
}
}
}
8 43 17 6 40 16
18 97 11 7
7. Partiendo del mismo array que en el Ejercicio 6.6,
encuentre las particiones e intercambios que realiza el
algoritmo de ordenación Quicksort para su ordenación.
package provando;
import java.util.Arrays;
import java.util.Random;
int arreglo[] = {8, 43, 17, 6, 40, 16, 18, 97, 11, 7};
Shell(arreglo);
System.out.println(Arrays.toString(arreglo));
QuickSort(arreglo,0,arreglo.length-1);
System.out.println(Arrays.toString(arreglo));
int i, j, k, intervalo;
j = i - intervalo;
k = j + intervalo;
j = -1;
else
j -= intervalo;
intervalo = intervalo/2;
int i = izq;
int j = der;
do{
i++;
arreglo[i] = arreglo[j];
arreglo[j] = aux;
i++;
j--;
QuickSort(arreglo,izq,j);
QuickSort(arreglo,i,der);
package javaapplication106;
public class JavaApplication106 {
System.out.println("MAESTRO ESCLAVO");
for (int i = 0; i < 7; i++) {
System.out.println(Maestro[i]+" "+ Esclavo[i]);
System.out.println("");
System.out.println("ORDENANDO EN QUICKSORT");
OrdenarQuicSort(Maestro,0,Maestro.length-1 );
OrdenarQuicSortEsclavo(Esclavo,0,Esclavo.length-1 );
System.out.println("MAESTRO ESCLAVO");
for (int i = 0; i < Maestro.length; i++) {
System.out.println(Maestro[i]+" "+Esclavo[i]);
}
while(Maestro[i]<pivote){
i++;
}
while(Maestro[j]>pivote){
j--;
}
if(i<=j){
int aux =Maestro[i];
Maestro[i]=Maestro[j];
Maestro[j]=aux;
i++;
j--;
}
} while (i<=j);
if(pri<j){
OrdenarQuicSort(Maestro, pri,j);
}
if(i<ulti){
OrdenarQuicSort(Maestro, i, ulti);
}
while(Esclavo[i]<pivote){
i++;
}
while(Esclavo[j]>pivote){
j--;
}
if(i<=j){
int aux =Esclavo[i];
Esclavo[i]=Esclavo[j];
Esclavo[j]=aux;
i++;
j--;
}
} while (i<=j);
if(pri<j){
OrdenarQuicSort(Esclavo, pri,j);
}
if(i<ulti){
OrdenarQuicSort(Esclavo, i, ulti);
}
12. Supongamos que se tiene una secuencia de n números que deben ser
clasificados:
*Repetir el paso 1 para el método de Quicksort.
package ordenamientoquicksort;
}
public void imprimir(int A[]){
for (int k = 0; k < A.length; k++) {
System.out.print(A[k]);
}
System.out.println(" ");
System.out.printf("Comparaciones totales : %d",y);
System.out.printf("Cambios totales : %d",x);
}
}
Cuando se encuentra ordenado hace una sola pasada y ningún intercambio, por eso quicksort es
uno de los mejores algoritmos de ordenación.
Cuando se encuentra en orden inverso se realiza T(n)=2T(n/2)+ n-1 donde T es el pivote y para
el numero de intercambios nos basamos en el orden del quicksort T(n) - 0(n lg n).