SHELL

La ordenacin Shell debe el nombre a su inventor, D.L. Shell. Se suele denominar tambin
ordenacin por insercin con incrementos decrecientes. Se considera que el mtodo Shell es
una mejora del mtodo de insercin directa.

a. Entrada Ordenada = MEJOR CASO
b. Entrada Orden Inverso = PEOR CASO
c. Entrada Desordenada = CASO AL AZAR


public void ordenacionshell(int a[])
{
int intervalo,i,j,k; //declara los nombres de las variables
int n=a.length-1; //la longitud del vector y no se desborde
intervalo=n/2; /lo que va a realizar con el numero de intervalo
while(intervalo>0)
{
for(i=intervalo;i<n;i++) //J es el intervalo y se compara con n y si es menor j incrementa i y
sigue comparando
{
j=i-intervalo;
while(j>=0)
{
k=j+intervalo;
if(a[j]<=a[k])//compara la variable primera con la variable que en ese momento esta en curso
{
j=-1;//si se cumple la condicin de arriba y es menor se decrementa j
}
else
{
intercambiar(a, j, j+1); //si no se cumple y es mayor aqu hace el intercambio de las variables
unido=Unir(unido , a); // trae a unido que realiza el enlace para poder generar el TXT
unido+="\n";
j-=intervalo;
}
}
}
intervalo=intervalo/2;
}
grabapasadas(unido,"C://Users//Naye//Desktop//shell//she.txt"); //este solo llama a
grabapasadas que genera la corrida y la ordenacin la muestra en un txt
}



MERGE SORT(MEZCLA SIMPLE)
Una tcnica para el diseo de algoritmos es "Dividir para conquistar". Los algoritmos de
este tipo se caracterizan por estar diseados siguiendo estrictamente las siguientes fases:
Dividir: Se divide el problema en partes mas pequeas.
Conquistar: Se resuelven recursivamente los problemas mas chicos.
Combinar: Los problemas mas chicos de combinan para resolver el grande.
Si el vector tiene mas de dos elementos se lo divide en dos mitades, se invoca
recursivamente al algoritmo y luego se hace un merge de las dos mitades ordenadas.

Anlsis del Algortimo Merge.
El algortimo de merge requiere de dos pasadas a los vectores a combinar, una para realizar
el merge y otra para copiar del vector auxiliar al vector original. El tiempo del algoritmo de
merge es T(n) = 2n

Propiedades.
El algoritmo de MergeSort es un algortimo de sort que presenta algunas propiedades
interesantes.

En primer lugar, el orden del algorimo es en el caso (n log n), y esto ocurre tanto en el
peor caso, como en el mejor caso, como medio ya que el tiempo que insume el algoritmo
no depende de la disposicin inicial de los elementos del vector.

En segundo lugar es un algoritmo que requiere de un espacio extra de almacenanimiento
para poder funcionar. A los algoritmos que realizan el sort dentro del mismo vector se les
denomina algoritmos de sort "in-situ". Claramente el algoritmo de MergeSort no pertenece
a esta familia.



Combinar Ordenar Recursividad
La funcin "mergesort" divide de forma recursiva la lista. En primer lugar, se subdivide
la lista original en medio de cada vez que se llama a s mismo de forma
recursiva. Cuando la recursividad alcanza un solo dgito, la funcin y luego retrocede y
comienza a ordenar la lista. Cada vez que la funcin da marcha atrs a una llamada a la
funcin anterior, fusiona dos mitades de una lista ms pequea, con el tiempo de
trabajo de nuevo a la lista completa. La funcin de "fusionar" parece hacer todo el
trabajo por la organizacin y copiar los valores en la lista, pero el corazn de una
combinacin de clase est en la funcin engaosamente simple "mergesort".

