选择在JavaScript中排序

Question

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的新手，因此在语法方面有时会感到困惑。我目前只是返回原始数组，但我正在尝试进行选择排序，右/左/中间类型......我无法真正告诉目前发生了什么。我只是尝试排序然后返回数组。

那里的任何人都能指出我正确的方向吗？

感谢.....

Answer 1

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

Answer 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)

Answer 3

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

您的左侧应以0开头，右侧应以arr.length结尾。

newsort(arr, 0 ,arr.length);这应该起作用。

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

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

Answer 4

假设您可以使用内置在JS方法中的.push和.splice。 因此，您的决定将是这样的：

• 创建两个数组，一个数组包含数据，另一个数组为空；
• 在第一个迭代过程中，找到最小的元素并将其推入第二个数组；
• 因为结果数组中有新元素，所以我们希望可以从第一个数组中删除该元素以完成一次循环，为此，我们有内置的.splice方法，该方法可以对数组进行更改并返回删除的项。

let arr = [4, 1, 8, 10, 23, 3], result = []

while (arr.length > 0) {
  let minElIdx = 0

  for (let i=0; i < arr.length; i++) {
    if (arr[i] < arr[minElIdx])  {
            minElIdx = i
        }
  }

  result.push(arr.splice(minElIdx, 1)[0])
}

result // => [1, 3, 4, 8, 10, 23]

您应该注意.splice带有两个参数，其中第一个是元素的索引，第二个是要在其索引之后删除的元素计数。

Answer 5

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

递归方法

1. 找到最小数量及其索引/位置
2. 从数组中删除最小项，并将其追加到同一项的末尾
3. 在每次迭代之后，找到最小值时，请提供未排序的数组（否则，您将再次获得先前的最小值）。参见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))

Answer 6

口才解决方案：

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]) 
)

Answer 7

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;
};

Answer 8

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

}

Answer 9

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 ]

Answer 10

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

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;

Answer 11

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]);