Presentación

➢ Nombres: Elisa Paola

➢ Apellidos: De La R. Sánchez
➢ Profesor/a: Felipe Arturo Duran
➢ Matricula: 20-EIST-6-046
➢ Sección: 311
➢ Tema de asignación: Algoritmos de Búsqueda y Ordenamiento
➢ Fecha de entrega: 31/07/2021
 Introducción

La ordenación es una aplicación fundamental en computación. La mayoría de los

datos producidos por un programa están ordenados de alguna manera, y muchos
de los cómputos que tiene que realizar un programa son más eficientes si los
datos sobre los que operan están ordenados. Uno de los tipos de cómputo que
más se benefician de operar sobre un conjunto de datos ordenados es la
búsqueda de un dato: encontrar el número de teléfono de una persona en un listín
telefónico es una tarea muy simple y rápida si conocemos su nombre, ya que los
listines telefónicos se encuentran ordenados alfabéticamente. Encontrar a que
usuario corresponde un número de teléfono dado, sin embargo, es una tarea
prácticamente inabordable. Valga esto a modo de ejemplo de cómo el disponer de
una colección de datos ordenados simplifica la búsqueda de información entre
ellos, de ahí la importancia de las tareas de ordenación y búsqueda y la relación
que existe entre ellas.
 Algoritmos de Búsqueda y Ordenamiento

¿Qué es un Ordenamiento?
Es la operación de arreglar los registros de una
tabla en algún orden secuencial de acuerdo a
un criterio de ordenamiento.
El ordenamiento se efectúa con base en
el valor de algún campo en un registro.
El propósito principal de un ordenamiento es el
de facilitar las búsquedas de los miembros del
conjunto ordenado.
Ej. de ordenamientos:
Dir. telefónico, tablas de contenido, bibliotecas y diccionarios, etc.
El ordenar un grupo de datos significa mover los datos o sus referencias para que queden
en una secuencia tal que represente un orden, el cual puede ser numérico, alfabético o
incluso alfanumérico, ascendente o descendente.
¿Cuándo conviene usar un método de ordenamiento?
Cuando se requiere hacer una cantidad considerable de búsquedas y es importante el
factor tiempo.
▪ Tipos de ordenamientos:
Los 2 tipos de ordenamientos que se pueden realizar son: los internos y los externos.
Los internos:
Son aquellos en los que los valores a ordenar están en memoria principal, por lo que se
asume que el tiempo que se requiere para acceder cualquier elemento sea el mismo (a[1],
a[500], etc).
▪ Los externos:
Son aquellos en los que los valores a ordenar están en memoria secundaria (disco, cinta,
cilindro magnético, etc), por lo que se asume que el tiempo que se requiere para acceder a
cualquier elemento depende de la última posición accesada (posición 1, posición 500, etc).
Eficiencia en tiempo de ejecución:
Una medida de eficiencia es:
Contar el # de comparaciones (C)
Contar el # de movimientos de items (M)
Estos están en función de el #(n) de items a ser ordenados.
Un "buen algoritmo" de ordenamiento requiere de un orden nlogn comparaciones.
La eficiencia de los algoritmos se mide por el número de comparaciones e intercambios
que tienen que hacer, es decir, se toma n como el número de elementos que tiene el arreglo
o vector a ordenar y se dice que un algoritmo realiza O(n2) comparaciones cuando compara
n veces los n elementos, n x n = n2
 Búsqueda

Un algoritmo de búsqueda es un conjunto de instrucciones que están diseñadas para

localizar un elemento con ciertas propiedades dentro de una estructura de datos; por
ejemplo, ubicar el registro correspondiente a cierta persona en una base de datos, o el
mejor movimiento en una partida de ajedrez.
La variante más simple del problema es la búsqueda de un
número en un vector.
Un problema típico de la Inteligencia Artificial consiste en
buscar un estado concreto entre un conjunto determinado, al
que se le llama espacio de estados. Imaginemos, por
ejemplo, una habitación con baldosines en la que hay un
libro. Un robot se desea desplazar por la habitación con el fin
de llegar a dicho libro. ¿De qué manera lo hará? En este
punto es donde entran en juego las estrategias y
los algoritmos de búsqueda.
Cuando el sistema agente (en este caso, el robot) posee
algún tipo de información del medio, se utilizan técnicas de
búsquedas informadas; sin embargo, si carece de
conocimiento alguno, se deberán emplear algoritmos de
búsqueda no informadas. En nuestro ejemplo, y para este
último caso, podemos imaginar un robot que no posea
ningún tipo de visión artificial, que únicamente sea capaz de
moverse en horizontal o vertical de un baldosín a otro y
detectar si en el baldosín se halla el libro.