Combinar Clase
Una fusin especie tiene una lista que se ordenan y se divide de forma recursiva la lista
hasta llegar a los valores individuales, tales como los nmeros individuales. El tipo
entonces recombina los nmeros de forma ordenada, el tiempo de regresar una lista
ordenada. Una clase de la clasificacin bsica en Java contendr una lista para
ordenar, y llamar a una funcin principal de combinacin de la clasificacin que
define:
class Merge{
public int[] x;
public static void main(String[] args){
x = [5, 6, 3, 4, 7, 8, 10, 2];
mergeSort(x, 0, x.length-1);
}
}
Combinar Ordenar Funcin
Fuera de la clase principal residir una funcin de combinacin de clase. Esta funcin
segmentos de un rango de nmeros para ordenar la lista. Inicialmente, esta gama
representar toda la lista, pero como el tipo de mezcla continua, tardar slo la mitad
de la lista hasta llegar a las entradas individuales. Entonces, la funcin de combinacin
de clase se recombinar los elementos en grandes listas que se ordenan (Fuente 2):

public void mergeSort(int low, int hi){
if (low < hi) {
int middle = (low + hi) / 2;
mergeSort(low, middle);
mergeSort(middle + 1, hi);
merge(low, middle, hi);
}
}
Funcin Merge bsico
La funcin de fusin combinar dos listas despus de clasificarlos. Si la funcin recibe
elementos individuales, ordenar ellos. De lo contrario, tendr dos listas separadas, y
en funcin de los deseos de la orden del programador en orden ascendente o
descendente:

private void merge(int low, int mid, int hi) {
int[] copy = new int[x.length-1];
// Copy both parts into the helper array
for (int i = low; i <= hi; i++) {
copy[i] = x[i];
}
int i = low;
int j = mid + 1;
int k = low;
while (i <= mid && j <= hi) {
if (copy[i] <= copy[j]) {
x[k] = copy[i];
i++;
} else {
x[k] = copy[j];
j++;
}
k++;
}
while (i <= mid) {
x[k] = copy[i];
k++;
i++;
}
}
Mejor, peor y caso promedio

Mejor caso
En el caso de Mergesort el mejor caso es cuando se realiza una sola comparacin, es
decir cuando el elemento buscado es el primer punto medio obtenido de la suma del
ndice inicial y el ltimo.
Peor caso
El peor caso se da cuando requiere un tiempo de log2 N, es decir mientras ms divisiones
y comparaciones con el punto medio haya peor, por lo cual si se da el caso de realizar la
mayor cantidad de divisiones en un arreglo sera el peor caso para ste algoritmo.
Caso promedio
En ste caso, no es muy claro cuando sera un caso promedio, por lo cual se dice que
ste algoritmo no tiene un caso promedio.


MEZCLA DIRECTA
La idea central de este algoritmo consiste en la realizacin sucesiva de una particin y
una fusin que produce secuencias ordenadas de longitud cada vez mayor. En la primera
pasada la participacin es de longitud 1 y la fusin o mezcla produce secuencias
ordenadas de longitud 4. Este proceso se repite hasta que la longitud de la secuencia
para la particin sea mayor o igual que la longitud de la secuencia para la particin sea
mayor o igual que el nmero de elementos del archivo original.
El destino de los elementos combinados se cambia despus de que cada par ha sido
ordenado para llenar uniformemente las dos secuencias que son el destino. Despus de
cada pasada los dos extremos del arreglo intercambian de papel, la fuente se convierte en
el nuevo destino y viceversa.
Ordenacin por mezcla directa
La informacin a ordenar se encuentra almacenada en un fichero (f) con n registros
- se comienza copiado esa informacin en dos ficheros (f1 y f2) de longitud n/2
Proceso de ordenacin:
- se lee el primer registro de f1 y el primero de f2, se ordenan
entre s (fusin) y la pareja ordenada se guarda los segundos registros se ordenan y se
guardan se repite el proceso, que forman cuartetos que se almacenan en f1 y f2
- el proceso continua fusionando grupos de tamao.
La principal desventaja de esta ordenacin es el tiempo de ejecucin, debido a las
sucesivas operaciones de entrada y salida.

