Swift 对数组进行排序，以便在偶数之前进行赔率计算

给定一个数组，然后对其进行排序，使赔率在偶数之前出现。 因此，我在Swift中编写了如下方法。我看不出这种方法有什么错误，但逻辑是不正确的。 任何人能给我线索都能救我的命。 提前谢谢

代码如下：

class OddsBeforeEvens {
    func sortArrayOddsBeforeEvens(var array: [Int]) -> [Int]? {
        if array.isEmpty { return nil }
        let length = array.count
        var begin = 0
        var end = length - 1
        var temp: Int
        while (begin < end) {
            while (begin < end && array[begin] / 2 != 0) {
                begin += 1
            }
            while (begin < end && array[end] / 2 == 0) {
                end -= 1
            }
            if (begin < end) {
                temp = array[begin]
                array[begin] = array[end]
                array[end] = temp
            }
        }

        return array
    }
}   

oddsbeforevens类{
func Sortarayoddsbeforevens（变量数组：[Int]）->[Int]{
if array.isEmpty{return nil}
让length=array.count
var begin=0
var end=长度-1
变量温度：Int
while（开始<结束）{
while（begin

您可以在swift中使用

排序功能，如下所示：

let arr = [1,3,4,5,9,10,50,2,8,12,34,53,88,23]

let arrSorted  = arr.sort { (a, b) -> Bool in
    return a % 2 != 0
}

要获得排序的赔率和排序的偶数：

let arrSorted  = arr.sort { (a, b) -> Bool in
    if (a % 2 != 0) {
        if (b % 2 != 0) {
            return a < b
        } else {
            return true
        }
    } else {
        return a < b
    }
}

let arrsorded=arr.sort{（a，b）->Bool-in
如果（a%2！=0）{
如果（b%2！=0）{
返回a
作为一种替代方法，您可以通过对数组进行两次
筛选操作来分离赔率和偶数，并简单地将两个结果数组连接起来，奇数数组先于偶数数组

func sortArrayOddsBeforeEvens(array: [Int]) -> [Int] {
    let odds = array.filter{ $0 % 2 != 0 }
    let evens = array.filter{ $0 % 2 == 0 }
    return odds + evens
}     

print(sortArrayOddsBeforeEvens([1,4,3,7,8,11,12,27,18]))
// [1, 3, 7, 11, 27, 4, 8, 12, 18]

或者


这在实践中不应该是一个问题，除非您正在编写一些HPC应用程序（在这种情况下，Swift可能不是最佳的选择语言），但是如果您出于某种原因担心wr.t的性能。在上面的两个
筛选
操作中，您可以使用
$0%2
的结果（它总是在集合
{0，1}
中）直接作为指向两个给定结果数组之一的索引。例如

func sortArrayOddsBeforeEvens(array: [Int]) -> [Int] {
    var arr: [[Int]] = [[],[]]
    array.forEach { arr[$0 % 2].append($0) }
    return arr[1] + arr[0]
} 

print(sortArrayOddsBeforeEvens([1,4,3,7,8,11,12,27,18]))
// [1, 3, 7, 11, 27, 4, 8, 12, 18]

受Hoa答案的启发，这里提供了一种排序方法，可以确保您获得一个“”。因此，您将拥有所有奇数值，然后是偶数值。在每个组中，值将被排序

let arr = [1,3,4,5,9,10,50,2,8,12,34,53,88,23]

let arrSorted  = arr.sort { (a, b) -> Bool in
    // If a and b are both even (or odd), we simply compare them
    if a % 2 == b % 2{
        return (b>a)
    }
    // Else, we just put the odd values first
    return a % 2 != 0
}

此示例给出了以下结果：

[1, 3, 5, 9, 23, 53, 2, 4, 8, 10, 12, 34, 50, 88]

虽然@dfri的解决方案运行良好，看起来比我的好得多，但性能是2n，这意味着过滤器可以循环通过
该数组被删除两次。如果您追求性能，您可以使用此代码，因为它只在数组中循环一次，所以速度应该是原来的两倍

func sortArrayOddsBeforeEvens(array: [Int]) -> [Int] {
    var odds = []
    var evens = []
    for int in array {
        if int % 2 == 0 {
            evens.append(int)
        } else {
            odds.append(int)
    }
    return odds + evens
} 

您试过调试代码吗？似乎您必须使用
%2！=0而不是
/2！=0
来检测数字是奇数还是偶数。@Hoa，非常感谢！我犯了一个很严重的基本错误，我很久没发现了！非常感谢。这可能是偶然的，但您的比较函数不是所需的“严格弱排序”：这太棒了！我会记在心里的！谢谢分享！这不会将数字从最小值排序到最大值。OPI没有要求这样做，这意味着在中，当然，当它不做相同的事情时，您的将更快。我不是想说你做错了——这可能正是OP想要的。
func sortArrayOddsBeforeEvens(array: [Int]) -> [Int] {
    var odds = []
    var evens = []
    for int in array {
        if int % 2 == 0 {
            evens.append(int)
        } else {
            odds.append(int)
    }
    return odds + evens
}