Javascript 递归选择排序（JS）

我正在用JavaScript编写递归选择排序

预期行为：我希望函数

selectionSort（）

按升序对数组中的值进行排序

问题：我无法摆脱递归，也不知道如何摆脱

错误：

未捕获范围错误：超过最大调用堆栈大小

---

这是我的密码：

const findsmalestindex=（arr）=>{
设最小值=arr[0]；
设smallestIndex=0；
设arrLen=arr.长度；
for（设i=0；i{
设最小值=arr.拼接（FindSalestIndex（arr），1）；
return[minimable].concat（selectionSort（arr））；
};
设arr=[23,43,23423,66,5,57,78,0,1]；
console.log（selectionSort（arr））
如果（！arr.length）返回[]，则必须添加完成递归的条件（所谓的基本情况）

arr.splice（findsmalestindex（arr），1）
返回数组，无需在
[最小值]…
-只需
最小值.concat（selectionSort（arr））
改进：您的代码变异了
arr
（注），因此我们可以通过添加
让newArray=Array.prototype.slice.call（arr）来修复它


/**
*查找数组的最小元素
*@param{Array}arr用于搜索的数组
*数组中最小元素的@return{number}索引
*/
常量findsmalestindex=（arr）=>{
设最小值=arr[0]；
设smallestIndex=0；
设arrLen=arr.长度；
for（设i=0；i{
如果（！arr.length）返回[]；
让newArray=Array.prototype.slice.call（arr）；
设最小值=arr.拼接（FindSalestIndex（arr），1）；
返回最小的.concat（selectionSort（arr））；
};
设arr=[23,43,23423,66,5,57,78,0,1]；
console.log（selectionSort（arr））
如果（！arr.length）返回[]，则必须添加完成递归的条件（所谓的基本情况）

arr.splice（findsmalestindex（arr），1）
返回数组，无需在
[最小值]…
-只需
最小值.concat（selectionSort（arr））
改进：您的代码变异了
arr
（注），因此我们可以通过添加
让newArray=Array.prototype.slice.call（arr）来修复它


/**
*查找数组的最小元素
*@param{Array}arr用于搜索的数组
*数组中最小元素的@return{number}索引
*/
常量findsmalestindex=（arr）=>{
设最小值=arr[0]；
设smallestIndex=0；
设arrLen=arr.长度；
for（设i=0；i{
如果（！arr.length）返回[]；
让newArray=Array.prototype.slice.call（arr）；
设最小值=arr.拼接（FindSalestIndex（arr），1）；
返回最小的.concat（selectionSort（arr））；
};
设arr=[23,43,23423,66,5,57,78,0,1]；
console.log（selectionSort（arr））以下是更有效的方法

function selectionSort(arr) {

    var swap = function(x, y) {
        var temp = arr[y];
        arr[y] = arr[x];
        arr[x] = temp;
    }

    var sort = function(start) {
        if (start === arr.length) {
            return arr;
        }

        var min = start;

        for (var i = start + 1; i < arr.length; i++) {
            if (arr[i] < arr[min]) {
                min = i;
            }
        }

        swap(start, min);

        return sort(start + 1);
    }

    return sort(0);
}

selectionSort([23, 43, 23423, 66, 5, 57, 78, 0, 1]);

功能选择排序（arr）{
变量交换=函数（x，y）{
var-temp=arr[y]；
arr[y]=arr[x]；
arr[x]=温度；
}
变量排序=函数（开始）{
如果（开始===arr.length）{
返回arr；
}
var min=启动；
对于（变量i=start+1；i
以下是更有效的方法

function selectionSort(arr) {

    var swap = function(x, y) {
        var temp = arr[y];
        arr[y] = arr[x];
        arr[x] = temp;
    }

    var sort = function(start) {
        if (start === arr.length) {
            return arr;
        }

        var min = start;

        for (var i = start + 1; i < arr.length; i++) {
            if (arr[i] < arr[min]) {
                min = i;
            }
        }

        swap(start, min);

        return sort(start + 1);
    }

    return sort(0);
}

selectionSort([23, 43, 23423, 66, 5, 57, 78, 0, 1]);

功能选择排序（arr）{
变量交换=函数（x，y）{
var-temp=arr[y]；
arr[y]=arr[x]；
arr[x]=温度；
}
变量排序=函数（开始）{
如果（开始===arr.length）{
返回arr；
}
var min=启动；
对于（变量i=start+1；i
“不起作用”怎么说？你看到了什么？你期待什么呢？当您使用调试器逐步完成代码时，您看到的是什么？您不明白吗？@t.J.Crowder我无法摆脱递归，我不知道您的递归如何没有基本情况！“不起作用”怎么说？你看到了什么？你期待什么呢？当您使用调试器逐步完成代码时，您看到的是什么？您不明白吗？@t.J.Crowder我无法摆脱递归，我不知道您的递归如何没有基本情况！值得注意的是，此解决方案会发生变异
arr
，对于较大的数组，这将导致堆栈崩溃，而且速度相当缓慢，因为每个递归步骤都会创建一个新数组。@ftor谢谢。似乎我已经解决了这个问题。值得注意的是，这个解决方案会发生变异
arr
，对于较大的数组，它会破坏堆栈，速度会相当慢，因为每个