public static void distribucion(int rec){ // es el metodo principal de clace directa
try{ //
RandomAccessFile a0=new RandomAccessFile("Original.txt","r"); // genera datos
aleatorios
RandomAccessFile a1=new RandomAccessFile("Copia1.txt","rw");
RandomAccessFile a2=new RandomAccessFile("Copia2.txt","rw");

int nrl=0, nag=1; //var que juegan con las posiciones
int num=a0.readInt();//var que esta en el Archivo
while(num!=-1){
if(nrl==rec){
if(nag==1)
nag=2;
else
nag=1;
nrl=0;
}
if(nag==1)
a1.writeInt(num);
else
a2.writeInt(num);
num=a0.readInt();
nrl++;
}
a1.writeInt(-1);
a2.writeInt(-1);
a0.close();
a1.close();
a2.close();

a0=new RandomAccessFile("Original.txt","rw");
a1=new RandomAccessFile("Copia1.txt","r");
a2=new RandomAccessFile("Copia2.txt","r");

int ra1=a1.readInt();
int ra2=a2.readInt();

int nrla1=0;
int nrla2=0;

while(ra1 != -1 && ra2 != -1){
if(nrla1==rec || nrla2==rec ){
if(nrla1 == rec){
while(ra2 != -1 && nrla2 != rec ){
a0.writeInt(ra2);
ra2=a2.readInt();
nrla2++;
}
}
if(nrla2 == rec){
while(ra1 != -1 && nrla1 != rec ){
a0.writeInt(ra1);
ra1=a1.readInt();
nrla1++;
}
}
nrla1=0;
nrla2=0;
}
else{
if(ra1<=ra2){
a0.writeInt(ra1);
ra1=a1.readInt();
nrla1++;
}
else{
a0.writeInt(ra2);
ra2=a2.readInt();
nrla2++;
}
}
}

while(ra2 != -1){
a0.writeInt(ra2);
ra2=a2.readInt();
}
while(ra1!=-1){
a0.writeInt(ra1);
ra1=a1.readInt();
}
//-imprimir original, mandarlo como parametro
imprime("Original.txt","Original");
a0.writeInt(-1);
a0.close();
a1.close();
a2.close();
//imprimir au1 y au2
imprime("Copia1.txt","Copia1");
imprime("Copia2.txt","Copia2");

}catch(FileNotFoundException e){}
catch(IOException e){}
}


