El documento describe diferentes métodos de ordenamiento de datos, incluyendo el método de burbuja, método de selección, método de inserción, ordenamiento shell y ordenamiento quicksort. Explica los pasos y diagramas de flujo de cada método, y proporciona ejemplos de código Java para simular el funcionamiento de los algoritmos de ordenamiento.

1. CAZTELDARY MARTINEZ PEDRAZA
ANGELA MONTILLA
MIGUEL ANGEL CASTAÑEDA

2. En este método la información ingresa de forma
desorganizada; lo que realiza este ordenamiento es que
vector mueve el elemento mayor hasta la ultima casilla
esto se realizaría en la siguiente manera:
Índice cero del vector a acomoda este elemento hasta la
ultima posición para que de forma escalada se organiza
de mayor a menor

3. Como lo muestra la siguiente gráfica en la
casilla 0 correspondiente a seis que es el
ordenado paso a la ultima posición y se observa
que esta secuencia traslada el valor a la
primera posición.
Este proceso seguirá así hasta que halla
ordenado todas las casillas del vector.
Una de las desventaja de este método es que
hace duplicidad de la organización cuando esto
ya no es necesario.

5. Diagrama de flujo Método de burbuja y/o
intercambio

6. SIMULACION
• //METODO BURBUJA ESTE CODIGO PERMITE ORDENAR UNA SECUENTCIA DE
NOMBRES ALFABETICAMENTE
• //DE ACUERDO AL TAMAÑO QUE QUERAMOS TENER
• import java.util.*;
• class Burbuja5 {
• public static void main(String[] args) {
• // Valores que tiene el array A desordenado.
• Scanner tecla = new Scanner(System.in);
• Scanner key = new Scanner(System.in);
• int tam;
• System.out.println("ingrese tamano");
• tam = tecla.nextInt();
• String[] A= new String[tam];
• for(int i=0; i<A.length; i++)
• {
• System.out.println("ingrese texto: "+i);
• A[i] = key.nextLine();
• }
•
• //String[] B = A //coipa del arreglo
• // Imprimimos el array A desordenado.
• System.out.println("array A desordenado: ");
• for(int i=0; i<A.length; i++)
• {System.out.println( " A[" + i + "] = " + A[i] ); }
• // Inicio del metodo de ordenamiento de la Burbuja
• String aux;
• for(int i=1; i<=A.length; i++) {
• for(int j=0; j<A.length-i; j++) {
• if( A[j].compareTo( A[j+1] ) > 0 ) {
• aux = A[j];
• A[j] = A[j+1];
• A[j+1]= aux;
• }
• }
• }
• // Fin del metodo de ordenamiento de la Burbuja
• // Imprimimos el array A ordenado Burbuja.
• System.out.println("n array A ordenado: ");
• for(int i=0; i<A.length; i++)
• {System.out.println( " A[" + i + "] = " + A[i] ); }
•
• }
• }

7. El ordenamiento Shell (Shell sort en inglés). Su implementación
original, requiere O(n2) comparaciones e intercambios. Un cambio menor
presentado en el libro de V. Pratt produce una implementación con un
rendimiento de O(n log2 n). Esto es mejor que las O(n2) comparaciones
requeridas por algoritmos simples pero peor que el óptimo O(n log n).
Ventajas:
 El Shell sort es una generalización del ordenamiento por inserción
 El ordenamiento por inserción es eficiente si la entrada está "casi
ordenada".
Desventajas:
 El ordenamiento por inserción es ineficiente, en general, porque
mueve los valores sólo una posición cada vez.
 Es muy difícil analizar su tiempo de ejecución.

8. Divide el arreglo ordenándolo en varios grupos,
realizando comparaciones e intercambios entre
ellos, el tamaño de los grupos se decremento y el
número de los subgrupos se incrementa hasta
tener un ‘n’ grupo de tamaño en este punto su
funcionalidad es de inserción directa.

9. ALGORITMO METODO SHELL

