ESTRUCTURA

DE DATOS

METODOS: BURBUJA, QUICKSORT,

SHELL

Lucy Elen Alamilla Hernandez

INGENIERIA EN SISTEMAS
COMPUTACIONALES
ESTRUCTURA DE DATOS
El ordenamiento burbuja
El ordenamiento burbuja hace múltiples pasadas a lo largo de una lista. Compara los ítems
adyacentes e intercambia los que no están en orden. Cada pasada a lo largo de la lista ubica el
siguiente valor más grande en su lugar apropiado. En esencia, cada ítem “burbujea” hasta el lugar al
que pertenece.
La Figura 1 muestra la primera pasada de un ordenamiento burbuja. Los ítems sombreados se
comparan para ver si no están en orden. Si hay n ítems en la lista, entonces hay n−1n−1 parejas de
ítems que deben compararse en la primera pasada. Es importante tener en cuenta que, una vez que
el valor más grande de la lista es parte de una pareja, éste avanzará continuamente hasta que la
pasada se complete.

Figura 1: La primera pasada de ordenamientoBurbuja

Al comienzo de la segunda pasada, el valor más grande ya está en su lugar. Quedan n−1n−1 ítems por
ordenar, lo que significa que habrá n−2n−2 parejas. Puesto que cada pasada ubica al siguiente valor
mayor en su lugar, el número total de pasadas necesarias será n−1n−1. Después de completar la
pasada n−1n−1, el ítem más pequeño debe estar en la posición correcta sin requerir procesamiento
adicional. El ActiveCode 1 muestra la función ordenamientoBurbuja completa. La función recibe la lista
como un parámetro, y lo modifica intercambiando ítems según sea necesario.
La operación de intercambio es ligeramente diferente en Python que en la mayoría de los otros
lenguajes de programación. Normalmente, el intercambio de dos ítems en una lista requiere una
ubicación de almacenamiento temporal (una ubicación de memoria adicional). Un fragmento de
código como

temp = unaLista[i]

unaLista[i] = unaLista[j]

unaLista[j] = temp

intercambiará los ítems ii-ésimo y jj-ésimo de la lista. Sin el almacenamiento temporal, uno de los
valores sería sobrescrito.
En Python es posible realizar la asignación simultánea. La instrucción a,b=b,a dará lugar a que se
realicen dos instrucciones de asignación al mismo tiempo (véase la Figura 2). Usando la asignación
simultánea, la operación de intercambio se puede hacer en una sola instrucción.
Las líneas 5-7 en el ActiveCode 1 realizan el intercambio de los ítems ii-ésimo e (i+1)(i+1)-ésimo
utilizando el procedimiento de tres pasos descrito anteriormente. Note que también podríamos haber
utilizado la asignación simultánea para intercambiar los ítems.

Figura 2: Intercambio de dos valores en Python

CODIGO
import java.io.*;

public class burbuja

{
public static void main(String arg[]) throws IOException
{
/*creacion del objeto para leer por teclado*/
BufferedReader in = new BufferedReader(new
InputStreamReader(System.in));
/*ingreso del tamaño de arreglos*/
System.out.print("\n Ingrese Numero de Datos a Ingresar : ");
int tam = Integer.parseInt(in.readLine());
/*creacion del arreglo*/
int arr[] = new int[tam];
System.out.println();
/*lectura del arreglo*/
int j = 0;
for (int i = 0 ; i < arr.length;i++)
{
j+=1;
System.out.print("Elemento " + j + " : ");
arr[i] = Integer.parseInt(in.readLine());
}
burbuja(arr);
}

static void burbuja(int arreglo[])

{
for(int i = 0; i < arreglo.length - 1; i++)
{
 for(int j = 0; j < arreglo.length - 1; j++)
{
if (arreglo[j] < arreglo[j + 1])
{
int tmp = arreglo[j+1];
arreglo[j+1] = arreglo[j];
arreglo[j] = tmp;
}
}
}
for(int i = 0;i < arreglo.length; i++)
{
System.out.print(arreglo[i]+"\n");
}
}
}

PANTALLAZO
 ORDENAMIENTO RAPIDO O QUICKSORT

ALGORITMO DE ORDENAMIENTO RAPIDO O QUICKSORT

Este algoritmo esta basado en la tecnica divide y vencerás (consiste en dividir el problema en pequeños
subproblemas mas sencillos para luego estos ser resueltos con un calculo mas sencillo) asi crearemos arreglos
mas pequeños para ordenar estos.

Los pasos que realiza este algoritmo son:

1. Selecciona un valor del arreglo como pivote es decir un numero por el cual todos los elementos van a ser
comparados.
2. se realizan dos búsquedas: una de izquierda a derecha, buscando un elemento mayor que el pivote, y otra
de derecha a izquierda, buscando un elemento menor que el pivote. Cuando se han encontrado los dos, se
intercambian, y se sigue realizando la búsqueda hasta que las dos búsquedas se encuentran.
3. luego se organizan los subarreglos que quedaron a mano derecha y izquierda.

Ejemplo:

Tenemos un arreglo que esta definido con los valores {22,40,4,10,12,35} los pasos en quicksort para
arreglarlo son los siguientes:

