Ios 快速稳定排序？

此时（2015年3月28日）：如果我想在swift中使用稳定排序，我必须使用

NSArray

和

sortWithOptions

或在swift中编写我自己的稳定排序，例如？我在表中看到，

排序

不稳定

:

---

除了使用Objective-C或编写我自己的排序之外，我是否缺少Swift中可用的另一个选项？

除了Swift包装方法之外，您还可以使用C

mergesort:

函数

var array2 = ["mango", "apple", "pear", "apple", "orange", "banana"]
mergesort(&array2, array2.count, MemoryLayout<String>.size, {
    let a = $0.unsafelyUnwrapped.load(as:String.self)
    let b = $1.unsafelyUnwrapped.load(as:String.self)
    if a == b {
        return 0
    }
    else if a < b {
        return -1 }
    else {
        return 1
    }
})
print(array2) // ["apple", "apple", "banana", "mango", "orange", "pear"]

var array2=[“芒果”、“苹果”、“梨”、“苹果”、“橘子”、“香蕉”]
合并排序（&array2，array2.count，MEMORYLAOUT.size{
设a=$0.unsafelyUnwrapped.load（as:String.self）
设b=$1.unsafelyUnwrapped.load（as:String.self）
如果a==b{
返回0
}
否则，如果a

或者写一个纯粹的快速方法，让事情变得更一般：

var array = ["mango", "apple", "pear", "banana", "orange", "apple", "banana"]

enum SortType {
    case Ascending
    case Descending
}

struct SortObject<T> {
    let value:T
    let startPosition:Int
    var sortedPosition:Int?
}

func swiftStableSort<T:Comparable>(array:inout [T], sortType:SortType = .Ascending) {

    var sortObjectArray = array.enumerated().map{SortObject<T>(value:$0.element, startPosition:$0.offset, sortedPosition:nil)}

    for s in sortObjectArray {
        var offset = 0
        for x in array[0..<s.startPosition]  {
            if s.value < x {
                offset += sortType == .Ascending ? -1 : 0
            }
            else if s.value > x {
                offset += sortType == .Ascending ? 0 : -1
            }
        }

        for x in array[s.startPosition+1..<array.endIndex]  {
            if s.value > x  {
                offset += sortType == .Ascending ? 1 : 0
            }
            else if s.value < x  {
                offset += sortType == .Ascending ? 0 : 1
            }
        }
        sortObjectArray[s.startPosition].sortedPosition = offset + s.startPosition
    }

    for s in sortObjectArray {
        if let sInd = s.sortedPosition {
            array[sInd] = s.value
        }
    }

}

swiftStableSort(array: &array, sortType:.Ascending) // ["apple", "apple", "banana", "banana", "mango", "orange", "pear"]
swiftStableSort(array: &array, sortType:.Descending) // ["pear", "orange", "mango", "banana", "banana", "apple", "apple"]

var数组=[“芒果”、“苹果”、“梨”、“香蕉”、“橙子”、“苹果”、“香蕉”]
枚举排序类型{
升格
病例下降
}
结构SortObject{
let值：T
让开始位置：Int
var分拣位置：Int？
}
func swiftStableSort（数组：inout[T]，sortType:sortType=.升序）{
var sortObjectArray=array.enumerated（）.map{SortObject（值：$0.element，起始位置：$0.offset，sortedPosition:nil）}
对于sortObjectArray中的s{
var偏移量=0
对于数组[0..x]中的x{
偏移量+=排序类型==。升序？0:-1
}
}
对于阵列[s.startPosition+1..x]中的x{
偏移量+=排序类型==。升序？1:0
}
如果s.值小于x，则为else{
偏移量+=排序类型==。升序？0:1
}
}
sortObjectArray[s.startPosition]。sortedPosition=offset+s.startPosition
}
对于sortObjectArray中的s{
如果让sInd=s.sortedPosition{
数组[sInd]=s.value
}
}
}
swiftStableSort（数组：&数组，排序类型：。升序）/[“苹果”、“苹果”、“香蕉”、“香蕉”、“芒果”、“橙子”、“梨”]
swiftStableSort（数组：&数组，排序类型：。降序）/[“梨”、“橙”、“芒果”、“香蕉”、“香蕉”、“苹果”、“苹果”]

---

（这是我谦逊而直截了当的方法，毫无疑问其他人可以优化。）

是的。你也可以写一个快速的包装器来调用objective-c函数——如果真的还没有的话。当然！我有个大脑屁。回答这个问题，我会打绿色的复选标记，@Michael:）这回答了你的问题吗？

var array = ["mango", "apple", "pear", "banana", "orange", "apple", "banana"]

enum SortType {
    case Ascending
    case Descending
}

struct SortObject<T> {
    let value:T
    let startPosition:Int
    var sortedPosition:Int?
}

func swiftStableSort<T:Comparable>(array:inout [T], sortType:SortType = .Ascending) {

    var sortObjectArray = array.enumerated().map{SortObject<T>(value:$0.element, startPosition:$0.offset, sortedPosition:nil)}

    for s in sortObjectArray {
        var offset = 0
        for x in array[0..<s.startPosition]  {
            if s.value < x {
                offset += sortType == .Ascending ? -1 : 0
            }
            else if s.value > x {
                offset += sortType == .Ascending ? 0 : -1
            }
        }

        for x in array[s.startPosition+1..<array.endIndex]  {
            if s.value > x  {
                offset += sortType == .Ascending ? 1 : 0
            }
            else if s.value < x  {
                offset += sortType == .Ascending ? 0 : 1
            }
        }
        sortObjectArray[s.startPosition].sortedPosition = offset + s.startPosition
    }

    for s in sortObjectArray {
        if let sInd = s.sortedPosition {
            array[sInd] = s.value
        }
    }

}

swiftStableSort(array: &array, sortType:.Ascending) // ["apple", "apple", "banana", "banana", "mango", "orange", "pear"]
swiftStableSort(array: &array, sortType:.Descending) // ["pear", "orange", "mango", "banana", "banana", "apple", "apple"]