# Implementación de la inserción Ordenar en JavaScript -- javascript campo con algorithm campo con sorting campo con insertion-sort camp codereview Relacionados El problema

## Implementation of insertion sort in JavaScript

2

### problema

Español

He escrito un algoritmo de clasificación de inserción en JavaScript:

` ` function insertionSort(inputArray){    var totalElements = inputArray.length - 1;   var temp = 0;   var lastIndex = 0;   var prevIndex = 0;   for(var i = 0; i <= totalElements; i++){     for(var currentIndex = i; currentIndex > lastIndex; currentIndex--){         prevIndex = currentIndex - 1;                                    if(inputArray[currentIndex] < inputArray[prevIndex]){             temp = inputArray[currentIndex];             inputArray[currentIndex] = inputArray[prevIndex];             inputArray[prevIndex] = temp;                                         }else{             break;         }     }    }    return inputArray; }  console.log(insertionSort([1,31,26,4,3,12])); console.log(insertionSort([5,6,1,2,3,4]));    ``

La salida también es correcta:

` ` rahul@rahul:~/myPractise/Algo\$ node sorting.js  [ 1, 3, 4, 12, 26, 31 ] [ 1, 2, 3, 4, 5, 6 ] rahul@rahul:~/myPractise/Algo\$  ` `

¿Puede mejor mejorarse esto?

Original en ingles

I have written an insertion sort algorithm in JavaScript:

``function insertionSort(inputArray){    var totalElements = inputArray.length - 1;   var temp = 0;   var lastIndex = 0;   var prevIndex = 0;   for(var i = 0; i <= totalElements; i++){     for(var currentIndex = i; currentIndex > lastIndex; currentIndex--){         prevIndex = currentIndex - 1;                                    if(inputArray[currentIndex] < inputArray[prevIndex]){             temp = inputArray[currentIndex];             inputArray[currentIndex] = inputArray[prevIndex];             inputArray[prevIndex] = temp;                                         }else{             break;         }     }    }    return inputArray; }  console.log(insertionSort([1,31,26,4,3,12])); console.log(insertionSort([5,6,1,2,3,4]));  ``

The output is also proper:

``rahul@rahul:~/myPractise/Algo\$ node sorting.js  [ 1, 3, 4, 12, 26, 31 ] [ 1, 2, 3, 4, 5, 6 ] rahul@rahul:~/myPractise/Algo\$ ``

Can this be further improved?

## Lista de respuestas

2

La mejor respuesta

Su función solo puede ordenar los números y las cadenas

La función ` 9988776665544330 ofrece una función de comparación opcional como un parámetro. Agregar esta función a su función 9988776665544331 ` permitiría a los usuarios ordenar cualquier tipo de objeto:

` ` function defaultCompare(x, y) {   if (x < y)     return -1;   else if (x > y)     return 1;   else     return 0; }  function insertionSort(array, compare) {   compare = compare ? compare : defaultCompare;   //... }  ` `

tiene bastantes variables que no son necesarias

` totalElements3 `

Usted solo usa esta variable una vez, en la condición de su primer ` for ` bucle. JavaScript tiene algunos motores increíblemente rápidos y con JIT-Compiler (solo en el Time Compiler), no tiene que preocuparse por las optimizaciones de micromanagia, como si JS no es lo suficientemente inteligente como para saber que está recalculando ` inputArray.length - 1 ` cada uno iteración. Definir ` totalElements ` posiblemente hace que su código sea más difícil de leer agregando otra variable del alcance, y los motores JS son lo suficientemente inteligentes / lo suficientemente rápidos que el rendimiento no se ve afectado, por lo que recomendaría deshacerse de eso.

` temp `

Podría eliminar ` temp ` al abstraer una función para intercambiar índices en una matriz:

` ` function swapIndices(array, index1, index2) {   var temp = array[index1];   array[index1] = array[index2];   array[index2] = temp; }   ``

Esto también mejora la cohesión de su código al abstraer los aspectos técnicos de las variables de intercambio, y le permite usar ` insertionSort0 ` en otra parte de su código.

` insertionSort1 `

Este es solo una constante para cero. Por lo menos, debe cambiar el ` insertionSort2 a insertionSort3 : `

` ` insertionSort4  ``

Pero me recomendaría que me deshaga de ello.

` insertionSort5 `

Encuentro ` insertionSort6 ` Más claro que ` insertionSort7 . El primero es obviamente el índice 1 menos que insertionSort8 `

` Summary `

` Con todos los cambios anteriores, su código se vería como: insertionSort9 `

Your function can only sort numbers and strings

The built in `Array.sort` function offers an optional compare function as a parameter. Adding this feature to your `insertionSort` function would allow for users to sort any type of object:

``function defaultCompare(x, y) {   if (x < y)     return -1;   else if (x > y)     return 1;   else     return 0; }  function insertionSort(array, compare) {   compare = compare ? compare : defaultCompare;   //... } ``

You have quite a few variables that aren't necessary

`totalElements`

You only use this variable once, in the condition of your first `for` loop. JavaScript has some incredibly fast engines and with JIT-Compiler (just in time compiler) you don't have to worry about micromanaging optimizations like what if js isn't smart enough to know that it's recalculating `inputArray.length - 1` each iteration. Defining `totalElements` arguably makes your code harder to read by adding another variable the scope, and the JS engines are smart-enough/fast-enough that performance isn't likely affected, so I would recommend getting rid of it.

`temp`

You could eliminate `temp` by abstracting out a function to swap indices in an array:

``function swapIndices(array, index1, index2) {   var temp = array[index1];   array[index1] = array[index2];   array[index2] = temp; } ``

This also improves your code's cohesiveness by abstracting out the technicalities of swapping variables, and it allows you to use `swapIndices` elsewhere in your code.

`lastIndex`

This one is just a constant for zero. At the very least you should change the `var` to `const`:

``const lastIndex = 0; ``

But I'd recommend to just get rid of it.

`prevIndex`

I find `currentIndex - 1` more clear than `prevIndex`. The former is obviously the index 1 less than `currentIndex` whereas the latter could also mean the previously swapped element (precedingIndex is another possible name).

Summary

With all the above changes your code would look like:

``function defaultCompare(x, y) {   if (x < y)     return -1;   else if (x > y)     return 1;   else     return 0; }  function swapIndices(array, index1, index2) {   var temp = array[index1];   array[index1] = array[index2];   array[index2] = temp; }  function insertionSort(array, compare) {   compare = compare ? compare : defaultCompare;    for (let i = 0; i < array.length; i++) {     for (let currIndex = i; currIndex > 0; currIndex--) {       if (compare(array[currIndex], array[currIndex - 1]) < 0) {         swapIndices(array, currIndex, currIndex - 1);       }       else {         break;       }     }   }    return array; } ``

0

Después de leer y ejecutar su código, pensé que podría hacer tu vida más fácil al encender este pseudocódigo en > Sort de inserción a JavaScript.

` ` 99887766555443320 ` `

Nota:

• Tantas variables se definieron ` function defaultCompare(x, y) { if (x < y) return -1; else if (x > y) return 1; else return 0; } function insertionSort(array, compare) { compare = compare ? compare : defaultCompare; //... } 1 , function defaultCompare(x, y) { if (x < y) return -1; else if (x > y) return 1; else return 0; } function insertionSort(array, compare) { compare = compare ? compare : defaultCompare; //... } 22 , function defaultCompare(x, y) { if (x < y) return -1; else if (x > y) return 1; else return 0; } function insertionSort(array, compare) { compare = compare ? compare : defaultCompare; //... } 3 y 99887766555443324 ` que fueron innecesarios. En el código a continuación, utilicé dos variables llamada ` function defaultCompare(x, y) { if (x < y) return -1; else if (x > y) return 1; else return 0; } function insertionSort(array, compare) { compare = compare ? compare : defaultCompare; //... } 5 y function defaultCompare(x, y) { if (x < y) return -1; else if (x > y) return 1; else return 0; } function insertionSort(array, compare) { compare = compare ? compare : defaultCompare; //... } 6 para servir como posiciones para la inserción y los valores para incluir en esas posiciones `
• También he reemplazado su segundo por declaración con un bucle while. Yo usaría mientras el bucle con una clasificación continua en lugar de un bucle

After reading and running your code, I thought I could make your life easier by turning this pseudocode at Insertion Sort to javascript.

``   function insertionSort(inputArray){     var holePosition     var valueToInsert          for(var i = 1; i< inputArray.length; i++){                 /* select value to be inserted */           valueToInsert = inputArray[i]           holePosition = i                /* Notice I used the while as opposed to the for*/     while ( holePosition > 0 && inputArray[holePosition-1] > valueToInsert){              inputArray[holePosition] = inputArray[holePosition-1]              holePosition = holePosition -1                  }           /* insert the number at hole position */           inputArray[holePosition] = valueToInsert     }     return inputArray;     } var result =insertionSort([1,31,26,4,3,12]); alert('['+ result.join() + ']');``

Note:

• So many variables were defined `totalElements`, `temp`, `lastIndex` and `prevIndex` which were unnecessary. In the code below, I utilised two variables called `holePosition` and `valueToInsert` to serve as Positions for insertion and the values to include in those positions
• I have also replaced your second for statement with a while loop. I would use while loop with a continuous sorting as opposed to a for loop

7  Realización de la inserción ordena en C #  ( Performing insertion sort in c )
Este es mi código en C # para realizar una especie de inserción: static int[] performInsertionSort(int[] inputarray) { for (int i = 0; i < inputarray.L...

2  Ordenar una matriz de cuerdas usando los punteros (seguimiento)  ( Sorting an array of strings using pointers followup )
Este es un seguimiento para este post . cosas que he cambiado: Se verifica el número de cadenas. Estoy usando punteros ahora. Usaré fgets en situ...

3  Optimización del tiempo de contar los cambios en la inserción  ( Time optimization of counting shifts in insertion sort )
¿Hay alguna forma de contar cuántos turnos se necesitaría para contar los cambios al hacer una especie de inserción? Este es un problema de hackterank. Aquí e...

5  Ordenador de inserción revisado con la salida a la consola  ( Insertion sort revised with output to console )
Tomé la pregunta Realización de la inserción Ordenar en C # y ordenó un poco, luego pensé en el Uso de las matrices y se preguntaba si funcionaba, y lo hace...

3  Ordenar una matriz de cuerdas en C usando un tipo de inserción  ( Sorting an array of strings in c using insertion sort )
Soy un programador Java que tiene C este semestre. No hace falta decir que mi estilo de escritura está fuertemente influenciado por Java, que probablemente no...

5  Clasificación de inserción a través de la recursión  ( Insertion sort via recursion )
Estoy aprendiendo sobre algoritmos y he estado experimentando recientemente con una especie de inserción a través de la recursión en Python. Mi código funci...

17  Clasificación de inserción en C ++  ( Insertion sorting in c )

9  Implementación de clasificación de inserción adaptada desde la web  ( Insertion sort implementation adapted from the web )
He encontrado esta implementación en la web: VersionFactory9 He escrito esto: isCompatible()0 ¿Hay algún problema con esta implementación? ...

4  Ordenador de inserción en Lisp comunes  ( Insertion sort in common lisp )
Este es mi primer código significativo en Common Lisp, una implementación del tipo de inserción. Siendo nuevo en Lisp en general, me pregunto si este Código s...

7  Insertar ordenar en una lista vinculada  ( Insert sort on a linked list )
Quiero hacer un orden de inserción en una lista vinculada sin usar los nodos ficticios. Este es mi código. ¿Cómo se puede mejorar esto? Se aprecia cualquier...