De esta forma, los algoritmos de búsqueda pueden ser:

• Algoritmos no informados o ciegos: en general más

ineficientes en tiempo y memoria que otros métodos.
• Algoritmos informados
o Algoritmos heurísticos: destacan las Búsquedas Primero el Mejor
(Algoritmo voraz o Greedy y Algoritmo de búsqueda A*) y de Mejora Iterativa
(Algoritmo Escalada Simple -Hill Climbing- y Escalada por Máxima
Pendiente)
o Algoritmos de Búsqueda con adversario: destacan el Minimax y el Poda
alfa-beta.

• Búsqueda Secuencial: Consiste en ir comparando el elemento a buscar

con cada elemento del vector hasta encontrarlo o hasta que se llegue al
final, esto hace que la búsqueda sea secuencialmente (de ahí su nombre).
La existencia se puede asegurar cuando el elemento es localizado, pero no
podemos asegurar la no existencia hasta no haber analizado todos los
elementos del vector. Se utiliza sin importar si el vector está
 previamente ordenado o no. A continuación, se muestra
el pseudocódigo del algoritmo:

Datos de entrada:
vec: vector en el que se desea buscar el dato
tam: tamaño del vector. Los subíndices válidos van desde 0 hasta tam-1 inclusive. Puede
representarse así: vec[0...tam) o vec[0...tam-1].
dato: elemento que se quiere buscar.

Variables
pos: posición actual en el vector

pos = 0
while pos < tam:
if vec[pos] == dato:
Retorne verdadero y/o pos,
else:
pos = pos + 1
Fin (while)
Retorne falso,

• C

