Node.js 如何不使用循环对数组进行排序

在Node.js中，有一个内置的sort()方法可用于对数组进行排序而不需要头疼。然而，作为一个初学者，要学习sort()方法的内部工作原理，用户应该学习各种排序算法。

在本教程中，我们将学习一种不同的算法，在NodeJS中不使用循环对数组进行排序。

使用setInterval()方法

setInterval()方法允许我们在每个区间后调用任何特定的函数。此外，我们可以将setInterval()方法的id存储在任何变量中，并在以后使用它来清除间隔。

因此，我们可以在setInterval()方法中调用一个回调函数，从数组中找到最小的元素，将其推送到排序的数组中，并将最小的元素替换为Infinity值。

语法

用户可以按照下面的语法来使用setInterval()方法对数组进行排序，不需要使用NodeJS的循环。

let interval = setInterval(sort_callback, 2);

// in sort_callback() function
let min_from_array = Math.min.apply(null, array);
sorted_Array.push(min_from_array);
array[array.indexOf(min_from_array)] = Infinity;
if (++len == array.length) {
   clearInterval(interval);
}

操作步骤

第1步 - 使用setInterval()方法，在每2秒后调用sort_callback()函数。

第 2 步 – 使用Math.min.apply()方法从数组中获取最小元素。

第 3 步–将最小元素推到数组中。

第 4 步 – 使用最小元素的索引，用无穷大的值替换最小元素。

第 5 步 – 如果len变量的值等于数组的长度，这意味着所有数组元素都被排序了，并通过setInterval()方法清除间隔以停止执行sort_callback()函数。

例子

在下面的例子中，我们已经创建了数字数组，并应用上述算法对数组进行升序排序。用户可以使用Math.max.apply()方法对数组进行降序排序，并为最大元素分配负的Infinity值。

let array = [10, 20, 45, 21, 32, 11, 9, 8, 65];
console.log("The original array is");
console.log(array);
let interval = setInterval(sort_callback, 2);
let len = 0;
let sorted_Array = [];
function sort_callback() {
   let min_from_array = Math.min.apply(null, array);
   sorted_Array.push(min_from_array);
   array[array.indexOf(min_from_array)] = Infinity;
   len++;
   if (len == array.length) {
      clearInterval(interval);
      console.log("The sorted array is");
      console.log(sorted_Array);
   }
}

使用array.reduce()方法

我们可以在array.reduce()方法的每一次迭代中不断提取数组中的最小元素，并将其推送到sorted_array中。通过这种方式，一旦reduce()方法执行完毕，我们就可以得到排序后的数组。

语法

用户可以按照下面的语法来使用array.reduce()方法对数组进行排序，而无需在NodeJS中使用循环。

arr.reduce((sorted_Array, element) => {
   let min_from_array = Math.min.apply(null, arr);
   sorted_Array.push(min_from_array);
   arr[arr.indexOf(min_from_array)] = Infinity;
   return sorted_Array;
}, []);

在上面的语法中，我们从一个数组中提取最小元素，将其推入一个数组中，用无穷大替换最小元素，然后从reduce()方法中返回排序后的数组。

例子

在下面的例子中，sort_array()函数使用reduce()方法来排序数组。一旦完成reduce()方法的迭代，我们从函数中返回排序后的数组。

let arr = [
   100, 99, 32, 45, 6567898, 32, 123, 54, 7, 89, 745, 43, 34, 232, 121, 23, ];
console.log("The original array is " + arr);
function sort_array() {
   return arr.reduce((sorted_Array, element) => {
      let ind = 0;
      let min_from_array = Math.min.apply(null, arr);
      sorted_Array.push(min_from_array);
      arr[arr.indexOf(min_from_array)] = Infinity;
      return sorted_Array;
   }, []);
}
console.log("The sorted array is ", sort_array());

用户可以在输出中发现原始数组和排序后的数组之间的差异。

使用递归方案

我们将在这种方法中实现递归的冒泡排序算法来对数组进行排序。冒泡排序算法使用两个循环来遍历数组，交换元素，并对整个数组进行排序。

在这里，我们将用一个递归方案取代外层for循环。

语法

用户可以按照下面的语法来实现递归的冒泡排序算法。

function recursive_sort(array, index) {
   if (index == 1)
   return;
   var count = 0;
   for (var i = 0; i < index - 1; i++)

   // swap array elements if it’s not sorted
   return recursive_sort(array, index - 1);
}

操作步骤

第1步 - 先写一个基本案例。如果索引变成等于1，执行返回语句。

第2步 - 将count变量初始化为0。

第 3步 - 使用for循环遍历数组，如果两个元素没有被排序，就交换元素。当我们交换元素时，将count的值增加1。

第4 步 – 如果count值为0，则不需要再进行交换，并从函数中返回。

第 5步 - 递归函数调用，通过减少1的值索引，减少一次迭代。

例子

在下面的例子中，我们在NodeJS中使用了递归气泡排序函数来对一个数组进行排序。我们使用了临时变量来交换两个变量。

var arr = [613, 65, 654, 4, 65, 4, 61, 631, 6513, 89, 7, 97, 09, 98];
console.log("The original array is " + arr);
function recursive_sort(array, index) {

   // return statement for the base case
   if (index == 1) return;
   var count = 0;

   // swap elements that are not in sorted order
   for (var i = 0; i < index - 1; i++)
   if (array[i] > array[i + 1]) {
      var temp = array[i];
      array[i] = array[i + 1];
      array[i + 1] = temp;
      count++;
   }

   // if any swap does not occur, execute the return;
   if (count == 0) return;

   // call recursive_sort index-1 times, to swap element index-1 times
   return recursive_sort(array, index - 1);
}
recursive_sort(arr, arr.length);
console.log("The sorted array is ", arr);