Algoritmos

Los algoritmos son conjuntos de instrucciones o pasos lógicos que resuelven un problema o
realizan una tarea específica. En el contexto de la programación, los algoritmos son la base
fundamental para resolver problemas de manera eficiente y automatizada.
En la programación informática, los algoritmos son conjuntos de reglas que indican al
ordenador cómo ejecutar una tarea. En realidad, un programa informático es un algoritmo
que indica al ordenador qué pasos debe realizar y en qué orden para llevar a cabo una tarea
específica. Se escriben utilizando un lenguaje de programación.
Al realizar algoritmos, los desarrolladores pueden optimizar el rendimiento de sus
aplicaciones, mejorar la escalabilidad y reducir los tiempos de respuesta. Esto se traduce en
aplicaciones más rápidas, eficientes y capaces de manejar de manera efectiva los retos y
demandas del mundo real.

Algoritmos de búsqueda
Los algoritmos de búsqueda son fundamentales en el desarrollo de aplicaciones para
encontrar elementos específicos en un conjunto de datos. En JavaScript, existen varios
algoritmos de búsqueda comunes, dos de los cuales son el Algoritmo de Búsqueda Lineal y
el Algoritmo de Búsqueda Binaria.
Algoritmo de Búsqueda Lineal
El Algoritmo de Búsqueda Lineal es el método más simple y directo para buscar un elemento
en una lista o arreglo. Comienza desde el primer elemento y recorre secuencialmente cada
uno hasta encontrar la coincidencia deseada. En el peor de los casos, si el elemento se
encuentra al final de la lista, se recorrerán todos los elementos.
function busquedaLineal(arr, elemento) {
for (let i = 0; i < arr.length; i++) {
if (arr[i] === elemento) {
return i; // Retorna el índice del elemento encontrado
}
}
return -1; // Retorna -1 si el elemento no se encuentra en el arreglo
}

const arreglo = [10, 5, 3, 8, 2, 6];

const elementoBuscado = 8;
const indice = busquedaLineal(arreglo, elementoBuscado);
console.log(`El elemento ${elementoBuscado} se encuentra en el índice ${indice}.`);

// Output:
// El elemento 8 se encuentra en el índice 3.

Algoritmo de búsqueda binaria

El Algoritmo de Búsqueda Binaria es una técnica más eficiente para buscar elementos en
una lista ordenada. Funciona dividiendo repetidamente a la mitad el rango de búsqueda
hasta encontrar la coincidencia.
Este enfoque aprovecha la propiedad de que los datos están ordenados, lo que permite
descartar la mitad de los elementos en cada paso.
Sabiendo esto, podemos decir que el Algoritmo de Búsqueda Lineal es útil cuando
trabajamos con un conjunto de datos pequeño o que no están ordenados y no se dispone de
ninguna información adicional sobre la ubicación del elemento.
Sin embargo, en casos en los que los datos están ordenados, el Algoritmo de Búsqueda
Binaria puede ser mucho más eficiente, ya que reduce el rango de búsqueda a la mitad en
cada iteración.
function busquedaBinaria(arr, elemento) {
let inicio = 0;
let fin = arr.length - 1;

while (inicio <= fin) {

let medio = Math.floor((inicio + fin) / 2);
if (arr[medio] === elemento) {
return medio; // Retorna el índice del elemento encontrado
} else if (arr[medio] < elemento) {
inicio = medio + 1;
} else {
fin = medio - 1;
}
}
return -1; // Retorna -1 si el elemento no se encuentra en el arreglo
}

const arregloOrdenado = [2, 3, 5, 6, 8, 10];

const elementoBuscado = 6;
const indice = busquedaBinaria(arregloOrdenado, elementoBuscado);
console.log(`El elemento ${elementoBuscado} se encuentra en el índice ${indice}.`);
 Algoritmos de Ordenamiento
