如何按升序对奇数数组进行排序，但将偶数保留在其位置？

Question

我只想对奇数进行排序，而不移动偶数。例如，当我写：

sortArray([5, 3, 2, 8, 1, 4])

预期结果是：

[1, 3, 2, 8, 5, 4]

我是 JavaScript 的新手，我在 Internet 上遇到了一个让我感到困惑的挑战。我通常不会 post 在 Internet 上寻求解决方案，但我已经尝试了几个小时，我想在 JavaScript.

中学习这个概念

挑战状态：

你有一组数字。你的任务是对奇数进行升序排序，但偶数必须在它们的位置上。零不是奇数，你不需要移动它。如果你有一个空数组，你需要return它。

到目前为止，这是我的代码，请放轻松，我正处于编程的初级阶段。

function sortArray(array) {
  let oddNums = [];
  for(let i = 0; i < array.length; i++) {
    if(array[i] % 2 !== 0) {
      oddNums.push(array[i]);
    }
  }
  oddNums = oddNums.sort((a,b)=> a-b);
  array.concat(oddNums);
  array = array.sort((a,b) => a-b);
  return array;
}

Answer 1

就这样：

arr.sort((a, b) => a%2 && b%2 ? a - b : 0)

是否有效取决于您的浏览器使用的排序算法。独立于浏览器的版本：

for(const [i1, v1] of arr.entries())
  for(const [i2, v2] of arr.entries())
    if( v1%2 && v2%2 && (i1 < i2) === (v1 > v2))
        ([arr[i1], arr[i2]] = [v2, v1]);

Answer 2

这是一个可能的解决方案，使用稍微自定义的 selection sort：

var xs = [5, 3, 2, 8, 1, 4];

console.log(sortOddsOnly(xs));

function sortOddsOnly (xs) {
  var n = xs.length;
  for (var i = 0; i < n - 1; i++) {
    if (xs[i] % 2 === 1) {
      for (var j = i + 1; j < n; j++) {
        if (xs[j] % 2 === 1) {
          if (xs[i] > xs[j]) {
            var min = xs[j];
            xs[j] = xs[i];
            xs[i] = min;
          }
        }
      }
    }
  }
  return xs;
}

前两个if保证我们只交换奇数（x % 2 === 1表示"x is odd"）。

Answer 3

我有这样的解决方案。
先建一个排序好的奇数数组，然后依次填充剩下的偶数：

const arr = [5, 3, 2, 8, 1, 4];

const odd = arr.filter(i => i%2 !== 0).sort();
let i = 0,
  result = [];
arr.forEach(e => {
  if (e%2 === 0) {
    result.push(e)
  } else {
    result.push(odd[i]);
    i++;
  }
});

console.log(result);

Answer 4

您可以为奇数索引使用一个辅助数组，为奇数使用另一个辅助数组，对它们进行排序并将它们应用回原始数组的先前存储的索引。

var array = [5, 3, 2, 8, 1, 4],
    indices = [];

array
    .filter((v, i) => v % 2 && indices.push(i))
    .sort((a, b) => a - b)
    .forEach((v, i) => array[indices[i]] = v);

console.log(array);

Answer 5

这是一个主要使用 built-in 数组方法的解决方案。获取仅包含赔率的列表，对其进行排序，然后映射到原始对象，如果项目是奇数，则将每个项目替换为第一个排序的奇数，如果是偶数，则替换为自身：

const array = [5, 3, 2, 8, 1, 4] // to: [1, 3, 2, 8, 5, 4]

function sortOddsOnly(arr) {
    const odds = arr
        .filter(x => x%2)
        .sort((a, b) => a - b);
        
    return arr
        .map(x => x%2 ? odds.shift() : x);
}

console.log(sortOddsOnly(array));

Answer 6

一种可能的解决方案是这样的。我所做的是创建新数组 odd(原始数组中奇数位置的数组使用 Array.prototype.filter) and then sort that array using Array.prototype.sort. Then using Array.prototype.map 将原始数组的所有奇数元素的值更改为 odd数组。

x1=[5, 3, 2, 8, 1, 4];
function sortArray(array) {
  var odd = array.filter((x,i) => (i+1) % 2 ).sort((a,b) => a > b); //sort odd position and store that in new array
  return array.map((x,i) => (i+1) % 2 ? odd.shift() : x ); //if i is odd then replace it with element from 
                                                  //odd array otherwise keep the element as it is
}
console.log(sortArray(x1));

Answer 7

def sort_array(source_array):
b = sorted([n for n in source_array if  n % 2 != 0])
c = -1
d = []
for i in source_array:
    c = c+1
    if i % 2 != 0 :
        d.append(c)
for x in range (len(d)):
    z = d[x]
    source_array[z] = b[x]
return source_array

如何按升序对奇数数组进行排序，但将偶数保留在其位置？

How to sort an array of odd numbers in ascending order, but keep even numbers at their position?

javascript

arrays

sorting

modulus