INSTITUTO TECNOLÓGICO SUPERIOR DE SAN

ANDRÉS TUXTLA
INGENIERÍA EN SISTEMAS COMPUTACIONALES

DOCENTE:
MTI ANGELINA MÁRQUEZ JIMÉNEZ.

MATERIA:
ESTRUCTURA DE DATOS

INTEGRANTES:
ISAAC CHAGA CHAGALA
REPORTE DE INVESTIGACIÓN

Unidad 5

PERIODO:

SEPTIEMBRE 2023 – ENERO 2024

GRUPO: 304-B

San Andrés Tuxtla, Veracruz

1
CONTENIDO

INTRODUCCIÓN..................................................................................................... 3

UNIDAD 5: MÉTODOS DE ORDENAMIENTO ....................................................... 4

5.1 ALGORITMOS DE ORDENAMIENTO INTERNOS ....................................... 5

5.1.1 BURBUJA ............................................................................................... 6

5.1.2 QUICKSORT ........................................................................................... 8

5.1.3 SHELLSORT..........................................................................................11

5.1.4 RADIX ....................................................................................................13

5.2 ALGORITMOS DE ORDENAMIENTO EXTERNOS .....................................15

5.2.1 INTERCALACIÓN ..................................................................................16

5.2.2 MEZCLA DIRECTA................................................................................18

5.2.3 MEZCLA NATURAL ..............................................................................23

CONCLUSIÓN .......................................................................................................29

REFERENCIAS BIBLIOGRÁFICAS Y/O ELECTRÓNICAS ..................................30

2
 INTRODUCCIÓN
En distintos contextos, ya sea en la vida diaria, en el ámbito laboral, en videojuegos, entre
otros, la organización desempeña un papel crucial. La capacidad de clasificar elementos
según un criterio que facilite su búsqueda, uso y obtención resulta esencial en cualquier
entorno.

Esta necesidad no pasa desapercibida en el ámbito tecnológico, afectando a todos los

programas informáticos existentes. La capacidad de almacenar datos de manera ordenada
no solo contribuye a comprender mejor la información, sino que también simplifica la
interacción del usuario con dichos datos.

Desde un enfoque más técnico y profundo, la capacidad de ordenar datos se logra mediante
la implementación de técnicas que llevan a cabo estas operaciones de manera eficiente.

El propósito de este documento es presentar al lector diversas metodologías de

ordenamiento de datos, cada una con sus propias ventajas y características, adaptadas a la
cantidad de datos que manipulan. Además, se incluyen pruebas de escritorio de algunos de
estos métodos, que servirán como representación gráfica del comportamiento de los mismos.

3
 UNIDAD 5: MÉTODOS DE ORDENAMIENTO

Para poder explicar que es un método de ordenamiento, primero se debe de

entender que es la acción de Ordenar.

Ordenar significa reagrupar o reorganizar un conjunto de datos u objetos en una

secuencia especifica. Ejemplos de esto se pueden encontrar a lo largo de la vida
diaria de las personas, va desde organizar libros en una biblioteca, números de
teléfono, registros de pacientes en hospitales, etc.

Visto de una manera formal, la ordenación se puede entender como la permutación

de sus elementos de forma que queden de acuerdo con una distribución
preestablecida. Sea A una lista de N elemento, quedaría que:

A1, A2, A3, A1, …, AN

En programación, existen dos categorías las cuales se distinguen en base a donde

se encuentren almacenados los datos. Si los elementos o componentes del arreglo
se encuentran en la memoria principal de la computadora, se denomina Ordenación
interna.

Por otra parte, si los elementos se encuentran en archivos almacenados en

dispositivos de almacenamiento secundario, como discos, CD, USB, etc. Se
denomina Ordenación externa. [1]

4
5.1 ALGORITMOS DE ORDENAMIENTO INTERNOS
Como se mencionó, le ordenamiento interno se refiere a ordenar un conjunto de
datos que se encuentren almacenados en una estructura, en la memoria principal.
Pueden ser vectores, matrices o cualquier otro tipo de estructura de datos.

El resultado de aplicar estos a una estructura de datos, es que todos sus elementos
queden ordenados de manera creciente o decreciente:

• Creciente: dato 1 ≤ dato 2 ≤ dato 3 ≤ … ≤ dato n

• Decreciente: dato 1 ≥ dato 2 ≥ dato 3 ≥… ≥ dato n

