JavaScript 中的选择排序答案

【问题标题】：Selection Sort in JavaScriptJavaScript 中的选择排序
【发布时间】：2014-04-06 19:33:25
【问题描述】：

function newsort(arr, left, right){    

for(var i= left; i < right; ++i){
    var min = i;
    for (var j = i; j < right; ++j){
        if (arr[min] > arr[j]){
        min = j;
        }
    }

var temp = arr[min];
arr[min] = arr[i];
arr[i] = temp;  

}
return arr;

}

var arr = [3,5,66,78,23,44,11,32,58];
alert(newsort(arr, arr.length, 0));

上面是我写的一个函数的代码。我对 JS 还是很陌生，因此在语法方面有时会感到困惑。我目前只是返回原始数组，但我正在尝试进行选择排序，右/左/中类型.....我现在无法判断发生了什么。我只是想排序然后返回数组。

有谁能给我指出正确的方向吗？

谢谢.....

【问题讨论】：

从外观上看，盯着屏幕太久的经典案例，该功能有效 - 您只是以错误的顺序传递了 left 和 right 参数。
数组有一个排序方法[3,1,2].sort()，并通过将其作为参数传递MDN sort doc来使用自定义排序函数@
我不明白您要做什么，但是如果您想对数组进行排序，为什么不使用 sort() 方法？ arr.sort(function(a,b){return a-b}) 将对数组进行排序。检查w3schools.com/jsref/jsref_sort.asp
@PatrickEvans 可能是出于教育目的
@aduch，这就是为什么我没有说他应该使用它:)。既然他说他是 js 新手，就让他知道有一种排序方法和一种使用自定义排序方法的方法。

标签： javascript arrays sorting

【解决方案1】：

您的代码的问题是左右参数以错误的方式传递。这是工作代码：alert(newsort(arr, 0 ,arr.length));

【讨论】：

这就是为什么 IMO 的 left 和 right 的适当名称将是 start 和 end。

【解决方案2】：

var selectionSort = function(array){
  for(var i = 0; i < array.length; i++){
    //set min to the current iteration of i
    var min = i;
    for(var j = i+1; j < array.length; j++){
      if(array[j] < array[min]){
       min = j;
      }
    }
    var temp = array[i];
    array[i] = array[min];
    array[min] = temp;
  }
  return array;
};
var array = [3,2,10,1]
console.log('selectionSort should return [1,2,3,10]-->',selectionSort(array));

如果您使用辅助交换功能，可能会更容易推理：

//HELPER FUNCTION
var swap = function(array, firstIndex, secondIndex){
    var temp = array[firstIndex];
    array[firstIndex]  = array[secondIndex];
    array[secondIndex] = temp;
};
var array = [2,1];
swap(array, 0, 1)
console.log('swap should return [1,2] -->', array);


var selectionSort = function(array){
  for(var i = 0; i < array.length; i++){
    //set min to the current iteration of i
    var min = i;
    for(var j = i+1; j < array.length; j++){
      if(array[j] < array[min]){
        min = j;
      }
    }
    swap(array, i, min);
  }
  return array;
};
var array = [3,2,10,1]
console.log('selectionSort should return [1,2,3,10]-->',selectionSort(array));

选择排序的视觉效果：

[3,1,2]
 |-----> iterate over list. find that min = 1 so we swap current i (3) with min(1)

[1,3,2]
   |---> iterate over list. find that min = 2 so we swap current i (3) with min(2)

[1,2,3]
     |---> iterate over list. find that min = 3 so we swap current i (3) with min(3)

【讨论】：

解构是 ES2015 中 JavaScript 的一项功能，可以在一行中处理交换：[array[i], array[min]] = [array[min], array[i]];。知道如何编写自己的交换函数仍然很好，但解构是工具带中的一个很棒的新工具。 You can read more about destructuring on MDN.

【解决方案3】：

雄辩的解决方案：

const selectionSort = (items) => {
  items.forEach((val, i, arr) => {
    const smallest = Math.min(...arr.slice(i))
    const smallestIdx = arr.indexOf(smallest)

    if (arr[i] > arr[smallestIdx]) {
      const temp = arr[i]
      arr[i] = arr[smallestIdx]
      arr[smallestIdx] = temp
    }
  })

  return items
}

标准解决方案：

