ANÁLISIS Y DISEÑO DE

ALGORITMO
PRESENTA:
ALGORITMO DE ORDENAMIENTO BURBUJA

• FUNCIONA REVISANDO CADA ELEMENTO DE LA LISTA QUE VA HACER ORDENADA CON EL

SIGUIENTE, INTERCAMBIÁNDOLOS DE POSICIÓN SI ESTÁN EN EL ORDEN EQUIVOCADO.

• SIRVE PARA CICLAR REPETIDAMENTE A TRAVÉS DE LA LISTA, COMPARANDO ELEMENTOS

ADYACENTES DE DOS EN DOS.

• UNA DE LAS CARACTERÍSTICAS EN EL ALGORITMO DE BURBUJA QUE ES ESTABLE,

REQUERIMIENTO DE MEMORIA Y EL TIEMPO DE EJECUCIÓN
COMO SE IMPLEMENTA ESTE ALGORITMO EN UN
LENGUAJE DE PROGRAMACIÓN
60 26 5 8 13 37

• PUBLIC STATIC VOID BURBUJA(INT[] A) { 26 60 5 8 13 37 Se intercambia el 60 y el 26

INT I, J, AUX;
26 5 60 8 13 37 Se intercambia el 60 y el 5
FOR (I = 0; I < A.LENGTH - 1; I++) {
FOR (J = 0; J < A.LENGTH - I - 1; J++) { 26 5 8 60 13 37 Se intercambia el 60 y el 8
IF (A[J + 1] < A[J]) {
26 5 8 13 60 37 Se intercambia el 60 y el 13
AUX = A[J + 1];
A[J + 1] = A[J]; 26 5 8 13 37 60 Se intercambia el 60 y el 37
A[J] = AUX;
}
}
5 26 8 13 37 60 Se intercambia el 26 y el 5
} 5 8 26 13 37 60 Se intercambia el 26 y el 8
}
5 8 13 26 37 60 Se intercambia el 26 y el 13
ALGORITMO DE ORDENAMIENTO POR INSERCIÓN

• PUEDE USARSE FÁCILMENTE PARA ORDENAR UN MAZO DE CARTAS NUMERADAS EN FORMA

ARBITRARIA.

• CONSISTE EN IR INSERTANDO UN ELEMENTO DE LA LISTA Ó UN ARREGLO EN LA PARTE

ORDENADA DE LA MISMA, ASUMIENDO QUE EL PRIMER ELEMENTO ES LA PARTE ORDENADA.

• LA SIMPLIFICACIÓN DE LOS INTERCAMBIOS DESCARGA BASTANTE LA UTILIZACIÓN DE

MEMORIA, AUNQUE NO REDUCE SU COMPLEJIDAD

• EL ALGORITMO APROVECHA DEL POSIBLE ORDEN PARCIAL QUE PUEDA EXISTIR ENTRE LOS
ELEMENTOS, ES DECIR SI UN ELEMENTO ESTA “CERCA” DE SU POSICIÓN DEFINITIVA, EL MISMO
REALIZA MENOS INTERCAMBIOS.
• PUBLIC CLASS ORDENARPORINSERCION {

• PUBLIC STATIC VOID MAIN(STRING[] ARGS) {

• INT[] LISTA = NEW INT[100]; // LISTA DE NÚMEROS ENTEROS QUE SUPONDREMOS LLENA.

• INT I,J; // ÍNDICES SOBRE LA LISTA.

• INT AUX; // VARIABLE AUXILIAR PARA EL INTERCAMBIO DE VALORES.

• FOR (I = 1; I < 100; I++){ // ¡OJO! EMPEZAMOS EN 1

• AUX = LISTA[I]; // GUARDAMOS EL VALOR A ORDENAR.

• J = I - 1;

• WHILE ( (J >= 0) && LISTA[J] > AUX ) // SIEMPRE QUE SEA MAYOR QUE AUX.

• // ORDENAMOS DE MENOR A MAYOR.

• LISTA[J+1] = LISTA[J--]; // TRASLADAMOS EL VALOR Y MOVEMOS EL INDICE. PROCEDIMIENTO Insertion_sort ( Vector a[1:n])
• LISTA [J+1] = AUX; // PONEMOS EL VALOR A ORDENAR EN SU SITIO.
PARA i VARIANDO DE 2 HASTA n HACER
INSERTAR a[i] EN SU LUGAR EN a[1:i-1];
• }
FIN PROCEDIMIENTO;
• }

• }
• SUPONGA QUE USTED TIENE QUE ORDENAR LA SIGUIENTE LISTA DE NÚMEROS: [15, 5, 4, 18, 12, 19, 14, 10, 8, 20] ¿CUÁL DE LAS SIGUIENTES LISTAS REPRESENTA LA LISTA
PARCIALMENTE ORDENADA TRAS TRES PASADAS COMPLETAS DEL ORDENAMIENTO POR INSERCIÓN?