Estos métodos de ordenación interna a su vez se pueden clasificar en dos

tipos:

• Métodos directos
• Métodos logarítmicos

A su vez, los métodos directos se dividen en tres tipos más:

• Ordenación por intercambio: Este se basa en el principio de comparar

pares de elementos adyacentes e intercambiarlos entre sí hasta que estén
todos ordenados. En este tipo de métodos, se encuentra le método de
burbuja, shaker, con señal y QuickSort.
• Ordenación por inserción: Este se basa en insertar un elemento en una
parte ordenada de la lista y comenzar de nuevo con los elementos restantes.
Es por esto también por lo que se le conoce como “Método de la baraja”. Por
su semejanza a una.
• Ordenación por selección: Esté método se basa en buscar el elemento
menor de la lista y colocarlo en primera posición. Luego se busca el segundo
elemento más pequeño y se coloca en la segunda posición, y así
sucesivamente. Los pasos sucesivos son:
1) Seleccionar el elemento menor de la lista de n elementos
2) Intercambiar dicho elemento con el primero [1]

5
5.1.1 BURBUJA
El algoritmo de clasificación de intercambio o de la burbuja se basa en el principio
de comparar pares de elementos adyacentes e intercambiarlos entre si hasta que
todos estén ordenados.
Este puede trabajar de dos maneras diferentes: puede llevar todos los elementos
más pequeños hacia su parte izquierda o trasladar los elementos más grandes hacia
su parte derecha.

Se realizan (n-1) pasadas transportando entre sí hasta que todos se encuentren

ordenados a su posición ideal. [1]

Algoritmo Burbuja dato menor

inicio
// . . .
desde I 0 hasta N-1 hacer
desde J 0 hasta N-1 hacer
si Arreglo[J] > Arreglo[J+1] entonces
AUX  Arreglo[J]
Arreglo[J]  Arreglo[J+1]
Arreglo[J+1]  AUX
fin_si
fin_desde
fin_desde
fin
Algoritmo burbuja dato mayor
inicio
// . . .
desde I 0 hasta N-1 hacer
desde J 0 hasta N-1 hacer
si Arreglo[J] < Arreglo[J+1] entonces
AUX  Arreglo[J]
Arreglo[J]  Arreglo[J+1]
Arreglo[J+1]  AUX
fin_si
fin_desde
fin_desde
fin

Algoritmo Burbuja dato menor con bandera

inicio
// . . .
BANDERA  ‘F’

6
A0
Mientras (Bandera = ‘F’) Y (A<N) hacer
BANDERA ’V’
desde K 0 hasta N-1 hacer
si Arreglo[K] > Arreglo[K+1] entonces
AUX  Arreglo[K]
Arreglo[K]  Arreglo[K+1]
Arreglo[K+1]  AUX
BANDERA = ‘F’
fin_si
fin_desde
A = A+1
fin_mientras
fin
Algoritmo Burbuja dato mayor con bandera
inicio
// . . .
BANDERA  ‘F’
A0
Mientras (Bandera = ‘F’) Y (A<N) hacer
BANDERA ’V’
desde K 0 hasta N-1 hacer
si Arreglo[K] < Arreglo[K+1] entonces
AUX  Arreglo[K]
Arreglo[K]  Arreglo[K+1]
Arreglo[K+1]  AUX
BANDERA = ‘F’
fin_si
fin_desde
A = A+1
fin_mientras
fin

7
 5.1.2 QUICKSORT
El método de ordenación rápida (quicksort) para ordenar o clasificar un vector o
lista de elementos (array) se basa en el hecho de que es más rápido y fácil de
ordenar dos listas pequeñas que una lista grande. Se denomina método de
ordenación rápida porque, en general, es actualmente el más eficiente y veloz de
los métodos de ordenación interna. Este método se debe a C. A. Hoare. El método
se basa en la estrategia típica de “divide y vencerás” (divide and conquer). El valor
elegido puede ser cualquier valor arbitrario del vector. En ordenación rápida se llama
a este valor pivote.

La idea central de este algoritmo consiste en lo siguiente:

1. Se toma un elemento X de una posición cualquiera del arreglo.

