METODOD DE LA BURBUJAclass OrdenaAlgoritmo { public static void ordenar( int [] arreglo) { int pasadas = 0; int comparaciones = 0; for (int i = 0; i < arreglo.length; i++) { ++pasadas; for (int j = 0; j < arreglo.length - 1; j++) { ++comparaciones; if (arreglo[j] > arreglo[j + 1]) { intercambiar(arreglo, j, j+1); } } } estadisticas(pasadas, comparaciones); }

public static void ordenarMejorado( int [] arreglo) { int pasadas = 0; int comparaciones = 0; boolean hayCambios = true; for (int i = 0; hayCambios ; i++) { ++pasadas; hayCambios = false; for (int j = 0; j < arreglo.length - 1; j++) { ++comparaciones; if (arreglo[j] > arreglo[j + 1]) { intercambiar(arreglo, j, j+1); hayCambios = true; } } } estadisticas(pasadas, comparaciones); }

private static void intercambiar(int [] arreglo, int a, int b) { int tmp = arreglo[a]; arreglo[a] = arreglo[b]; arreglo[b] = tmp; }

private static void estadisticas( int pasadas, int comparaciones) { System.out.println( "Pasadas: " + pasadas ); System.out.println( "Comparaciones: " + comparaciones ); }}

public class OrdenaBurbuja { public static void main (String args[]) {

int [] valores = {15,35,01,05,04,03,19,45,13,02,55,8, 78,997,451,546,12,16,24,103,99,784, 4541,15};

//OrdenaAlgoritmo.ordenar(valores); OrdenaAlgoritmo.ordenarMejorado(valores); // Mostrar arreglo. for (int i = 0; i < valores.length ; i++) System.out.println ( "valores["+i+"]: "+ valores[i]);

}}

SELECCIÓN DIRECTA

BUSQUEDA BINARIA

class BusquedaAlgoritmo { public static int buscar( int [] arreglo, int dato) { int inicio = 0; int fin = arreglo.length - 1; int pos; while (inicio <= fin) { pos = (inicio+fin) / 2; if ( arreglo[pos] == dato ) return pos; else if ( arreglo[pos] < dato ) { inicio = pos+1; } else { fin = pos-1; } } return -1; }}

public class BusquedaBinaria { public static void main (String args[]) { // Llenar arreglo int [] edades = new int [35]; for (int i = 0; i < edades.length ; i++) edades[i] = i*i ;

// Mostrar arreglo. for (int i = 0; i < edades.length ; i++) System.out.println ( "edades["+i+"]: "+ edades[i]);

int resultado = BusquedaAlgoritmo.buscar(edades, 9);

if (resultado != -1) { System.out.println ( "Encontrado en: "+ resultado); } else { System.out.println ( "El dato no se encuentra en el arreglo, o el arreglo no está ordenado." ); }

}}METDODO DEL QUICKSORT

Me base en aquel entonces en el libro de “Data Structures and Algorithms in java” de Robert Lafore.

class QuickSort{

private long[] a;

private int nElems;

public QuickSort(int max){a=new long[max];

nElems=max;

}

public void llenar(long value){

for(int k=0; k<value; k++)

a[k]=(int)(Math.random()*100);

}

public void display(){

for(int l=0; l<nElems; l++)

System.out.print(a[l]+" ");System.out.println("");

}

public void quickSort(){

recQuickSort(0, nElems-1);

}

public void recQuickSort(int left, int right){if(right-left<=0)    return;

else{

long pivot=a[right];

int partition=partitionIt(left, right, pivot);

recQuickSort(left, partition-1);

recQuickSort(partition+1, right);}}public int partitionIt(int left, int right, long pivot){

int leftPtr=left-1;

int rightPtr=right;

while(true){

while(a[++leftPtr]<pivot);

while(rightPtr>0&&a[--rightPtr]>pivot);

if(leftPtr>=rightPtr)break;

else swapqs(leftPtr, rightPtr);

}

swapqs(leftPtr, right);return leftPtr;

}

public void swapqs(int dex1, int dex2){

long temp=a[dex1];

a[dex1]=a[dex2];

a[dex2]=temp;

}

}/*end class*/

/*y está es nuestra interfaz*/

 

class QuickSortApp{public static void main(String[] args){

int cien=100;

QuickSort arr;

arr=new QuickSort(cien);arr.llenar(cien);

arr.display();

arr.quickSort();

arr.display();

}}

2DO METODO DE QUICKSORT

ste código lo hize solo con JOption y un Objeto sencillo con datos primitivos es mas sencillo espero les sirva!!!!1

import javax.swing.JOptionPane; /* * @uthor: Sir FaCu.....

* xfiire: facu1 */ public class Quicksortorden { mercado cab=null; mercado fin=null; mercado aux=null; public static void main(String[] args) { Quicksortorden a=new Quicksortorden(); a.menu(); } void menu() { int op=0; do{ op=Integer.parseInt(JOptionPane.showInputDialog("QUICKSORTnnt1. CREAR MERCADOnt2.

AGREGAR MERCADOnt3.ORDENAR QUICKSORTnt4.SALIR" ); switch(op) {

case 1:crear(); break; case 2:agregar(); break; case 3:aux=cab; while(aux!=null) { quick(aux,0,20); quickpresion(aux); aux=aux.sig; } break; } }while(op!=4); } void crear() { if(cab==null) { cab=new mercado(); } else { JOptionPane.showMessageDialog(null,"YA EXISTE UN MERCADO SERA REDIRECCIONADO A

AGREGAR" ; agregar(); }

} void agregar() { if(cab==null) { JOptionPane.showMessageDialog(null,"NO EXISTE UN MERCADO SERA REDIRECCIONADO A

CREAR" ; crear(); }

else { aux=new mercado(); fin.sig=aux; fin=aux; } } static void quick(mercado aux, int p, int r) {

System.out.println("quick ini" ; if(p < r) {

System.out.println("p es "+p+" r= "+r); int q = dividir(aux, p, r); quick(aux, p, q - 1); quick(aux, q + 1, r); }

System.out.println("quick fin" ; } static int dividir(mercado aux, int p, int r)

{

System.out.println("partir" ; int x = aux.vec[r];

int i = p - 1, t; System.out.println("p es "+p+" r= "+r+"i es "+i); for(int j = p; j < r; j++) { if(aux.vec[j] <= x) { i++; t = aux.vec; aux.vec = aux.vec[j]; aux.vec[j] = t; } } t = aux.vec[i + 1]; aux.vec[i + 1] = aux.vec[r]; aux.vec[r] = t; return i + 1; } public void quickpresion(mercado aux) { String cad=""; while(aux!=null) { for(int i=0;i<10;i++) { cad=cad+" - "+String.valueOf(aux.vec)+" - "; } aux=aux.sig; } JOptionPane.showMessageDialog(null,"ORDENAMIENTO QUICKSORT: n "+cad); }

}