• (A) [4, 5, 12, 15, 14, 10, 8, 18, 19, 20]

• (B) [15, 5, 4, 10, 12, 8, 14, 18, 19, 20]

• (C) [4, 5, 15, 18, 12, 19, 14, 10, 8, 20]

• (D) [15, 5, 4, 18, 12, 19, 14, 8, 10, 20]

ALGORITMO DE ORDENAMIENTO POR SELECCIÓN

• CONSISTE EN ENCONTRAR AL MENOR DE TODOS LOS ELEMENTOS DEL ARREGLO O VECTOR E INTERCAMBIARLO CON
EL QUE ESTA EN LA PRIMERA POSICIÓN. LUEGO EL SEGUNDO MAS PEQUEÑO, Y ASÍ SUCESIVAMENTE.

• SU IMPLEMENTACIÓN ES CON CICLOS ANIDADOS.

• ALGORITMO QUE UBICA ELEMENTOS DE UN ARREGLO, EN UNA SECUENCIA, DADA POR UNA
RELACIÓN DE ORDEN

• BUSCAR EL MÍNIMO ELEMENTO ENTRE UNA POSICIÓN I Y EL FINAL DE LA LISTA

• INTERCAMBIAR EL MÍNIMO CON EL ELEMENTO DE LA POSICIÓN I

• DEF SELECTION_SORT(VECTOR):
• NB = LEN(VECTOR)
• FOR ACTUAL IN RANGE(0,NB):
• MAS_PEQUENO = ACTUAL PROCEDIMIENTO selection_sort ( Vector a[1:n])
• FOR J IN RANGE(ACTUAL+1,NB) : PARA i VARIANDO DE 1 HASTA n - 1 HACER
ENCONTRAR [j] EL ELEMENTO MÁS PEQUEÑO DE [i + 1:n];
• IF VECTOR[J] < VECTOR[MAS_PEQUENO] : INTERCAMBIAR [j] Y [i];
• MAS_PEQUENO =J FIN PROCEDIMIENTO;

• IF MIN IS NOT ACTUAL :

• TEMP = VECTOR[ACTUAL]
• VECTOR[ACTUAL] = VECTOR[MAS_PEQUENO]
• VECTOR[MAS_PEQUENO] = TEMP
• PUBLIC CLASS SELECTIONSORT{

• PUBLIC VOID SORTARRAY(INT[] ARRAY) {

• FOR (INT I = ARRAY.LENGTH - 1; I > 0; I--) {

• INT MAXVALUE = 0;

• FOR (INT J = 0; J < I; J++) {

• IF (ARRAY[J + 1] > ARRAY[MAXVALUE]) {

• MAXVALUE = J + 1;

• }

• }

• SWAP(ARRAY, I, MAXVALUE);

• PRINTARRAY (ARRAY );

• }

• }

• PUBLIC VOID PRINTARRAY(INT[] ARRAY) {

• FOR (INT I = 0; I < ARRAY.LENGTH ; I++) {

• SYSTEM.OUT.PRINTF("%D \T", ARRAY[I]);

• }

• SYSTEM.OUT.PRINTLN();

• }

• PUBLIC VOID SWAP(INT[] ARRAY, INT A, INT B) {

• INT VALUE = ARRAY[B];

• ARRAY[B] = ARRAY[A];

• ARRAY[A] = VALUE;

• }

• PUBLIC STATIC VOID MAIN(STRING[] ARGS) {

• SELECTIONSORT SELECTIONSORT = NEW SELECTIONSORT();

• INT[] ARRAY = { 10, 1, 5, 40, 12, 34, 44, 12, 11, 9 };

• SELECTIONSORT.PRINTARRAY(ARRAY);

• SELECTIONSORT.SORT ARRAY(ARRAY);

• SELECTIONSORT.PRINTARRAY(ARRAY);

• }

• }
• GRACIAS
 BIBLIOGRAFIA