2. Se trata de ubicar a X en la posición correcta del arreglo, de tal forma que
todos los elementos que se encuentren a su izquierda sean menores o
iguales a X y todos los que se encuentren a su derecha sean mayores o
iguales a X.
3. Se repiten los pasos anteriores, pero ahora de los conjuntos de datos que se
encuentran a la izquierda y a la derecha de la posición de X en el arreglo.
4. El proceso termina cuando todos los elementos se encuentran en su posición
correcta en el arreglo. [1]

Algoritmo QuickSort

Rapido_recursivo(A,N){
//Este algoritmo ordena los elementos del arreglo unidimensional utilizando el
méotodo rápido, de manera recursiva. A es un arreglo unidimensional de N
elementos
Llamar al algoritmo Reduce_recursivo(1,N);
}

8
Reduce_recursivo(INI, FIN){
// INI y FIN representan las posiciones del extremo izquierdo y derecho,
respectivamente, del conjunto de elementos da ordenar
//IZQ, DER, POS y AUX son variables de tipo entero. BAND es una variable de
tipo booleano.
Hacer IZQ = INI
Hacer DER = FIN
Hacer POS = INI
Hacer BAND = VERDADERO

Mientras BAND = VERDADERO Repetir{

Hacer BAND = Falso
Mientras A[POS] <= A[DER] y [POS!=DER] Repetir{
Hacer DER = DER -1
}

SI (POS!=DER) entonces{
Hacer AUX = A[POS]
Hacer A[POS] = A[DER]
Hacer A[DER] = AUX
Hacer POS = DER
Mientras (A[POS]>=A[IZQ] y POS!=IZQ) Repetir{
Hacer IZQ = IZQ +1
}

Si POS!=IZQ entonces{
Hacer BAND = VERDADERO
Hacer AUX = A[POS]
Hacer A[POS] = A[IZQ]
Hacer A[IZQ] = AUX
Hacer POS = IZQ

9
 }
}
}
SI (POS-1)>INI entonces{
Regresar a Reduce_recursivo con INI y POS-1 //llamada recursiva
}
SI FIN>(POS+1) entonces{
Regresar a Reduce_recursivo con (POS+1) y FIN //llamada recursiva
}
}

10
5.1.3 SHELLSORT
Este método es una variante mejorada del método de inserción directa. La idea de
insertar un elemento en una posición de tal forma que el arreglo vaya quedando
ordenado se mantiene, sin embargo, en este método los elementos a comparar se
seleccionan con intervalos que se reducen en cada iteración. Por ejemplo, a primera
vez el rango es de Tamaño/2 posiciones, luego Tamaño/4, después Tamaño/8 y así
hasta obtener un valor de 1 para él rango de posiciones.

Selección de los incrementos:

Se eligen los incrementos de tal manera que el último incremento sea 1.
Comúnmente se utilizan secuencias de incrementos como la secuencia de Shell (1, 4,
13, 40, ...) o la secuencia de Knuth (1, 4, 13, 40, ...).
Ordenamiento por inserción en subconjuntos:
Se aplican repetidamente los pasos de ordenamiento por inserción a subconjuntos de
la lista, utilizando el incremento actual seleccionado.
Cada vez que se ordena un subconjunto, los elementos están más cerca de sus
posiciones finales.
Reducir el incremento:
Se reduce el incremento y se repite el proceso hasta que el incremento es 1.
La última fase del algoritmo es un simple ordenamiento por inserción.
Ventajas:
Mejora significativamente el rendimiento del método de inserción, especialmente para
listas grandes.
Es eficiente para listas que no están completamente desordenadas.
Desventajas:
La elección de la secuencia de incrementos puede afectar el rendimiento del
algoritmo.
Complejidad Temporal:
El rendimiento del Shell Sort depende en gran medida de la secuencia de incrementos
utilizada.
En el peor caso, su complejidad temporal es generalmente, pero puede tener un mejor
rendimiento en la práctica dependiendo de los datos y la secuencia de incrementos.
[2]

11
Algoritmo ShellSort

Inicio
N  Insertar número de elementos
// . . .
Salto = parte entera(N/2)
Mientras Salto > 0 hacer
Desde I  Salto hasta N hacer
J  I-Salto
Mientras J > 0 hacer
K  J + Salto
Si Arreglo[J] <= Arreglo[K] entonces
J0
Si_no
AUX = Arreglo[J]
Arreglo[J] = Arreglo[K]
Arreglo[K] = AUX
Fin_si
J J-Salto
Fin_mientras
Fin_desde
Salto = Parte entera(Salto/2)
Fin_mientras
Fin