int busquedaSimple(int vector[n], int n, int dato) {

int i;

for(i=0; i<n; i++){

if(dato==vector[i]) {
return i;
}
}

return -1;

Búsqueda Dicotómica: Se utiliza cuando el vector en el que queremos determinar la

existencia de un elemento está previamente ordenado. Este algoritmo reduce el tiempo
de búsqueda considerablemente, ya que disminuye exponencialmente el número de
iteraciones necesarias. En el peor de los casos el número máximo de comparaciones

es , donde es el número de los elementos en el vector. Por ejemplo, en uno

conteniendo 50.000.000 elementos, el algoritmo realiza como máximo 26
comparaciones.
Para implementar este algoritmo se compara el elemento a buscar con un elemento
cualquiera del vector (normalmente el elemento central): si el valor de este es mayor que
el del elemento buscado se repite el procedimiento en la parte del vector que va desde el
inicio de este hasta el elemento tomado, en caso contrario se toma la parte del vector
que va desde el elemento tomado hasta el final. De esta manera obtenemos intervalos
cada vez más pequeños, hasta que se obtenga un intervalo indivisible. Si el elemento no
se encuentra dentro de este último entonces se deduce que el elemento buscado no se
encuentra en todo el vector.
A continuación, se presenta el pseudocódigo del algoritmo, tomando como elemento
inicial el elemento central del vector.

Datos de entrada:
vec: vector en el que se desea buscar el dato
tam: tamaño del vector. Los subíndices válidos van desde 0 hasta tam-1 inclusive.
dato: elemento que se quiere buscar.

Variables
centro: subíndice central del intervalo
inf: límite inferior del intervalo
sup: límite superior del intervalo

inf = 0
sup = tam-1

Mientras inf <= sup:

centro = ((sup - inf) / 2) + inf // División entera: se trunca la fracción
Si vec[centro] == dato devolver verdadero y/o pos, de lo contrario:
Si dato < vec[centro] entonces:
sup = centro - 1
En caso contrario:
inf = centro + 1
Fin (Mientras)
Devolver Falso

• C

int busquedaBinaria(int vector[], int n, int dato) {

int centro,inf=0,sup=n-1;
while(inf<=sup){
centro=((sup+inf)/2);
if(vector[centro]==dato) return centro;
else if(dato < vector[centro]) sup=centro-1;
else inf=centro+1;
}
return -1;
}

Implementación recursiva en C++

• C++

#include <vector>

bool busqueda_dicotomica(const vector<int> &v, int principio, int fin, int &x){
bool res;
if(principio <= fin){
int m = ((fin - principio)/2) + principio;
if(x < v[m]) res = busqueda_dicotomica(v, principio, m-1, x);
else if(x > v[m]) res = busqueda_dicotomica(v, m+1, fin, x);
 else res = true;
}else res = false;
return res;
}
/*{Post: Si se encuentra devuelve true, sino false}*/

Implementación recursiva en Python

• Python

def busquedaBinaria (numeros, inicio, fin, elemento):

if (inicio == fin): return numeros [inicio] == elemento

centro = ((fin - inicio) // 2) + inicio

if (elemento < numeros [centro]):

return busquedaBinaria (numeros, inicio, centro - 1, elemento)

elif (elemento > numeros [centro]):

return busquedaBinaria (numeros, centro + 1, fin, elemento)

else: return True

def busqueda (numeros, elemento):

if (numeros == None) or (numeros == []):
return False

else: return busquedaBinaria (numeros, 0, len (numeros) - 1, elemento)

Implementación recursiva en Python3

• Python

def bin(a,x,low,hi):
ans = -1
if low==hi: ans = -1
else:
mid = (low+((hi-low)//2))
if x < a[mid]: ans = bin(a,x,low,mid)
elif x > a[mid]: ans = bin(a,x,mid+1,hi)
else: ans = mid
return ans

# Así se hace el llamado: print(bin(Lista, numero_a_buscar, 0, len(Lista)))

# Retorna el índice que coincide con 'numero_a_buscar', si no está retorna -1
# Tiempo: (log n)

Implementación iterativa en Python3

• Python

def bin(a, c):

ans = -1
if a[0] >= c: ans = -1
else:
 low, hi = 0, len(a)
while low+1 != hi:
mid = low + ((hi-low)//2)
if a[mid] < c: low = mid
else: hi = mid
ans = low
return ans

# Así se hace el llamado: print(bin(lista(), numero_a_buscar))

# Retorna el índice que coincide con 'numero_a_buscar', si no está retorna -1
# Tiempo: (log n)
 Ordenamiento

Los algoritmos de ordenamiento nos permiten, como su nombre lo dice, ordenar

información de una manera especial basándonos en un criterio de ordenamiento.
En la computación el ordenamiento de datos cumple un rol muy importante, ya sea como
un fin en sí o como parte de otros procedimientos más complejos. Se han desarrollado
muchas técnicas en este ámbito, cada una con características específicas, y con ventajas
y desventajas sobre las demás.
Para que os hagáis una idea de la dificultad del problema, propongo el siguiente mini juego.
Se trata de unos barriles ordenar (entre 3 y 10) con el fin de aumentar de peso. El peso de
cada barril fue asignado al azar. Utilice la opción "arrastrar y soltar" para mover los barriles.
Tienes una escala no calibrada que le permite comparar el peso de barriles y estantes que
pueden servir para el almacenamiento intermedio. Estos son exactamente los mismos
elementos que los que están disponibles a un ordenador: una función de comparación y
áreas de almacenamiento. El
objetivo es, obviamente, de
ordenar los barriles con los menos
comparaciones e intercambios
posibles.
Las relaciones de orden más
usadas son el orden numérico y
el orden lexicográfico.
Ordenamientos eficientes son
importantes para optimizar el uso
de otros algoritmos (como los
de búsqueda y fusión) que
requieren listas ordenadas para
una ejecución rápida. También es
útil para poner datos en forma
canónica y para generar resultados
legibles por humanos.
Desde los comienzos de la computación, el problema del ordenamiento ha atraído gran
cantidad de investigación, tal vez debido a la complejidad de resolverlo eficientemente a
pesar de su planteamiento simple y familiar. Por ejemplo, BubbleSort fue analizado desde
1956.1 Aunque muchos puedan considerarlo un problema resuelto, nuevos y útiles
algoritmos de ordenamiento se siguen inventado hasta el día de hoy (por ejemplo,
el ordenamiento de biblioteca se publicó por primera vez en el 2004). Los algoritmos de
ordenamiento son comunes en las clases introductorias a la computación, donde la
abundancia de algoritmos para el problema proporciona una gentil introducción a la
variedad de conceptos núcleo de los algoritmos, como notación de O
mayúscula, algoritmos divide y vencerás, estructuras de datos, análisis de los casos peor,
mejor, y promedio, y límites inferiores.
¿Estos se clasifican?

• La más común es clasificar según el lugar donde se realice la ordenación

o Algoritmos de ordenamiento interno: en la memoria del ordenador.
o Algoritmos de ordenamiento externo: en un lugar externo como un disco duro.
• Por el tiempo que tardan en realizar la ordenación, dadas entradas ya ordenadas o
inversamente ordenadas:
o Algoritmos de ordenación natural: Tarda lo mínimo posible cuando la entrada está
ordenada.
o Algoritmos de ordenación no natural: Tarda lo mínimo posible cuando la entrada
está inversamente ordenada.

• Por estabilidad: un ordenamiento estable mantiene el orden relativo que tenían

originalmente los elementos con claves iguales. Por ejemplo, si una lista ordenada por
fecha se reordena en orden alfabético con un algoritmo estable, todos los elementos
cuya clave alfabética sea la misma quedarán en orden de fecha. Otro caso sería cuando
no interesan las mayúsculas y minúsculas, pero se quiere que si una clave aBC estaba
antes que AbC, en el resultado ambas claves aparezcan juntas y en el orden original:
aBC, AbC. Cuando los elementos son indistinguibles (porque cada elemento se ordena
por la clave completa) la estabilidad no interesa. Los algoritmos de ordenamiento que
no son estables se pueden implementar para que sí lo sean. Una manera de hacer esto
es modificar artificialmente la clave de ordenamiento de modo que la posición original
en la lista participe del ordenamiento en caso de coincidencia.
Los algoritmos se distinguen por las siguientes características:

• Complejidad computacional (peor caso, caso promedio y mejor caso) en términos de n,

el tamaño de la lista o arreglo. Para esto se usa el concepto de orden de una función y
se usa la notación O(n). El mejor comportamiento para ordenar (si no se aprovecha la
estructura de las claves) es O(n log n). Los algoritmos más simples son cuadráticos, es
decir O(n²). Los algoritmos que aprovechan la estructura de las claves de ordenamiento
(p. ej. bucket sort) pueden ordenar en O(kn) donde k es el tamaño del espacio de
claves. Como dicho tamaño es conocido a priori, se puede decir que estos algoritmos
tienen un desempeño lineal, es decir O(n).
• Uso de memoria y otros recursos computacionales. También se usa la notación O(n).
 Algoritmos de Búsqueda

Un algoritmo de búsqueda es aquel que está diseñado para localizar un elemento concreto
dentro de una estructura de datos. Consiste en solucionar un problema de existencia o no
de un elemento determinado en un conjunto finito de elementos, es decir, si el elemento
en cuestión pertenece o no a dicho conjunto, además de su localización dentro de éste.
Este problema puede reducirse a devolver la existencia de un número en un vector.

La búsqueda de un elemento dentro de un array es una de las operaciones más importantes

en el procesamiento de la información, y permite la recuperación de datos previamente
almacenados. El tipo de búsqueda se puede clasificar como interna o externa, según el
lugar en el que esté almacenada la información (en memoria o en dispositivos externos).
Todos los algoritmos de búsqueda tienen dos finalidades:

• Determinar si el elemento buscado se encuentra en el conjunto en el que se busca.

• Si el elemento está en el conjunto, hallar la posición en la que se encuentra.

• Complejidad de la Búsqueda Lineal.

(A) MEJOR CASO: El algoritmo de búsqueda lineal termina tan pronto como encuentra el
elemento buscado en el array. Si tenemos suerte, puede ser que la primera posición
examinada contenga el elemento que buscamos, en cuyo caso el algoritmo informará que
tuvo éxito después de una sola comparación. Por tanto, la complejidad en este caso será
O(1).

(B) PEOR CASO: Sucede cuando encontramos X en la última posición del array. Como se
requieren n ejecuciones del bucle mientras, la cantidad de tiempo es proporcional a la
longitud del array n, más un cierto tiempo para realizar las instrucciones del bucle mientras
y para la llamada al método. Por lo tanto, la cantidad de tiempo es de la forma an + b
(instrucciones del mientras * tamaño del arreglo + llamada al método) para ciertas
constantes a y b, que representan el coste del bucle mientras y el costo de llamar el método
respectivamente. Representando esto en notación O, O(an+b) = O(n).

(C) CASO MEDIO: Supongamos que cada elemento almacenado en el array es igualmente
probable de ser buscado. La media puede calcularse tomando el tiempo total de encontrar
todos los elementos y dividiéndolo por n:

Total = a (1 + 2 + ...+n) + bn = a (n(n+1) / 2) + bn, a representa el costo constante asociado

a la ejecución del ciclo y b el costo constante asociado a la evaluación de la condición. 1, 2
, ..n, representan el costo de encontrar el elemento en la primera, segunda, ..., enesima
posición dentro del arreglo.
Media = (Total / n) = a((n+1) / 2) + b que es O(n).

Este es el algoritmo de más simple implementación, pero no el más efectivo. En el peor de

los casos se recorre el array completo y el valor no se encuentra o se recorre el array
completo si el valor buscado está en la última posición del array. La ventaja es su
implementación sencilla y rápida, la desventaja, su ineficiencia.
 Ordenación Directo

El método de ordenación por inserción directa consiste en recorrer todo el array

comenzando desde el segundo elemento hasta el final. Para cada elemento, se trata de
colocarlo en el lugar correcto entre todos los elementos anteriores a él o sea entre los
elementos a su izquierda en el array.
Dada una posición actual p, el algoritmo se basa en que los elementos A[0], A[1], ..., A[p-
1] ya están ordenados.
De forma gráfica el proceso que sigue el método de inserción directa es el siguiente:

El método de Ordenamiento por inserción directa en Java es el siguiente:

public static void insercionDirecta(int A[]){
int p, j;
int aux;
for (p = 1; p < A.length; p++){ // desde el segundo elemento hasta
aux = A[p]; // el final, guardamos el elemento y
j = p - 1; // empezamos a comprobar con el anterior
while ((j >= 0) && (aux < A[j])){ // mientras queden posiciones y el
// valor de aux sea menor que los
A[j + 1] = A[j]; // de la izquierda, se desplaza a
j--; // la derecha
}
A[j + 1] = aux; // colocamos aux en su sitio
}
}
En el peor de los casos, el tiempo de ejecución en O(n2).
En el mejor caso (cuando el array ya estaba ordenado), el tiempo de ejecución de este
método de ordenamiento es O(n).
El caso medio dependerá de cómo están inicialmente distribuidos los elementos. Cuanto
más ordenada esté inicialmente más se acerca a O(n) y cuanto más desordenada, más se
acerca a O(n2).
El peor caso el método de inserción directa es igual que en los métodos de burbuja y
selección, pero el mejor caso podemos tener ahorros en tiempo de ejecución.
 Ordenación Externo

Ordenamiento externo es un término genérico para los algoritmos de ordenamiento que

pueden manejar grandes cantidades de información. El ordenamiento externo se requiere
cuando la información que se tiene que ordenar no cabe en la memoria principal de una
computadora (típicamente la RAM) y un tipo de memoria más lenta (típicamente un disco
duro) tiene que utilizarse en el proceso.
Un ejemplo de ordenamiento externo es el algoritmo de ordenamiento por mezcla.
Supongamos que 900 MB de información deben ser ordenados utilizando únicamente 100
MB de RAM.

1. Léanse 100MB de información en la memoria principal y ordenense utilizando un

algoritmo tradicional (típicamente quicksort).
2. Escríbase la información ordenada en el disco.
3. Repítanse los pasos 1 y 2 hasta que toda la información esté ordenada en pedazos
de 100 MB. Ahora se deben mezclar todos los pedazos ordenados.
4. Léanse los primeros 10MB de cada pedazo ordenado a la memoria principal (total
de 90 MB) y destínense los 10 MB
restantes para el buffer de salida.
5. Ordénense los nueve pedazos
mezclándolos y grábese el resultado en el
buffer de salida. Si el buffer de salida está
lleno, escríbase al archivo destino final. Si
cualquiera de los 9 buffers leídos queda
vacío, se llena con los siguientes 10 MB de
su pedazo original de 100 MB o se marca
este como completado si ya no hay
registros remanentes.
Otro ejemplo es el algoritmo
de ordenamiento por mezcla equilibrada,
que es una optimización del anterior.

Es un término genérico para los algoritmos de ordenamiento que pueden manejar grandes
cantidades de información. El ordenamiento externo se requiere cuando la información que
se tiene que ordenar no cabe en la memoria principal de una computadora (típicamente la
RAM) y un tipo de memoria más lenta (típicamente un disco duro) tiene que utilizarse en el
proceso. Existen otros tipos de memoria externa que son los USB de almacenamiento entre
otros.
La Ordenación externa de los datos están en un dispositivo de almacenamiento externo
(Archivos) y su ordenación es más lenta que la interna.
 Estudios de Conjunto Complejidades

Un algoritmo será mas eficiente comparado con otro, siempre que consuma
menos recursos, como el tiempo y espacio de memoria necesarios para ejecutarlo.

La eficiencia de un algoritmo puede ser cuantificada con las siguientes medidas de

complejidad:

1. Complejidad Temporal o Tiempo de ejecución: Tiempo de cómputo necesario para

ejecutar algún programa.
2. Complejidad Espacial: Memoria que utiliza un programa para su ejecución, La
eficiencia en memoria de un algoritmo indica la cantidad de espacio requerido para
ejecutar el algoritmo; es decir, el espacio en memoria que ocupan todas
las variables propias al algoritmo. Para calcular la memoria estática de un algoritmo
se suma la memoria que ocupan las variables declaradas en el algoritmo. Para el
caso de la memoria dinámica, el cálculo no es tan simple ya que, este depende de
cada ejecución del algoritmo.

•
• Este análisis se basa en las Complejidades Temporales, con este fin, para cada
problema determinaremos una medida N, que llamaremos tamaño de la entrada o
número de datos a procesar por el programa, intentaremos hallar respuestas
en función de dicha N.
•
• El concepto exacto que cuantifica N dependerá de la naturaleza del problema, si
hablamos de un array se puede ver a N como el rango del array, para una matriz, el
número de elementos que la componen; para un grafo, podría ser el número de nodos
o arcos que lo arman, no se puede establecer una regla para N, pues cada problema
acarrea su propia lógica y complejidad.
•

Tiempo de Ejecución
•
• El tiempo de Ejecución de un programa se mide en función de N, lo que designaremos
como T(N).
•
• Esta función se puede calcular físicamente ejecutando el programa acompañados de
un reloj, o calcularse directamente sobre el código, contando las instrucciones a ser
ejecutadas y multiplicando por el tiempo requerido por cada instrucción. Así, un trozo
sencillo de código como:

S1;
for(x = 0; x < N; x++)
S2;
Demanda: T(N) = t1 + t2 * N
Donde t1 es el tiempo que lleva ejecutar la serie S1 de sentencias, y t2 es el que lleva la
serie S2.
•
• Habitualmente todos los algoritmos contienen alguna sentencia condicional o selectiva,
haciendo que las sentencias ejecutadas dependan de la condición lógica, esto hace que
aparezca más de un valor para T(N), es por ello que debemos hablar de un rango
de valores:

Tmin(N) ≤ T(N) ≤ Tmax(N)

•
• Estos extremos son llamados "el peor caso" y "el mejor caso" y entre ambos se puede
hallar "el caso promedio" o el más frecuente, siendo este el más difícil de estudiar; nos
centraremos en el "el peor caso" por ser de fácil cálculo y se acerca a "el caso promedio",
brindándonos una medida pesimista pero fiable.
•
• Toda función T(N) encierra referencias al parámetro N, y a una serie de
constantes Ti dependientes de factores externos al algoritmo. Se tratará de analizar los
algoritmos dándoles autonomía frente a estos factores externos, buscando
estimaciones generales ampliamente válidas, a pesar de ser demostraciones teóricas.
 Ordenación Avanzada

También conocido como ordenación incremental reducida, es una versión más eficiente y
mejorada del algoritmo de ordenación por inserción directa. La clasificación de colinas es
un algoritmo de clasificación inestable. Este método se debe a DL. Shell lleva el nombre de
su propuesta en 1959. La clasificación de colinas consiste en registrar un cierto incremento
agrupado presionando el objetivo y usar el algoritmo de clasificación de inserción directa
para ordenar cada grupo; a medida que el incremento disminuye gradualmente, cada grupo
contiene más y más palabras clave. Cuando el incremento disminuye a 1, el El archivo se
divide en un grupo y el algoritmo finaliza.

Nuestro propósito de dividir los registros a ordenar es reducir el número de registros a

ordenar y hacer que toda la secuencia se desarrolle básicamente en orden. Después de
dividir los grupos como se indicó anteriormente, los métodos de clasificación respectivos
no pueden cumplir con nuestros requisitos. Por lo tanto, debemos adoptar la estrategia de
la segmentación por omisión: formar una subsecuencia de registros separados por un
cierto "incremento", para asegurar que los resultados obtenidos después de la inserción
directa y la clasificación en las subsecuencias estén básicamente ordenados en lugar de
que parcialmente ordenado.

Inicialmente, hay una secuencia desordenada de tamaño 5.

(1) En la primera ronda de clasificación, también podríamos establecer gap1 = N / 2 = 2,

es decir, los elementos separados por una distancia de 5 forman un grupo, que se puede
dividir en 5 grupos.

(2) A continuación, clasifique cada grupo de acuerdo con el método de clasificación por
inserción directa.

En la segunda ronda de clasificación, reducimos el último espacio a la mitad, es decir,

espacio2 = espacio1 / 2 = 1 (número entero). De esta forma, cada elemento separado por
una distancia de 2 forma un grupo, que se puede dividir en 2 grupos.

(3) Clasifique cada grupo según el método de clasificación por inserción directa. En este
punto, la clasificación ha finalizado.
/*

* Tipo de colina

*/

static void shellSort1(int[] a,int n){

int grp = a.length;

while (true){

grp = grp/ 2;
// Grupo de ciclo

for(int i = 0;i < grp; i++){

// Insertar y ordenar los datos de cada grupo

for (int j = i + grp; j < a.length; j=j+grp) {

int temp = 0;

// El tipo de inserción más primitivo

for (int k = j; k > 0; k=k-grp) {

if( a[k] < a[k-grp]){

temp=a[k-grp];

a[k-grp]=a[k];

a[k]=temp;

}
 }

if (grp== 1) {// gap == 1, salta del bucle

break;

}
 Conclusión
Pues en este tema se obtuvo mucho aprendizaje en esta investigación es que conoció sus
tipos y funciones y métodos de búsquedas ya que al momento de ejecutar un programa
extensos podríamos utilizar estos dichos métodos y así encontrar pues dicha información.
Hasta aquí mi tema de asignación por dado espero que sea buen gusto.
 Bibliografía

https://es.wikipedia.org/wiki/Algoritmo_de_ordenamiento
http://artemisa.unicauca.edu.co/~nediaz/EDDI/cap02.htm
http://puntocomnoesunlenguaje.blogspot.com/2015/02/ordenamiento-insercion-directa-
java.html
http://es.wikipedia.org/wiki/Algoritmo_/de_/búsqueda
http://estructura-de-datos-itsav.blogspot.com/2012/03/71-algoritmos-ordenacion-
externa.html
https://www.monografias.com/trabajos27/complejidad-algoritmica/complejidad-
algoritmica.shtml#complej
https://programmerclick.com/article/69211836250/