Metodo de shell

Es una version mejorada del metodo de insercion directa. Recibe este nombre en honor a su autor. Donald
L.Shell, quien lo propuso en 1959. Este metodo tambien se conoce como insercion con incrementos
decrecientes como elementos decrecientes. Shell propone que las comparaciones entre elementos se
efectuen con saltos de mayor tamaño, pero con incrementos decrecientes; asi los elementos quedaran
ordenados en el arreglo mas rapidamente.

/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package javaapplication7;
import javax.swing.JOptionPane;
/**
*
* @author CSFH
*/
public class JavaApplication7 {
/**
* @param args the command line arguments
*/

public static void main(String[] args) {

// TODO code application logic here
int [] c1,c2;
String[] Nombre;
int longitud,salto,j;
int O = 0;
 int aux,aux2,aux3,aux4;
String aux1;
String resultado="";
boolean cambios;
longitud =Integer.parseInt(JOptionPane.showInputDialog("Ingrese una Cantidad de automoviles a
capturar "));
c1 = new int[10];
c2 = new int[10];
Nombre = new String[10];
for(int i=0; i<longitud ; i++){
Nombre[i]=JOptionPane.showInputDialog("Ingresar modelo del automovil : ");
c1[i]=Integer.parseInt(JOptionPane.showInputDialog("Ingresar el año de fabricacion del automovil "));
c2[i]=Integer.parseInt(JOptionPane.showInputDialog("Ingresar el numero de placas del automovil"));
}
String repetir="si";
// int CapPer;
// int Tam = longitud;
while(repetir.equals("si")){
resultado="";
// JOptionPane.showMessageDialog(null,resultado);
O = Integer.parseInt(JOptionPane.showInputDialog("ingresa una opcion"+ "\n 2 - Ordenar por año de
fabricación"
+ "\n 3 - Ordenar por numero de placas"))
if(O==2){
for(salto=longitud/2; salto!=0; salto/=2){
cambios=true;
while(cambios){ // Mientras se intercambie algún elemento
cambios=false;
for(j=salto; j<longitud; j++) // se da una pasada
if(c1[j-salto]>c1[j]){ // y si están desordenados
aux2=c2[j];
c2[j]=c2[j-salto];
c2[j-salto]=aux2;
aux=c1[j]; // se reordenan
c1[j]=c1[j-salto];
 c1[j-salto]=aux;
aux1=Nombre[j];
Nombre[j]=Nombre[j-salto];
Nombre[j-salto]=aux1;

cambios=true;
}}}}

if(O==3)
{
for(salto=longitud/2; salto!=0; salto/=2){
cambios=true;
while(cambios){ // Mientras se intercambie algún elemento
cambios=false;
for(j=salto; j<longitud; j++) // se da una pasada
if(c2[j-salto]>c2[j]){ // y si están desordenados
aux=c1[j]; // se reordenan
c1[j]=c1[j-salto];
c1[j-salto]=aux;
aux2=c2[j];
c2[j]=c2[j-salto];
c2[j-salto]=aux2;
aux1=Nombre[j];
Nombre[j]=Nombre[j-salto];
Nombre[j-salto]=aux1;

cambios=true; // y se marca como cambio.

}}}}
for(int i=0; i<longitud ; i++) {
resultado=resultado+ " Modelo del automovil : " + Nombre[i] + ": \n " + " Año de fabricación : " + c1[i]
+ " , \n " + " Numero de placas : " + c2[i] + " \n ";
}
JOptionPane.showMessageDialog(null,resultado);

repetir=JOptionPane.showInputDialog("Desea continuar? ");

 }

// TODO code application logic here

}
}
 Metodo Quicksort
Es probablemente la tecnica mas rapida conocida. Fue desarrollada por C.A Hoare
en 1960. El método es posiblemente el más pequeño en código, más rápido, más
elegante y más interesante y eficiente de los algoritmos conocidos de ordenación.
El método se basa en dividir los elementos de la lista a ordenar en dos partes o
particiones separadas por un elemento, una partición “izquierda” un elemento
central denominado pivote o elemento de partición, y una partición “derecha”, La
partición se hace de tal forma que todos los elementos de la partición izquierda
son menores que todos los elementos de la partición derecha, por lo que las dos
sublistas se ordenan entonces independientemente, para dividir la lista en
particiones se elige uno de los elementos de la lista y se utiliza como pivote o
elemento de partición.
int i,aux;

String au;

int array[];

int x;

int z[],a[];

String y[];

String resultado ="";

String resultado2="";

x=Integer.parseInt(JOptionPane.showInputDialog("Ingrese cantidad de autos :"));

y=new String[x];

z= new int [x];

a= new int [x];

for(int q=0; q<x ; q++){

y[q] =JOptionPane.showInputDialog("Ingresar Modelo :");

z[q]=Integer.parseInt(JOptionPane.showInputDialog("Ingresar Año :"));

a[q] = Integer.parseInt(JOptionPane.showInputDialog("Ingresar Placa :"));

 }

//JOptionPane.showMessageDialog(null,"Quick Sort");

//JOptionPane.showMessageDialog(null,"Valores antes de QuickSort:");

for(i = 0; i < a.length; i++)

resultado=resultado+"Modelo: "+y[i]+"\n"+"Año: "+z[i]+"\n"+"Placa: "+a[i]+"\n"+"\n";

JOptionPane.showMessageDialog(null,""+resultado);

boolean opcion = true;

while (opcion =true){

int seleccion = JOptionPane.showOptionDialog(null,

"Ordenar por",

"Seleccion De Opciones",

JOptionPane.YES_NO_CANCEL_OPTION,

JOptionPane.QUESTION_MESSAGE,

null, // null para icono por defecto.

new Object[] { "Por Placa", "Por Año","Salir" }, // null para YES, NO y CANCEL

"");

resultado2="";

if (seleccion == JOptionPane.YES_OPTION){

Quicksort(a,z,y,0,a.length-1);

//JOptionPane.showMessageDialog(null,"Valores despues de QuickSort:");

for(i = 0; i <a.length; i++)

resultado2=resultado2+"Modelo: "+y[i]+"\n"+"Año: "+z[i]+"\n"+"Placa: "+a[i]+"\n"+"\n";

JOptionPane.showMessageDialog(null,""+resultado2);

if (seleccion == JOptionPane.NO_OPTION) {

Quicksort(z,a,y,0,a.length-1);
 //JOptionPane.showMessageDialog(null,"Valores despues de QuickSort:");

for(i = 0; i <a.length; i++)

resultado2=resultado2+"Modelo: "+y[i]+"\n"+"Año: "+z[i]+"\n"+"Placa: "+a[i]+"\n"+"\n";

JOptionPane.showMessageDialog(null,""+resultado2);

opcion = false;

if (seleccion == JOptionPane.CANCEL_OPTION){

System.exit(0);

} } }

static void Quicksort(int arr[],int arr1[],String arr3[], int p, int r){

if(p < r)

int q = Particion(arr,arr1,arr3, p, r);

Quicksort(arr,arr1,arr3, p, q - 1);

Quicksort(arr,arr1,arr3, q + 1, r);

}}

static int Particion(int arr[],int arr1[],String arr3[], int p, int r){

int x = arr[r];

int i = p - 1, t;

String w;

for(int j = p; j < r; j++)

if(arr[j] <= x) {

i++;

t = arr[i];

arr[i] = arr[j];
 arr[j] = t;

t = arr1[i];

arr1[i] = arr1[j];

arr1[j] =t;

w = arr3[i];

arr3[i] = arr3[j];

arr3 [j] = w;

}}

t = arr[i + 1];

arr[i + 1] = arr[r];

arr[r] = t;

t = arr1[i+1];

arr1[i+1]=arr1[r];

arr1[r] = t;

w = arr3 [i + 1];

arr3[i + 1] = arr3[r];

arr3[r] = w;

return i + 1;

}
Estructura de datos II
Practicas
Metodo de shell
Metodo Quicksort