12
5.1.4 RADIX
El método de ordenamiento Radix Sort también llamado ordenamiento por residuos
que puede utilizarse cuando los valores a ordenar están compuestos por secuencias
de letras o dígitos que admiten un orden lexicográfico.

El algoritmo ordena utilizando un algoritmo de ordenación estable, las letras o dígitos

de forma individual, partiendo desde el que está más a la derecha (menos significativo)
y hasta el que se encuentra más a la izquierda (el más significativo). Nota: a cada letra
o dígito se le asigna una llave o código representado por un número entero, el cual se
utiliza para el ordenamiento de cada elemento que conforma el valor original.

Determinar el número máximo de dígitos:

Se identifica el elemento con el máximo número de dígitos en la lista.
Ordenar por el dígito menos significativo:
Se realiza una clasificación estable (manteniendo el orden relativo de los elementos
con el mismo valor) basada en el dígito menos significativo.
Los elementos se distribuyen en cubetas según el valor del dígito actual.
Repetir el proceso para cada dígito:
Se repite el proceso de ordenamiento para el siguiente dígito (de menor a mayor
peso).
En cada iteración, los elementos se reorganizan en base al siguiente dígito.
Listo cuando se procesan todos los dígitos:
Después de procesar todos los dígitos, la lista está ordenada.
Variantes:
LSD (Least Significant Digit):
Comienza por el dígito menos significativo y avanza hacia el más significativo.
MSD (Most Significant Digit):
Comienza por el dígito más significativo y avanza hacia el menos significativo.
Ventajas:
No depende de comparaciones entre elementos, por lo que puede ser eficiente para
ciertos tipos de datos.
Es estable, lo que significa que conserva el orden relativo de elementos con claves
iguales.
13
 Desventajas:
No es eficiente para datos que no se pueden descomponer en dígitos individuales.
Puede requerir memoria adicional para almacenar las cubetas.
Complejidad Temporal:
La complejidad temporal de Radix Sort depende del número de dígitos y del número
de elementos en la lista.
[2]

Algoritmo en pseudocódigo del Radix Sort

RadixSort(A,d)
Inicio
Para i=1 hasta i=d
Ordenamiento de A en el digito i
Fin

14
5.2 ALGORITMOS DE ORDENAMIENTO EXTERNOS
En la actualidad es común procesar volúmenes de información que los datos no se
pueden almacenar en la memoria principal de la computadora. Estos datos,
organizados en archivos, se guardan en dispositivos de almacenamiento secundario,
como cintas, discos, etcétera.

El proceso de ordenas los datos almacenados en varios archivos se conoce como

fusión o mezcla; se entiende por este concepto a la combinación o intercalación de dos
o más secuencias ordenadas en una única secuencia ordenada. Se debe hacer
hincapié en que sólo se colocan en la memoria principal de la computadora los datos
que se pueden acceder en forma directa.

El tratamiento de los archivos secuenciales exige que éstos se encuentren ordenados

respecto a un campo del registro, denominado campo clave.
La clasificación en orden ascendente o descendente se puede realizar con respecto a
una clave (nombre, dirección, etc.). Sin embargo, un archivo puede estar ordenado por
un campo clave o una jerarquía de campos. [2]

Se dice que un archivo (estructura del registro: campos C1, C2, ... Cn) está ordenado
principalmente por el campo C1, en orden secundario 1 por el campo C2, en orden
secundario 2 por el campo C3, etc., en orden secundario n por el campo Cn. Si el archivo
tiene la siguiente organización:

• Los registros aparecen en el archivo según el orden de los valores del campo
clave C1.
• Si se considera un mismo valor C1, los registros aparecen en el orden de los
valores del campo C2.
• Para un mismo valor de C(Ci) los registros aparecen según el orden de los
valores del campo Ci + 1, siendo 1 =< i <= n.

• Si se desea ordenar un archivo principalmente por C1, y en orden secundario 1

por C2, se necesita:

• Ordenar primero por C2.

• Ejecutar a continuación una ordenación estable por el campo C1. [2]

15
5.2.1 INTERCALACIÓN
Se entiende por intercalación de archivos a la unión o fusión de dos o más archivos
ordenados de acuerdo con un determinado campo clave, en un solo archivo.