10. DIAGRAMA DE FLUJO METODO DE
ORDENAMIENTO SHELL

11. SIMULACION
• //METODO SHELL ESTE METODO PERMITE ODENAR ALFABETICAMENTE UNA
LISTA DE NOMBRES
• //TENIENDO EN CUENTA LOS NOMBRES QUE SE INGRESEN
• package shell2;
public class Shell2 {
• public static void sort(Comparable[] a) {
• int N = a.length;
int h = 1;
• while (h < N/3) h = 3*h + 1;
• while (h >= 1) {
• for (int i = h; i < N; i++) {
• for (int j = i; j >= h && less(a[j], a[j-h]); j -= h) {
• exch(a, j, j-h);
• }
• }
• assert isHsorted(a, h);
• h /= 3;
• }
• assert isSorted(a);
• }
private static boolean less(Comparable v, Comparable w) {
• return v.compareTo(w) < 0;
• }
• // cambio de posiciones
• private static void exch(Object[] a, int i, int j) {
• Object swap = a[i];
• a[i] = a[j];
• a[j] = swap;
• }
• private static boolean isSorted(Comparable[] a) {
• for (int i = 1; i < a.length; i++)
• if (less(a[i], a[i-1])) return false;
• return true;
• }
• // is the array h-sorted?
• private static boolean isHsorted(Comparable[] a, int h) {
• for (int i = h; i < a.length; i++)
• if (less(a[i], a[i-h])) return false;
• return true;
• }

12. SIMULACION
• // Imprimir resultado
• private static void show(Comparable[] a) {
• for (int i = 0; i < a.length; i++) {
• System.out.println(a[i]);
• }
• }
• /**
• * Creacion del arreglo String
• */
• public static void main(String[] args) {
• String []a = {"armando","ursula","ernesto","nelson","pedro","blanca"};
• Shell2.sort(a);
• show(a);
• }
• }
• * Creacion del arreglo String
• */
• public static void main(String[] args) {
• String []a = {"armando","ursula","ernesto","nelson","pedro","blanca"};
• Shell2.sort(a);
• show(a);}}

13. Se puede definir como un procedimiento recursivo.
A diferencia del método burbuja trabaja mejor para elementos
de entrada desordenados completamente, que para elementos
semiordenados.
Este tipo de algoritmos se basa en la técnica "divide y
vencerás", o sea es más rápido y fácil de ordenar dos arreglos o
listas de datos pequeños , que un arreglo o lista grande.
Al inicio de la ordenación se escoge un elemento
aproximadamente en la mitad del arreglo, así al empezar a
ordenar, se debe llegar a que el arreglo este ordenado respecto
al punto de división o la mitad del arreglo.

14. PROCEDIMIENTO METODO DE
ORDENAMIENTO QUICK SORT
El proceso se repite hasta que la
subdivisión muestre un solo elemento de
algoritmo ordenado .

17. DIAGRAM QUICK SORT

18. SIMULACION
• //METODO QUICKSHORT QUE ORDENA DESORNADAMENTE UNA SECUENCUA
• public class Quicksort20 {
• private static int []a;
• public static void main(String[] args) {
• // Gerenerar array aleatoreo
• a = getArray();
• // imprima el array desordenado
• printArray();
• // ordenar
• sort();
• System.out.println("");
• //imprima el array ordenado
• printArray();
• }
• // Este metodo llama internamente al quicksort
• public static void sort(){
• int left = 0;
• int right = a.length-1;
• quickSort(left, right);
• }
• // Este metodo es para hacer uso del algoritmo quicksort.
• // Tener en cuenta el elemento de la izq y derec como parametro
• private static void quickSort(int left,int right){
•
• // Verificar si el valor de la izq es igual al der es porque se acabo el array
• if(left >= right)
• return;
• // Creacion del pivote
• int pivot = a[right];
• int partition = partition(left, right, pivot);
• // Quicksort es recursivo por ello se realiza este llamado al mismo metodo
• quickSort(0, partition-1);
• quickSort(partition+1, right);
• }
• // particion del array segun el algoritmo
• private static int partition(int left,int right,int pivot){
• int leftCursor = left-1;
• int rightCursor = right;
• while(leftCursor < rightCursor){
• while(a[++leftCursor] < pivot);
• while(rightCursor > 0 && a[--rightCursor] > pivot);
• if(leftCursor >= rightCursor){
• break;
• }else{
• swap(leftCursor, rightCursor);
• }
• }
• swap(leftCursor, right);
• return leftCursor;
• }
•

19. SIMULACION
• // Metodo para realizar el cambio de las posiciones comparadas
• public static void swap(int left,int right){
• int temp = a[left];
• a[left] = a[right];
• a[right] = temp;
• }
• public static void printArray(){
• for(int i : a){
• System.out.print(i+" ");
• }
• }
• public static int[] getArray(){
• int size=10;
• int []array = new int[size];
• int item = 0;
• for(int i=0;i<size;i++){
• item = (int)(Math.random()*100);
• array[i] = item;
• }
• return array;
• }
• }