Los Algoritmos de Ordenamiento son técnicas utilizadas para organizar los elementos de una
lista o arreglo en un orden específico. En JavaScript, existen varios algoritmos de
ordenamiento populares y de gran utilidad para los desarrolladores. A continuación, se
presentan algunos de ellos:
Algoritmo de Ordenamiento Burbuja
El algoritmo de burbuja es un método que funciona para ordenar algoritmos tanto de forma
creciente como decreciente. Con este algoritmo, iteramos e intercambiamos pares hasta
lograr mover el elemento más grande (o el más pequeño, dependiendo lo que se quiera
lograr) al final de la lista. Una vez logrado esto, se procede a mover el segundo elemento
más grande (o segundo más pequeño) al penúltimo puesto de la lista y así iremos
“burbujeando” hasta lograr el arreglo ordenado que buscamos.
A continuación, una ilustración que demuestra cómo funciona el algoritmo en su primera
iteración, siendo [5, 3, 8, 2, 6] el arreglo original. En este caso nuestro objetivo sería ordenar
el algoritmo de forma ascendente.
Como se mencionó anteriormente, nuestro objetivo en la primera iteración es mover el
elemento más grande al final. En este caso, nuestro elemento más grande es 8. En la
siguiente iteración donde i=1 nuestra meta sería mover 6 (el segundo número mayor) al
penúltimo puesto, el cual en este caso ya se encuentra ahí.
Es importante tener en cuenta que el algoritmo de ordenamiento burbuja no es eficiente para
grandes conjuntos de datos, ya que su complejidad es cuadrática (O(n^2)). Sin embargo, es
un algoritmo útil para aprender y comprender los conceptos básicos de los algoritmos de
ordenamiento.
function ordenamientoBurbuja(arr) {
const n = arr.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
// Intercambio de elementos
const temp = arr[j]
arr[j] = arr[j + 1]
arr[j + 1] = temp
}
 }
}
return arr;
}

const arreglo = [5, 3, 8, 2, 6];

const arregloOrdenado = ordenamientoBurbuja(arreglo);
console.log(arregloOrdenado); // Output: [2, 3, 5, 6, 8]

Algoritmo de ordenamiento rápido (Quicksort)

Utiliza el enfoque de "divide y vencerás" para ordenar la lista. Este algoritmo divide la lista en
subconjuntos más pequeños y ordena cada subconjunto de manera recursiva. Es uno de los
más eficientes y ampliamente utilizados para el ordenamiento. Aquí tienes un ejemplo de
implementación:
function ordenamientoRapido(arr) {
if (arr.length <= 1) {
return arr;
}

const pivot = arr[arr.length - 1];

// En muchos casos también se utiliza pivot = arr[0]

let menores = [];

let mayores = [];

for (let i = 0; i < arr.length; i++) {

if (arr[i] < pivot) {
menores.push(arr[i]);
} else {
mayores.push(arr[i]);
}
}

return [...ordenamientoRapido(menores), pivot, ...ordenamientoRapido(mayores)];

}

const arreglo = [5, 3, 8, 2, 6];

const arregloOrdenado = ordenamientoRapido(arreglo);
console.log(arregloOrdenado); // Output: [2, 3, 5, 6, 8]
 Algoritmo de Ordenamiento Notation (Notation Sort)
También conocido como Notation Sort, es un algoritmo de ordenamiento poco convencional.
A diferencia de otros algoritmos que se basan en comparaciones directas entre elementos, el
Notation Sort utiliza una notación especial para determinar el orden de los elementos en la
lista. Aunque no es un algoritmo práctico en términos de eficiencia y rendimiento, es
interesante explorar su funcionamiento y sus posibles usos en situaciones particulares.
El Algoritmo de Ordenamiento Notation se basa en la asignación de un valor numérico o una
etiqueta a cada elemento de la lista a ordenar. Estos valores numéricos o etiquetas son
generados de alguna manera específica, no necesariamente relacionada con el valor real de
los elementos. Luego, se realiza un proceso de clasificación utilizando estos valores
asignados, lo que resulta en una nueva ordenación de los elementos.
La idea detrás del algoritmo de ordenamiento Notation es que la asignación de valores o
etiquetas no depende de las comparaciones directas entre los elementos, sino de una serie
de reglas o criterios establecidos previamente. Estos criterios pueden ser arbitrarios o
basados en algún aspecto particular de los elementos. Por ejemplo, se pueden asignar
valores según el número de vocales en una cadena de texto o según la longitud de las
palabras.
function notationSort(arr) {
const sortedIndices = arr
.map((value, index) => index)
.sort((a, b) => {
const lengthA = arr[a].length;
const lengthB = arr[b].length;
return lengthA - lengthB;
});
const result = [];
for (const index of sortedIndices) {
result.push(arr[index]);
}

return result;
}

// Ejemplo de uso
const palabras = ["manzana", "perro", "gato", "banana"];
const palabrasOrdenadas = notationSort(palabras);
console.log(palabrasOrdenadas); // Output: ["gato", "perro", "banana", "manzana"]