metodos ordenamiento

1. METODOD DE LA BURBUJA
class 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]);

2. }
}
SELECCIÓN DIRECTA

3. 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." );
}

4. }
}
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;

5. }
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.

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

7. 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

8. AGREGAR" ;
agregar();
}

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

10. CREAR" ;
crear();
}

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

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

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

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

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

16. 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);
}
}