20. Es una manera muy natural de ordenar para un ser humano, y
puede usarse fácilmente para ordenar un mazo de cartas
numeradas en forma arbitraria. Requiere O(n²) operaciones
para ordenar una lista de n elementos.
Se tiene un elemento, que obviamente es un conjunto
ordenado. Después, cuando hay k elementos ordenados de
menor a mayor, se toma el elemento k+1 y se compara con
todos los elementos ya ordenados, deteniéndose cuando se
encuentra un elemento menor mostrando los elementos
mayores desplazados en una posición a la derecha o cuando ya
no se encuentran elementos (todos los elementos fueron
desplazados y este es el más pequeño). En este punto
se inserta el elemento k+1 debiendo desplazarse los demás
elementos.

21. PROCESO DEL METODO DE INSERCION
Realiza comparaciones equilibradas
con respecto a intercambios

23. DIAGRAMA DE INSERCCION

24. Este método de ordenamiento se base en lo siguiente:
• Entre los elemento busca el mayor numero.
• Poner el mayor al final (intercambiar el que está en
la última posición de la lista con el mayor
encontrado).
• Buscar el mayor de todos los elementos del
segmento de la lista entre la primera y la anteúltima
posición
• Poner el mayor al final del segmento (intercambiar
el que está en la última posición del segmento, o
sea anteúltima posición de la lista, con el mayor
encontrado).
•

25. METODO DE SELECCION

26. Esta basado en la división sucesiva del espacio ocupado por el
vector en sucesivas mitades hasta encontrar el elemento
buscado.
• Examina los elemento centrales de la lista, este proceso se
ejecuta en la segunda mitad de la lista.
• Se realiza la búsqueda en vectores ordenados.
• En conclusión este método realiza las búsquedas en bloques
en forma secuencial hasta encontrar dentro de la estructuran
de la base de datos el valor buscado,

27. FLUJO GRAMA BINARIO O SECUENCIAL

28. SIMULACION
• METODO DE BUSQUEDA BINARIA EL CUAL PERMITE BUSCAR LA POSICION EN
LA QUE SE ENCUENTRA
• //EL NOMBRE DE UNA PERSONA EMPEZANDO DESDE LA POSICION 0
• package binary_search;
• import java.util.Arrays;
• public class Binary_search {
• public static void main(String[] args) {
• //
• String num[]={"alvaro","vivivana","ximena"};
• int posicion;
• String buscar="alvaro";
• // Buscamos la posicion del primer valor
• // Si el array no esta ordenado nos puede dar un valor erroneo
• posicion=Arrays.binarySearch(num, buscar);
• System.out.println("Array no ordenado. Encontrado en el indice:
"+posicion);
• // Ordenamos el array
• Arrays.sort(num);
• // Buscamos la posicion del primer valor
• posicion=Arrays.binarySearch(num, buscar);
• System.out.println("Array ordenado. Encontrado en el indice:
"+posicion);
• }
• }