Algoritmos de Ordenamiento

con un comportamiento
logarítmico

Carrera: Ingeniería Civil Informática

Prof. : Carolina Toro
¿Qué aprendiste la semana pasada?
El uso de métodos de ordenamiento con un comportamiento cuadrático:
- sort burbuja
- sort inserción
- sort selección.

¿Qué veremos ésta semana?

1) Descripción y uso de métodos de ordenamiento con un comportamiento logarítmico:
- sort Shell
- sort Merge
- sort Quick
2) Descripción y uso de métodos de búsqueda secuencial o por fuerza bruta
 SORTSHELL
• La ordenación Shell debe el nombre a su inventor, D. L. Shell.
• Se suele denominar también ordenación por inserción con incrementos decrecientes.

• En el algoritmo de inserción, cada elemento se compara con los elementos contiguos de su izquierda, uno tras otro. Si
el elemento a insertar es el más pequeño, hay que realizar muchas comparaciones antes de colocarlo en su lugar
definitivo.
• El algoritmo de Shell , es similar al algoritmo de inserción, se diferencia en que modifica los saltos contiguos
resultantes de las comparaciones por saltos de mayor tamaño, y con ello se consigue que la ordenación sea más rápida.
Generalmente, se toma como salto inicial n/2 (siendo n el número de elementos), y luego se reduce el salto a la mitad
en cada repetición hasta que sea de tamaño 1. El método Shell es una mejora del método de inserción directa.
Ejemplo Sort Shell:
 package ordenamientocomplogaritmico;
import java.util.Scanner;