Ordenacin Rpida (QuickSort)
En la ordenacin rpida, la secuencia inicial de elementos se divide en dos subsecuencias de diferente
tamao. La obtencin de las dos subsecuencias es el proceso que acarrea ms tiempo mientras que la
combinacin de las subsecuencias ordenadas para obtener la secuencia final consume muy poco tiempo.
{Para dividir en dos la secuencia de elementos, se selecciona un elemento sobre el cual efectuar la divisin,
el PIVOTE. Se dividen los elementos en dos grupos, los elementos menores del lado izquierdo y aquellos
mayores del lado derecho.
Caso Mejor: Cuando el pivote, divide al conjunto en dos subconjuntos de igual tamao. En este caso hay dos
llamadas con un tamao de la mitad de los elementos, y una sobrecarga lineal.
(Entrada ordenada)
Caso Peor: Se podra esperar que los subconjuntos de tamao muy distinto proporcionen resultados malos.
{Supongamos que en cada paso de recursin slo hay un elemento menor a pivote. En tal caso el
subconjunto I (elementos menores que pivote) ser uno y el subconjunto D (elementos mayores o igual a
pivote) sern todos los elementos menos uno. El tiempo de ordenar 1 elemento es slo 1 unidad, pero
cuando n > 1.
(Entrada ordenada inverso)
Caso Medio: Complejidad O (nlog n).
(Entrada desordenada.)

//**********************************************************************************
public static void quicksort(int a[],int primero,int ultimo) // inicio de mtodo quicksort y declaracin de
parametros
{
int i, j,central; // inicializar i y j que son de tipo entero
double pivote; // inicializar el pivote y es de tipo double
central=(primero + ultimo)/2; // para poder sacar el centro la frmula es tomar el primer nmero + el
segundo entre 2.
pivote=a[central]; // pivote es el nmero a comparar en el centro
i=primero; // i representa el primero nmero que se encuentra en el lado izquierdo
j=ultimo; // j representa el ltimo nmero que se encuentra en el lado derecho.
do { // comienza el ciclo
while (a[i] < pivote) i++; // mientras la posicin a del vector [i] es < que el nmero a comparar sea el
pivote incrementa i.
while (a[j] > pivote) j--;// mientras el vector de a[j] sea > al pivote de crementara j.
if (i <=j) // si i es menor igual j
{
intercambiar(a, i, j); // intercambiar a i y j.
i++; // incrementar i
j--; // decrementa j
}
}while (i <=j); // mientras i<=j
if (primero <j) // si primero es menor j
quicksort(a, primero, j);// es el mismo proceso con sublista izd
if (i < ultimo) // si i<ultimo
quicksort(a, i, ultimo);// es el mismo proceso con sublista der
}




Ordenamiento de raz (radix sort).
Es un algoritmo de ordenamiento que ordena enteros procesando sus dgitos de
forma individual. Como los enteros pueden representar cadenas de caracteres por
ejemplo: nombres o fechas; Sin embargo radix sort no est limitado slo a los
enteros.
Este ordenamiento se basa en los valores de los dgitos reales en las
representaciones de posiciones de los nmeros que se ordenan.
En qu consiste este metodo?
Ordena por el valor de cada dgito (unidades, decenas, centenas,...).
No hace comparaciones entre datos.
Consiste en ir acomodando los nmeros primero por unidades, luego por decenas,
centenas, etc.
Reglas para ordenar.
Empezar en el dgito ms significativo y avanzar por los dgitos menos
significativos mientras coinciden los dgitos correspondientes en los dos nmeros.
El nmero con el dgito ms grande en la primera posicin en la cual los dgitos de
los dos nmeros no coinciden es el mayor de los dos (por supuesto s coinciden
todos los dgitos de ambos nmeros, son iguales).
Cul es su orden de complejidad?
O(n*d) donde d es el numero de digitos del valor mayor.
Cules son sus desventajas?
Se requiere conocer la cantidad de digitos del valor mximo (para saber cuando el metodo ya
acomodo todos los elementos).
Ventajas.
El ordenamiento es razonablemente eficiente si el nmero de dgitos en las
llaves no es demasiado grande.
Si las mquinas tienen la ventaja de ordenar los dgitos (sobre todo si estn
en binario) lo ejecutaran con mucho mayor rapidez de lo que ejecutan una
comparacin de dos llaves completas.

Estabilidad
Un algoritmo de ordenamiento se considera estable si preserva el orden relativo
de llaves iguales en la estructura de datos. Por ejemplo, si queremos ordenar por
calificacin una lista de asistencia que se encuentra ordenada alfabticamente, un
algoritmo estable produce una lista en la que los estudiantes con el mismo grado
se mantienen ordenados alfabticamente, mientras que un algoritmo inestable no
dejar trazas del ordenamiento original. La mayora de los mtodos bsicos son
estables, pero la mayora de los mtodos sofisticados no lo son.

BUSQUEDA SECUENCIAL
EN SI ESTE METODO LO QUE REALIZA ES QUE PIDE EL DATO Y VA COMPARANDO CON CADA UNO
DE LOS DATOS EXISTENTES EN EL VECTOR, SI LO RECORRE Y NO LO ENCUENTRA MUESTRA
MENSAJE DE QUE NO EXISTE EL DATO Y SI LO ENCUENTRA MUESTRA SU POSICION.
public static int BusquedaSecuencial(int vector[], int Elem){
//en la primera linea se crea el metodo BusquedaSecuencial y recibe el
vector y el element o dato a buscar

for (int i = 0; i < vector.length; ++i)
//SE crea el for que i inicia con 0, debeser menor que el vector y que va
a incrementar por cada pasada 1.
if (vector[i] == Elem)
//Si el dato en la posicion 1 es igual al dato que se pidio buscar
entonces
return i;
//Se regresa la posicion de I que es la que tiene el dato que se busca
return -1;
//sino se regresa menos uno que significa que el dato no existe y se
muestra un mensaje

}
La bsqueda secuencial es la tcnica ms simple para buscar un elemento en un arreglo. Consiste
en recorrer el arreglo elemento a elemento e ir comparando con el valor buscado (clave). Se
empieza con la primera casilla del arreglo y se observa una casilla tras otra hasta que se encuentra
el elemento buscado o se han visto todas las casillas. El resultado de la bsqueda es un solo valor,
y ser la posicin del elemento buscado o cero. Dado que el arreglo no est en ningn orden en
particular, existe la misma probabilidad de que el valor se encuentra ya sea en el primer elemento,
como en el ltimo. Por lo tanto, en promedio, el programa tendr que comparar el valor buscado
con la mitad de los elementos del arreglo.
El mtodo de bsqueda secuencial funciona bien con arreglos pequeos o para arreglos no
ordenados
Ventajas.
1. Es eficiente cuando un arreglo no est ordenado es la nica manera en la que se puede
emplear.

Desventajas.
1. Es muy lento.
2. Requiere mucho tiempo, debido a que se comparan uno a uno.
//ESTO PUEDE SERVIRLES
DIFERENCIAS ENTRE METODOS DE BUSQUEDA SECUENCIAL Y BINARIA
Se diferencian porque el mtodo secuencial realiza una bsqueda casilla por casilla y
comparndolas con el valor que se desea, y el mtodo binario realiza una bsqueda directa en el
centro del arreglo y la compara con el valor deseado.
En el caso del mtodo de bsqueda binaria, los arreglos deben estar nicamente ordenados, como
se plante anteriormente, por su parte el mtodo de bsqueda secuencial o lineal, puede
emplearse tanto en arreglos pequeos, como en aquellos que no estn ordenados.
En segundo orden, podemos ver que el mtodo de bsqueda binaria, es el mtodo ms eficiente
para encontrar elementos en un arreglo ordenado, lo contrario sucede con el mtodo de
bsqueda secuencial ya que este es muy lento, pero si los datos no estn en orden es el nico
mtodo que puede emplearse para hacer las bsquedas.


BUSQUEDA BINARIA
Se le da el nombre de bsqueda binaria por que el algoritmo divide en dos el arreglo, aludiendo al
concepto de bit, el cual puede tener dos estados. Est altamente recomendado para buscar en
arreglos de gran tamao. La nica condicin para usar este algoritmo es que los datos dentro del
arreglo estn ordenados de menor a mayor.
El algoritmo de bsqueda binaria funciona de la sig. forma: 1. Se declaran los ndices superior e
inferior. El inferior en 0 y el superior con el tamao del arreglo menos 1. 2. Se calcula el centro del
arreglo con la siguiente formula: centro = (superior + inferior) / 2 3. Verificamos si el arreglo en la
posicin centro es igual al dato que buscamos. Si es igual significa que encontramos el dato y
retornamos centro. 4. Si son diferentes verificamos si el arreglo en la posicin centro es mayor al
dato que queremos buscar. Si es mayor actualizamos superior: superior = centro - 1, si no
actualizamos inferior: inferior = centro + 1. 5. Volvemos al paso 2, hasta encontrar el dato que
buscamos.
VENTAJAS DESVENTAJAS La bsqueda binaria es un mtodo eficiente siempre que el vector est
ordenado. La bsqueda binaria proporciona un medio para reducir el tiempo requerido para
buscar en una lista. Es ms rpido por su recursividad, su mayor ventaja es con los archivos
extensos. El cdigo del procedimiento de esta bsqueda es corto en comparacin con las dems
tcnicas de bsqueda. El archivo debe estar ordenado y el almacenamiento de un archivo
ordenado suele plantear problemas en las inserciones y eliminaciones de elementos. No revisa
todos los elementos del archivo, requiere que todos los elementos estn ordenados.
Mejor Caso: En sus casos ptimos, tanto la bsqueda secuencial como la binaria requieren slo
una comparacin; esto significa que sus tiempos de ejecucin ptimos no dependen de la cantidad
de datos: son constantes y por tanto proporcionales a 1, es decir, son de O(1).

Peor Caso: En el peor caso, la bsqueda secuencial y la binaria s dependen de N. La primera
recorre todo el arreglo, requiriendo un tiempo de O(n); la binaria divide el arreglo, requiriendo
slo un tiempo O(log n).
package binaria;
import java.util.Scanner;
public class Binaria { // clase principal binaria
public static void main(String[] args) // campo
{
int a[],n,n1,indice;
Scanner sc=new Scanner(System.in);
System.out.print("Ingresa tamao de arreglo: "); // imprime el arreglo
n=sc.nextInt();
a=new int[n];
a=inicializa(n);
a=ordenarArreglo(a,n);
muestra(a);
System.out.print("Ingresa numero a buscar: ");
n1=sc.nextInt();
indice=busquedaBinaria(a,n1);
if(indice==-1)
{
System.out.println("tu nmero no esta en la lista"); // imprime se se encuentra o no }
else
{
System.out.println("tu nmero esta en el indice: "+indice);
}
}
static int[] inicializa(int n) //
{
int i,j,a[]=new int[n];
for(i=0;i<n;i++)
{
a[i]=randomxy(1,50);
}
return a;
}
static int busquedaBinaria(int a[],int n) // inicia el mtodo bsquedabinaria
{
int n1=a.length, Iarriba=n1-1, Iabajo=0, Icentro,indice=-1; //inicializo la longuitud
del vector

while (Iabajo<=Iarriba) // mientras abajo sea menor que arriba condicion
{
Icentro =(Iarriba + Iabajo)/2;
if (a[Icentro]==n) // si se cumple la condicin // empieza la primera condicion
{
indice=Icentro; // iguala
Iabajo=Iarriba+1; //iguala
}
Else // en caso contario
{
if (n<a[Icentro]) // vuelve a comparar
{
Iarriba=Icentro-1;
}
Else
{
Iabajo=Icentro+1; //
}
}
}
return indice+1; // regresa el ndice mas 1 e incrementa el valor
}
static int[] ordenarArreglo(int a[], int n) // empieza a ordenar el arreglo
{
int i,j,t; // daclara variables
for(i=0;i<n-1;i++) // empieza el ciclo
{
for(j=0;j<n-1;j++) //condicion
{
if(a[j]>a[j+1]) // condicion
{
t=a[j]; //intercambio
a[j]=a[j+1]; // intercambio
a[j+1]=t; // intercambio
}
}
}
return a; // retorna a
}
static void muestra(int a[] ) // mtodo de mostrar
{
int n=a.length;
for(int i=0;i<n;i++) //ciclo declara la posicin, pregunta la condicin y despus si se
cumple aumenta i
{
System.out.print(a[i]+" "); //imprime la posicin de i
}
System.out.print("\n\n"); // imprime salto de linea
}
static int randomxy(int x,int y) // mtodo ramdom
{
int ran=(int) (Math.floor(Math.random()*(y-x+1))+x); // genera los datos
aleatoriamente
return ran; // regresa los nmeros aletorios
}}