const selectionSort = (arr) => {
  for (let i=0; i <= arr.length-1; i++) {
    // find the idnex of the smallest element
    let smallestIdx = i

    for (let j=i; j <= arr.length-1; j++) {
      if (arr[j] < arr[smallestIdx]) { 
        smallestIdx = j
      }
    }

    // if current iteration element isn't smallest swap it
    if (arr[i] > arr[smallestIdx]) {
      let temp = arr[i]
      arr[i] = arr[smallestIdx]
      arr[smallestIdx] = temp
    }
  }

  return arr
}

测试：

console.log( // [14, 29, 56, 72, 92, 98] 
  selectionSort([29, 72, 98, 14, 92, 56]) 
)

【讨论】：

【解决方案4】：

const selectionSort = array => {
  const arr = Array.from(array); // avoid side effects
  for (let i = 0; i < arr.length - 1; i++) {
    let minPos = i;
    for (let j = i + 1; j < arr.length; j++) {
      if (arr[j] < arr[minPos]) {
        minPos = j;
      }
    }
    if (i !== minPos) {
      [arr[i], arr[minPos]] = [arr[minPos], arr[i]];
    }
  }
  return arr;
};

【讨论】：

【解决方案5】：

你基本上是在做选择开始是相反的顺序，这是行不通的。

你的左边应该以 0 开头，右边应该以 arr.length 结尾。

newsort(arr, 0 ,arr.length); 这应该可以。

如果您想在 javascript 中实现选择排序，请查看此链接。

https://learnersbucket.com/examples/algorithms/selection-sort-in-javascript/

【讨论】：

【解决方案6】：

选择排序算法说：重复寻找未排序数组的最小值。

递归方法

查找最小数字及其索引/位置
从数组中删除最小项并将其附加到同一项的末尾
每次迭代后，在找到最小值时提供未排序的数组（如果没有，您将再次获得上一个最小值）。请参阅 Math.min 的参数

注意：为了对未排序数组的元素进行排序，需要 selectionSort (i) 的第二个参数

function selectionSort(arr, i) {
  if (i === 0) {
    return arr;
  }
  const min = Math.min(...arr.filter((x, j) => j < i));
  const index = arr.findIndex(x => x === min);
  arr.splice(index, 1);
  arr.push(min);
  return selectionSort(arr, --i);
}

const unsortedArr = [5, 34, 5, 1, 6, 7, 9, 2, 100];
console.log('result', selectionSort(unsortedArr , unsortedArr.length))

【讨论】：

【解决方案7】：

function selectionSort(array_size, array) {
var min_index = 0;
for (var i = 0; i < array_size - 1; i++) {
    min_index = i;
    for (var j = i + 1; j < array_size; j++) {
        if (array[min_index] > array[j]) {
            min_index = j;
        }
    }
    [array[min_index],array[i]] = [array[i],array[min_index]]
}
return array

}

【讨论】：

【解决方案8】：

function selectionSort(inputArr) {
  let n = inputArr.length;

  for (let i = 0; i < n; i++) {
    // Finding the smallest number in the subarray
    let min = i;
    for (let j = i + 1; j < n; j++) {
      if (inputArr[j] < inputArr[min]) {
        min = j;
      }
    }
    if (min != i) {
      // Swapping the elements
      let tmp = inputArr[i];
      inputArr[i] = inputArr[min];
      inputArr[min] = tmp;
    }
  }
  return inputArr;
}

const numbers = [50, 30, 10, 40, 60];

console.log(selectionSort(numbers));

// Output: [ 10, 30, 40, 50, 60 ]

【讨论】：

【解决方案9】：

这是一个简单的选择排序算法。

let array = [64, 25, 3, 3, 22, 11, 44, 43, 12, 65, 213, 7, 3, 6, 3, 0, 6565, 43];
const selectionSort = a => {
  let sa = [];
  let len = a.length;
 for(let i=0;i<len;i++) {
   sa.push(Math.min(...a));
    a.splice(a.indexOf(Math.min(...a)), 1)
 }
 return sa;
}
selectionSort(array) // returns sorted array;

【讨论】：

【解决方案10】：

function selectionSort(arr) {

    var temp = 0;
    for (var i = 0; i < arr.length; ++i) {
        for (var j = i + 1; j < arr.length; ++j) {
            if (arr[i] > arr[j]) { // compare element with the reset of other element
                temp = arr[i];  // swap the valuse from smallest to gretest
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
    return (arr);
}

selectionSort([4,6,5,3,7,9]);

【讨论】：