public class OrdenamientoCompLogaritmico {

Código Java del public static void ordenacionShell(int A[])

{ int salto, aux, i;

algoritmo de
boolean cambios;
for (salto = A.length / 2; salto != 0; salto /= 2) {
cambios = true;
while (cambios) { // Mientras se intercambie algún elemento

cambios = false;
for (i = salto; i < A.length; i++) // se da una pasada

SORT SHELL { if (A[i - salto] > A[i])

{ aux = A[i];
A[i] = A[i - salto];
// y si están desordenados
// se reordenan

A[i - salto] = aux;

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

Con sólo 6 intercambios se ha ordenado el array, }

cuando por inserción se necesitaban muchos más. }
}
El rendimiento del método Shell de ordenación es }
bastante aceptable, aún para el caso de un for(int h=0;h<A.length;h++)
número de elementos muy grande. { System.out.print(A[h]+",");}
}
Se ha comprobado que el tiempo de ejecución public static void main(String[] args)
promedio es de O(n2/3) para la mayoría de las { int[] miArrreglo= {50,26,7,9,15,77};
secuencias de salto. ordenacionShell(miArrreglo);
}
 QUICKSORT
• La primera etapa en el algoritmo de partición es obtener el elemento
pivote; una vez que se ha seleccionado, se ha de buscar el sistema para
situar en la sublista izquierda todos los elementos menores que el
pivote y en la sublista derecha todos los elementos mayores que él.
• Supongamos que todos los elementos de la lista son distintos, aunque
será preciso tener en cuenta los casos en que existan elementos
idénticos.
• Inicialmente se elige como pivote el elemento central de la lista actual
• La elección del pivote determinará la eficiencia de este algoritmo ya que determina la
partición del array.
Ejemplo Quick Sort :
Código Java del public static void quicksort(int A[], int izq, int der)
{int pivote=A[izq]; // tomamos primer elemento como pivote

algoritmo de int i=izq;

int j=der;
// i realiza la búsqueda de izquierda a derecha
// j realiza la búsqueda de derecha a izquierda
int aux;
while(i < j){ // mientras no se crucen las búsquedas

QUICKSORT
while(A[i] <= pivote && i < j) i++; // busca elemento mayor que pivote
while(A[j] > pivote) j--; // busca elemento menor que pivote
if (i < j) { // si no se han cruzado
aux= A[i]; // los intercambia
A[i]=A[j];
A[j]=aux;
Con sólo 6 intercambios se ha ordenado el array, }
cuando por inserción se necesitaban muchos más. }
A[izq]=A[j]; // se coloca el pivote en su lugar de forma que tendremos
El rendimiento del método Shell de ordenación es
bastante aceptable, aún para el caso de un
número de elementos muy grande. A[j]=pivote; // los menores a su izquierda y los mayores a su derecha
if(izq < j-1)
Se ha comprobado que el tiempo de ejecución quicksort(A,izq,j-1); // ordenamos subarray izquierdo
promedio es de O(n2/3) para la mayoría de las if(j+1 < der)
secuencias de salto. quicksort(A,j+1,der); // ordenamos subarray derecho
MERGESORT
• El método MergeSort es un algoritmo de ordenación recursivo con un número
de comparaciones entre elementos del array mínimo.
• Su funcionamiento es similar al Quicksort, y está basado en la técnica divide y
vencerás.
• De forma resumida el funcionamiento del método MergeSort es el siguiente:
• Si la longitud del array es menor o igual a 1 entonces ya está ordenado.
• El array a ordenar se divide en dos mitades de tamaño similar.
• Cada mitad se ordena de forma recursiva aplicando el método MergeSort.
• A continuación las dos mitades ya ordenadas se mezclan formando una
secuencia ordenada.
Ejemplo MergeSort :
 public static void mergesort(int A[],int izq, int der){
if (izq < der){
int m=(izq+der)/2;

Código Java del mergesort(A,izq, m);

mergesort(A,m+1, der);
merge(A,izq, m, der);
algoritmo de }
}

public static void mergesort(int A[],int izq, int m, int der)

{ int i, j, k;
MERGESORT int [] B = new int[A.length]; //array auxiliar
for (i=izq; i<=der; i++) //copia ambas mitades en el array auxiliar

B[i]=A[i];
El método ordena un array A de enteros desde la i=izq; j=m+1; k=izq;
posición izq hasta la posición der. En la primera llamada al while (i<=m && j<=der) //copia el siguiente elemento más grande
método recibirá los valores izq = 0, der = ELEMENTOS-1.
Primero se calcula el elemento central m. A continuación la
primera parte del array, desde izq hasta m y la segunda if (B[i]<=B[j])
parte del array, desde m+1 hasta der, se mezclan
mediante llamadas recursivas al método mergesort. A[k++]=B[i++];
La recursión termina cuando izq == der, es decir, cuando else
un subarray contiene solamente un elemento.
La operación principal de mezcla la realiza el A[k++]=B[j++];
método merge. Este método se puede implementar de while (i<=m) //copia los elementos que quedan de la
varias formas
A[k++]=B[i++]; //primera mitad (si los hay)
Búsqueda Secuencial o de Fuerza Bruta
• La búsqueda lineal o secuencial es el algoritmo de búsqueda más simple. 
• Si bien es ciertamente el más simple, definitivamente no es el más común, debido a su ineficiencia. 
• Es un algoritmo de fuerza bruta. 
• Muy raramente se usa en producción, y en la mayoría de los casos, es superado por otros algoritmos.
• La búsqueda lineal no tiene requisitos previos para el estado de la estructura de datos subyacente.

Explicación
Relájate
• La búsqueda lineal implica la búsqueda secuencial de un elemento en la estructura de datos dada hasta que se encuentra el
elemento o se llega al final de la estructura.
• Si se encuentra el elemento, generalmente devolvemos su posición en la estructura de datos. Si no, normalmente
devolvemos un -1 u otro valor nulo
 Este código es parte del main….
Código int[ ] miArreglo4={89,57,91,47,953,27,22,67,99};
Impresion(miArreglo4);

Java del int indice = buscarElemento(miArreglo4, 67); //buscar dónde se ubica el 67

mostrarIndice(67, indice);

algoritmo public static int buscarElemento(int arr[], int elementToSearch)

{ for (int index = 0; index < arr.length; index++)
de Relájate
{ if (arr[index] == elementToSearch)
return index;
}
return -1;

Búsqueda }

Secuencial public static void mostrarIndice(int elementToSearch, int index)

{ if (index == -1)
{System.out.println("\n\n"+elementToSearch + " No existe");}
else
{System.out.println("\n\n"+elementToSearch + " Se encuentra en el índice: " + index);}
}
¿Qué se aprendió hoy?
• Ya sabíamos que existen métodos de ordenamiento con un comportamiento cuadrático, entre ellos: Burbuja, Inserción y
Selección
• Que también existen métodos de ordenamiento con un comportamiento logarítmico, entre ellos: ShellSort, QuickSort
y MergeSort
• Que los métodos de comportamiento cuadrático son más fáciles de implementar y de entender, pero son
más ineficientes.

¿Qué dudas quedaron? Relájate

¿Qué veremos en el laboratorio de esta semana?

• Trabajaremos implementando los algoritmos y realizaremos un desafío utilizando dichos algoritmos
• El trabajo será evaluado, se desarrollar dentro del bloque horario, sólo para quienes asisten online
• El trabajo del grupo 1 y 2 será diferente