• HTTP://LWH.FREE.FR/PAGES/ALGO/TRI/TRI_SELECTION_ES.HTML

• HTTP://ALGORITMOBASICO.BLOGSPOT.COM/2015/04/ALGORITMO-DE-LA-BURBUJA.HTML

• HTTP://ESCUELADEPROGRAMACION.ES/SNIPPETS/JAVA/ALGORITMOS/ORDENAR/ORDENACI
%C3%B3N_POR_INSERCI%C3%B3N.HTML
• HTTPS://DEVS4J.COM/2018/12/20/ALGORITMO-DE-ORDENAMIENTO-POR-SELECCION-EN-
JAVA-SELECTION-SORT/
• * 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 SELECCION;

• /**

SELECCION
• *

• * @AUTHOR JUAN FELIPE

• */

• PUBLIC CLASS SELECCION {

• PUBLIC STATIC VOID MAIN(STRING[] ARGS) {

• INT MENOR;

• INT[] TABLA = {7, 4, 8, 1, 12};

• INT[] NUEVATABLA = (TABLA);

• INT AUX;

• FOR (INT I = 0; I < TABLA.LENGTH ; I++) {

• MENOR = TABLA[I];

• FOR (INT J = I + 1; J < TABLA.LENGTH ; J++) {

• IF (TABLA[J] < MENOR) {

• AUX = NUEVATABLA[J];

• TABLA[J] = MENOR;

• MENOR = AUX;

• }

• }

• TABLA[I] = MENOR;

• }

• FOR (INT I = 0; I < NUEVATABLA.LENGTH; I++) {

• SYSTEM.OUT.PRINTLN(NUEVATABLA[I]);

• }

• }

• }
INSERCIÓN

PUBLIC CLASS INSERCCION {

PUBLIC STATIC VOID MAIN(STRING[] ARGS) {

INT[] LISTA = NEW INT[100]; // LISTA DE NÚMEROS ENTEROS QUE SUPONDREMOS LLENA.

INT I,J; // ÍNDICES SOBRE LA LISTA.

INT AUX; // VARIABLE AUXILIAR PARA EL INTERCAMBIO DE VALORES.

FOR (I = 1; I < 100; I++){ // ¡OJO! EMPEZAMOS EN 1

AUX = LISTA[I]; // GUARDAMOS EL VALOR A ORDENAR.

J = I - 1;

WHILE ( (J >= 0) && LISTA[J] > AUX ) // SIEMPRE QUE SEA MAYOR QUE AUX.

// ORDENAMOS DE MENOR A MAYOR.

LISTA[J+1] = LISTA[J--]; // TRASLADAMOS EL VALOR Y MOVEMOS EL INDICE.

LISTA [J+1] = AUX; // PONEMOS EL VALOR A ORDENAR EN SU SITIO.

}
PACKAGE BURBUJA;

IMPORT JAVA.UTIL.SCANNER;

/**

* @AUTHOR JUAN FELIPE

*/

// EN ESTE CODIGO PIDE QUE 5 USUARIOS INGRESEN SU EDAD Y ESTA IMPRIME LAS 5 EDADES DE MAYOR A MENOR.

PUBLIC CLASS BURBUJA {

PUBLIC STATIC VOID MAIN(STRING[] ARGS) {

INT ARR[] = NEW INT[5];

SCANNER SC = NEW SCANNER(SYSTEM.IN);

FOR (INT I = 0; I < ARR.LENGTH; I++) {

SYSTEM.OUT.PRINTLN("INGRESE NUMERO " + I);

ARR[I] = SC.NEXTINT();

FOR (INT I = 0; I < ARR.LENGTH - 1; I++) {

FOR (INT J = 0; J < ARR.LENGTH - 1; J++) {

IF (ARR[J] < ARR[J + 1]) {

INT TMP = ARR[J + 1];

ARR[J + 1] = ARR[J];

ARR[J] = TMP;

FOR (INT I = 0; I < ARR.LENGTH; I++) {

IF (I == 0) {

SYSTEM.OUT.PRINTLN("EL MAYOR ES: " + ARR[I]);

} ELSE IF (I == 4) {

SYSTEM.OUT.PRINTLN("Y EL MENOR ES: " + ARR[I]);

} ELSE {

SYSTEM.OUT.PRINTLN("EL SIGUIENTE ES: " + ARR[I]);