Proceso de Intercalación:
Compara los elementos en las sublistas ordenadas y los coloca en orden en una nueva
lista resultante.
Este proceso se repite hasta que se han recorrido ambas sublistas y todos los
elementos se han intercalado.
Complejidad Temporal:
La complejidad temporal del Merge Sort es el número de elementos en la lista.
Ventajas:
Eficiente para listas grandes y estructuras de datos enlazadas.
Garantiza un rendimiento estable y predecible.
Desventajas:
Requiere espacio adicional para almacenar temporalmente las sublistas.[3]
Pseudocódigo:
Intercalacion(F1, F2, F3){
//El algoritmo intercala los elementos de dos archivos ya ordenados F1 y F2 y almacena
el resultado en el archivo F3
//R1 y R2 son variables de tipo entero, BAN1 y BAN2 son variables de tipo booleano.
Abrir los archivos F1 y F2 para la lectura
Abrir el archivo F3 para la escritura
BAN1 = VERDADERO
BAN2 = VERDADERO

Mientras ((no sea el fin de archivo de F1 o BAN1!=FALSO) y (no sea el fin de archivo
de F2 o BAN2!=FALSE)) Repetir{ Si (BAN1 == VERDADERO) entonces{
Leer R1 de F1
BAN1 = FALSO
}

16
 Si (BAN2 == VERDADERO) entonces{
Leer R2 de F2
BAN2 = FALSO
}

Si (R1 < R2) entonces{

Escribir R1 EN F3
Hacer BAN1 = VERDADERO
}sino{
Escribir R2 EN F3
Hacer BAN2 = VERDADERO
}
}
Si (BAN1==FALSO) entonces{
Escribir R1 en F3

Mientras (no sea el fin de archivo de F1) Repetir{

Leer R1 de F1
Escribir R1 en F3
}
}
Si (BAN2==FALSO) entonces{
Escribir R2 en F3

Mientras (no sea el fin de archivo de F2) Repetir{

Leer R2 de F2
Escribir R2 en F3
}
}
Cerrar los archivos F1, F2 y F3
}

17
5.2.2 MEZCLA DIRECTA
El método de ordenación por mezcla directa es probablemente el más utilizado por su
fácil comprensión. La idea central de este algoritmo consiste en la realización sucesiva
de una partición y una fusión que produce secuencias ordenadas de longitud cada vez
mayor.

En la primera pasada, la partición es la longitud 1 y la fusión o mezcla produce

secuencias ordenadas de longitud 2. En la segunda pasada, la partición es de longitud
2 y la fusión o mezcla produce secuencias ordenadas de longitud 4. Este proceso se
repite hasta que la longitud de la secuencia para la partición sea la parte entera de
(n+1)/2

Donde n representa el número de elementos del archivo original [3]

Pseudocódigo

Mezcla_directa(F, F1, F2, N){

//El algoritmo ordena los elementos del archivo F por el método de mezcla directa.
Utiliza dos archivos auxiliares F1 y F2. N es el número de elementos del archivo F

PART = 1
Mientras (PART < parte entera((N+1)/2) ) Repetir{
Llamar al algoritmo Particiona con F, F1, F2 y PART
Llamar al algoritmo Fusiona con F, F1, F2 y PART
}
}

Particiona(F, F1, F2, PART){

//El algoritmo genera dos archivos auxiliares, F1 y F2, a partir del archivo F. PART es
la longitud de la partición que se va a realizar
//K, L y R son variables de tipo entero

Abrir el archivo F para lectura

Abrir los archivos F1 y F2 para escritura

18
 Mientras (no sea el archivo de F) Repetir{
K=0

Mientras (K<PART) y (no sea el fin de archivo de F) Repetir{

Leer R de F
Escribir R en F1
K=K+1
}

L =0

Mientras (L<PART) y (no sea el fin de archivo de F) Repetir{

Leer R de F
Escribir R en F2
L =L+1
}
}
}