1. se toma como pivote el numero 22 recuerden puede ser cualquier numero.

2. la búsqueda de izquierda a derecha encuentra el valor 40 que es mayor a pivote y la búsqueda de
derecha a izquierda encuentra el valor 35 no lo toma porque es mayor a el numero pivote (recuerden que
la búsqueda de derecha a izquierda busca los menores) entonces continua y encuentra a 12 que es menor
que el pivote y se intercambian el resultado seria {21,12,4,10,40,35}
3. si seguimos la búsqueda la primera encuentra el valor 40, y la segunda el valor 10,pero ya se han
cruzado,así que paramos. Para terminar la división, se coloca el pivote en su lugar el numero encontrado
por la segunda busqueda, el 10 quedando: {10,12,4,22,40,35}
4. ahora tenemos dividido el arreglo en dos arreglos mas pequeños que son {10,12,4} y el {40,35}, y en ellos se
repetirá el mismo proceso.
CODIGO

public class QuickSort{

public static void main(String a[]){
int i;
int array[] = {12,9,4,99,120,1,3,10,13};
System.out.println(" Quick Sort\n");
System.out.println("Valores antes de QuickSort:\n");
for(i = 0; i < array.length; i++)
System.out.print( array[i]+" ");
System.out.println();
quick_srt(array,0,array.length-1);
System.out.print("\n\n\nValores despues de QuickSort:\n\n");

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

System.out.print(array[i]+" ");
System.out.println();
}
public static void quick_srt(int array[],int low, int n){
int lo = low;
int hi = n;
if (lo >= n) {
return;
}
int mid = array[(lo + hi) / 2];
while (lo < hi) {
while (lo<hi && array[lo] < mid) {
lo++;
}
while (lo<hi && array[hi] > mid) {
hi--;
}
if (lo < hi) {
int T = array[lo];
array[lo] = array[hi];
array[hi] = T;
}
}
if (hi < lo) {
int T = hi;
hi = lo;
lo = T;
}
 quick_srt(array, low, lo);
quick_srt(array, lo == low ? lo+1 : lo, n);
}
}

PANTALLAZO
 Método de Shell (Shell Sort)
El método Shell (en honor a su descubridor) mejor del método de inserción
simple ordenando subarrreglos del arreglo original en forma separada. Para
crear estos nuevos subarreglos, se toman elementos saltados del areglo original
en relación a incrementos predeterminados.

Por ejemplo suponiendo un arreglo X, y tomando un incremento (salto) igual a

5, se generarían los siguientes subarreglos:

Subarreglo 1: X[0] X[5] X[10] ...

Subarreglo 2: X[1] X[6] X[11] ...
Subarreglo 3: X[2] X[7] X[12] ...
Subarreglo 4: X[3] X[8] X[13] ...
etc.

Con un salto igual a 3 se obtendrían:

Subarreglo 1: X[0] X[3] X[6] ...

Subarreglo 2: X[1] X[4] X[7] ...
Subarreglo 3: X[2] X[5] X[8] ...
Subarreglo 4: X[3] X[6] X[9] ...
etc.

Lo habitual es tomar un valor de incremento, y ordenar mediante inserción los

subarreglos obtenidos. Luego se toma otro valor de incremento, y se ordenan
ahora los asubarreglos generados a partir de este incremento. Y así
sucesivamente para diferentes valores de incremento o salto.

Supongamos que tenemos el siguienmte arreglo:

25 57 48 37 12 92 86 33

y que se elige la secuencia de incrementos (5,3,1), los archivos a ordenar para

esta secuencia serían:

con incremento = 5:

(x[0], x[5])
(x[1], x[6])
(x[2], x[7])
(x[3])
(x[4])

con incremento = 3:

(x[0], x[3], x[6])

(x[1], x[4], x[7])
(x[2], x[5])

con incremento = 1:

(x[0], x[1], x[2], x[3], x[4], x[5], x[6], x[7])

A continuación se muestra el resultado del ordenamiento Shell sobre este

arreglo. Las líneas indican los subarreglos que se procesan por separado.

arreglo original o 25 57 48 37 12 92 86 33
paso 1
o 25 57 48 37 12 92 86 33
salto = 5

paso 2
25 57 33 37 12 92 86 48
salto = 3

paso 3
25 12 33 37 48 92 86 57
salto = 1

Arreglo ordenado 25 12 33 37 48 57 86 92
CODIGO

public class shell_sort {

public static void shellSort( int b[ ]){
for(int k= b.length/2; k>0; k=k==2?1:(int)( k/2.2)){
for(int i=k;i<b.length; i++ ){
int tmp =b[i];
int j;
for(j=i; j>=k&&tmp<b[j-k]; j-=k){
b[j]=b[j-k]; }
b[j]=tmp;
}
}
}
public static void main(String args[]){
int a[]={321, 6, 1, 234, 213, 4, 5, 123};
System.out.println("Antes del ordenamiento");
for(int i=0;i<a.length;i++)
{
System.out.print(a[i]+" ");
}
shellSort(a);
System.out.println("\n");
System.out.println("Ordenado por el método Shell");
for (int i=0;i < a.length;i++){
System.out.print(a[i]+" ");
}
}
}
PANTALLAZO