Fusiona(F, F1, F2, PART){

//El algoritmo fusiona los archivos F1 y F2 en el archivo F. PART es la longitud de la
partición que se realizó previamente
//R1, R2, K y L son variables de tipo entero, B1 y B2 son variables de tipo booleano.

Abrir el archivo F para lectura

Abrir los archivos F1 y F2 para escritura

B1 = VERDADERO
B2 = VERDADERO

Si (no es el fin de archivo de F1) entonces{

Leer R1 de F1
B1 = Falso
}

19
 Si (no es el fin de archivo de F2) entonces{
Leer R2 de F2
B2 = Falso
}

Mientras ((no sea el fin de archivo de F1) o (B1==FALSO)) y ((no sea el fin de archivo
de F2) o (B2==FALSO)) Repetir{
K=0
L=0

Mientras ((K<PART) y (B1==FALSO)) y ((L<PART) y (B2==FALSO)) Repetir{

Si(R1<=R2) entonces{
Escribir R1 en F
B1 = VERDADERO
K=K+1
Si (no es el fin de archivo de F1) entonces{
Leer R1 de F1
B1=FALSO
}
}sino{
Escribir R2 en F
B2=VERDADERO
L=L+1
Si (no es el fin de archivo de F2) entonces{
Leer R2 de F2
B2=FALSO
}
}
}

Mientras (K<PART) y (B1==FALSO) Repetir{

Escribir R1 en F

20
 Hacer B1 = VERDADERO
K = K+1
Si (no es el fin de archivo F1) entonces{
Leer R1 de F1
B1 = FALSO
}
}

Mientras (L<PART) y (B2==FALSO) Repetir{

Escribir R2 en F
Hacer B2 = VERDADERO
L = L+1
Si (no es el fin de archivo F2) entonces{
Leer R2 de F2
B2 = FALSO
}
}
}

Si B1==FALSO entonces{
Escribir R1 en F
}

Si B2==FALSO entonces{
Escribir R2 en F

Mientras (no sea el fin del archivo F1) Repetir{

Leer R1 de F1
Escribir R1 en F
}
Mientras (no sea el fin del archivo F2) Repetir{
Leer R2 de F2
Escribir R2 en F

21
 }

Cerrar los archivos F, F1 y F2

}

22
5.2.3 MEZCLA NATURAL
El método de mezcla natural, o tambien conocido como mezcla equilibrada, es una
optimización del método de mezcla directa.

La idea central de este algoritmo consiste en realizar particiones tomando secuencias

ordenadas de máxima longitud en lugar de secuencia de tamaño fijo previamente
determinadas. Luego se realiza la fusión de las secuencias ordenadas, en forma
alternada, sobre dos archivos. Aplicando estas acciones en forma repetida se logrará
que el archivo original quede ordenado.

Para la realización de este proceso de ordenación se necesitarán cuatro archivos. El

archivo original F y tres archivos auxiliares F1, F2 y F3. De estos archivos, dos serán
considerados de entrada y dos de salida: esto, de manera alternada, con el objeto de
realizar la fusión - partición. El proceso termina cuando en la realización de una fusión-
partición el segundo archivo quede vacío. [3]

Pseudocódigo

Mezcla_equilibrada(F, F1, F2, F3){

//El algoritmo ordena los elementos del archivo F por el método de mezcla equilibrada.
Utiliza tres archivos auxiliares F1, F2 y F3
//BAND es una variable de tipo booleano

Llamar al algoritmo de Partición_inicial con F, F2 y F3

Llamar al algoritmo de Partición_Fusión con F2, F3, F y F1

BAND = FALSO

Mientras (F1!=VACIO) o (F3!=VACIO) Repetir{

Si BAND == VERDADERO entonces{
Llamar al algoritmo de Partición_Fusión con F2, F3, F y F1
BAND=FALSO
}sino{
Llamar al algoritmo de Partición_Fusión con F, F1, F2 y F3
23
 BAND=VERDADERO
}
}
}

Particion_inicial(F, F2, F3){

//El algoritmo produce la partición inicial del archivo F en dos archivos auxiliares,
F2 y F3
//AUX y R son variables de tipo entero. BAND es una variable de tipo booleano.

Abrir el archivo F para lectura

Abrir los archivos F2 y F3 para escritura
Leer R de F
Escribir R en F2
BAND = VERDADERO
AUX = R

Mientras (no sea el fin de archivo de F) Repetir{

Leer R de F

Si (R>=AUX) entonces{
AUX = R

Si BAND==VERDADERO entonces{
Escribir R en F2
}sino{
Escribir R en F3
}
}sino{
AUX=R

Si BAND==VERDADERO entonces{
Escribir R en F3
24
 BAND=FALSO
}sino{
Escribir R en F2
BAND=VERDADERO
}
}
}
Cerrar los archivos F, F2 y F3
}

Particion_fusion(FA, FB, FC, FD){

//El algoritmo produce la particion y la fusion de los archivos FA y FB, en los archivos
FC y FD
//R1, R2 y AUX son variables de tipo entero, BAN1, BAN2 y BAN3 son variables de
tipo booleano

Abrir los archivos FA y FB para lectura

Abrir los archivos FC y FD para escritura

BAN1=VERDADERO
BAN2=VERDADERO
BAN3=VERDADERO
AUX = -32768 //Se inicializa con un valor negativo alto

Mientras ((no sea el fin de archivo de FA) o (BAN1==FALSO)) y ((no sea el fin de
archivo FB) o (BAN2==FALSO)) Repetir{
Si BAN1==VERDADERO entonces{
Leer R1 de FA
BAN1=FALSO
}

Si BAN2==VERDADERO entonces{
Leer R2 de FB
BAN2=FALSO
25
}

Si R1<R2 entonces{
Si R1>=AUX entonces{
Si BAN3==VERDADERO entonces{
Escribir R1 en FC
}sino{
Escribir R1 en FD
}
BAN1=VERDADERO
AUX=R1
}sino{
Si BAN3==VERDADERO entonces{
Escribir R2 en FC
BAN3=FALSO
}sino{
Escribir R2 en FD
BAN3=VERDADERO
}
BAN2=VERDADERO
AUX=-32768
}sino{
Si R2>=AUX entonces{
Si BAN3==VERDADERO entonces{
Escribir R2 en FC
}sino{
Escribir R2 en FD
}
BAN2=VERDADERO
AUX=R2
}sino{
Si BAN3==VERDADERO entonces{

26
 Escribir R1 en FC
BAN3=FALSO
}sino{
Escribir R1 en FD
BAN3=VERDADERO
}
BAN1=VERDADERO
AUX=-32768
}
}
}
Si BAN1==FALSO entonces{
Si BAN3==VERDADERO entonces{
Escribir R1 en FC
Mientras (no sea el fin de archivo de FA) Repetir{
Leer R1 de FA
Escribir R1 en FC
}
}sino{
Escribir R1 en FD
Mientras (no sea el fin de archivo de FA) Repetir{
Leer R1 de FA
Escribir R1 en FD
}
}
}
Si BAN2==FALSO entonces{
Si BAN3==VERDADERO entonces{
Escribir R2 en FC
Mientras (no sea el fin de archivo de FB) Repetir{
Leer R2 de FB
Escribir R2 en FC

27
 }
}sino{
Escribir R2 en FD
Mientras (no sea el fin de archivo de FB) repetir{
Leer R2 de FB
Escribir R2 en FD
}
}
}
}
Cerrar los archivos FA, FB, FC y FD
}

28
CONCLUSIÓN
Como se pudo ver durante el documento, los métodos de ordenación son muy amplios
y variados, permitiéndole al programador el elegir cual utilizar en base a sus
necesidades, ya sea optimización de código, tiempo, manejabilidad de datos, uso de
archivos, etc. O también permitiéndole elegir uno con el que se familiarice o le guste
más.

Estos son muy importantes, ya que, dentro del funcionamiento de muchos programas,
la organización es una pieza clave para poder hacer un uso correcto de datos, desde
relaciones, el poder asignar espacios, inserciones, extracciones, etc.

Para finalizar, solo queda recalcar la verdadera importancia que tienen estos métodos
y el gran impacto que estos representan en la programación actual, permitiendo
administrar bases de datos, registros, inserciones, realizar operaciones de forma más
rápida y práctica, etc. Son muy importantes tanto fuera como dentro del ámbito
tecnológico.

29
REFERENCIAS BIBLIOGRÁFICAS Y/O ELECTRÓNICAS
[1] S. Guardati, Estructura de datos Orientada a Objetos Algoritmos con C++, México:
Pearson Educación, 2007.

[2] L. Joyanes Aguilar, Fundamentos de Programación. Algoritmos y Estructuras de

Datos., McGraw Hill, 2003.

[3] O. Cairo y S. Guardati, Estructura de Datos, México: McGraw-Hill.

[4] E. Saenz, «UNAM Facultad de Ingenieria,» 08 Febrero 2018. [En línea].

Available: http://odin.fi-b.unam.mx/salac/practicasEDAII/eda2_p3.pdf. [Último
acceso: 26 Noviembre 2020].

30