按Swift中的值排序字典

Question

是否有模拟 - (NSArray*)keysSortedByValueUsingSelector:(SEL)比较器在swift中？

如何在不转换为NSDictionary的情况下执行此操作？

我试过这个,但似乎不是一个好的解决方案.

var values = Array(dict.values)
values.sort({
    $0 > $1
    })

for number in values {
    for (key, value) in dict {
        if value == number {
            println(key + " : \(value)");
            dict.removeValueForKey(key);
            break
        }
    }
}

例:

var dict = ["cola" : 10, "fanta" : 12, "sprite" : 8]
dict.sortedKeysByValues(>) // fanta (12), cola(10), sprite(8)

Answer 1

只需一行代码就可以按Swift 4中的值对字典进行排序:

    let sortedByValueDictionary = myDictionary.sorted { $0.1 < $1.1 }

Answer 2

尝试:

let dict = ["a":1, "c":3, "b":2]

extension Dictionary {
    func sortedKeys(isOrderedBefore:(Key,Key) -> Bool) -> [Key] {
        return Array(self.keys).sort(isOrderedBefore)
    }

    // Slower because of a lot of lookups, but probably takes less memory (this is equivalent to Pascals answer in an generic extension)
    func sortedKeysByValue(isOrderedBefore:(Value, Value) -> Bool) -> [Key] {
        return sortedKeys {
            isOrderedBefore(self[$0]!, self[$1]!)
        }
    }

    // Faster because of no lookups, may take more memory because of duplicating contents
    func keysSortedByValue(isOrderedBefore:(Value, Value) -> Bool) -> [Key] {
        return Array(self)
            .sort() {
                let (_, lv) = $0
                let (_, rv) = $1
                return isOrderedBefore(lv, rv)
            }
            .map {
                let (k, _) = $0
                return k
            }
    }
}

dict.keysSortedByValue(<)
dict.keysSortedByValue(>)

更新:

更新为新的数组语法并从beta 3中排序语义.请注意,我正在使用sort而不是sorted最小化数组复制.该代码可以做得更紧凑,通过查看早期版本,并取代sort与sorted和固定的KeyType[]是[KeyType]

更新到Swift 2.2:

更改类型从KeyType到Key和ValueType到Value.使用new sortbuiltin Array代替sort(Array) Note所有这些的性能可以通过使用sortInPlace而不是使用来略微改进sort

Answer 3

你可以使用这样的东西:

var dict = ["cola" : 10, "fanta" : 12, "sprite" : 8]

var myArr = Array(dict.keys)
var sortedKeys = sort(myArr) {
    var obj1 = dict[$0] // get ob associated w/ key 1
    var obj2 = dict[$1] // get ob associated w/ key 2
    return obj1 > obj2
}

myArr // ["fanta", "cola", "sprite"]

Answer 4

这应该给你基于值的排序键,并且更清洁一点:

var sortedKeys = Array(dict.keys).sorted({dict[$0] < dict[$1]})

Answer 5

我认为这是按值排序Swift字典的最简单方法.

let dict = ["apple":1, "cake":3, "banana":2]

let byValue = {
    (elem1:(key: String, val: Int), elem2:(key: String, val: Int))->Bool in
    if elem1.val < elem2.val {
        return true
    } else {
        return false
    }
}
let sortedDict = dict.sort(byValue)

Answer 6

按字典的值对键进行排序实际上比最初看起来更简单:

let yourDict = ["One": "X", "Two": "B", "Three": "Z", "Four": "A"]
let sortedKeys = yourDict.keys.sort({ (firstKey, secondKey) -> Bool in
    return yourDict[firstKey] < yourDict[secondKey]
})

就是这样!真的没什么了不起的.我还没有找到一种更快捷的方法.

Answer 7

很多答案,这是一个单行.我喜欢它,因为它充分利用了原生的Swift迭代函数,并且不使用变量.这应该有助于优化者发挥其魔力.

return dictionary.keys.sort({ $0 < $1 }).flatMap({ dictionary[$0] })

请注意flatMap的使用,因为下载字典会返回一个可选值.在实践中,这应该永远不会返回nil,因为我们从字典本身获取密钥.flatMap只是为了确保结果不是一个选项数组.如果您的数组的关联值应该是可选的,则可以使用map.

Answer 8

OneLiner：

let dict = ["b":2,"a":1,"c":3]
(Array(dict).sorted{$0.1 < $1.1}).forEach{(k,v) in print("\(k):\(v)")}
//Output: a:1, b:2, c:3

.forEach用.map->功能编程交换

语法糖：

extension Dictionary where Value:Comparable {
    var sortedByValue:[(Key,Value)] {return Array(self).sorted{$0.1 < $1.1}}
}
extension Dictionary where Key:Comparable {
    var sortedByKey:[(Key,Value)] {return Array(self).sorted{$0.0 < $1.0}}
}
["b":2,"a":1,"c":3].sortedByKey//a:1, b:2, c:3
["b":2,"a":1,"c":3].sortedByValue//a:1, b:2, c:3

Answer 9

如果您希望输出是按值排序的元组形式的键值对数组，以下内容可能很有用。

var dict = ["cola" : 10, "fanta" : 12, "sprite" : 8]
let sortedArrByValue = dict.sorted{$0.1 > $1.1}
print(sortedArrByValue) // output [(key: "fanta", value: 12), (key: "cola", value: 10), (key: "sprite", value: 8)]

Answer 10

由于 Swift 3.0Dictionary具有sorted(by:)返回元组 ( [(Key, Value)])数组的函数。

let sorted = values.sorted(by: { (keyVal1, keyVal2) -> Bool in
    keyVal1.value > keyVal2.value
})

Answer 11

按键或值对字典进行排序

使用Swift 5.2内部处理“排序”：

var unsortedDict = ["cola" : 10, "fanta" : 12, "sprite" : 8]

// sorting by value
let sortedDictByValue = unsortedDict.sorted{ $0.value > $1.value } // from lowest to highest using ">"
print("sorted dict: \(sortedDictByValue)")
// result: "sorted dict: [(key: "fanta", value: 12), (key: "cola", value: 10), (key: "sprite", value: 8)]\n"

// highest value
print(sortedDictByValue.first!.key)  // result: fanta
print(sortedDictByValue.first!.value)  // result: 12
// lowest value
print(sortedDictByValue.last!.key)  // result: sprite
print(sortedDictByValue.last!.value)  // result: 8
// by index
print(sortedDictByValue[1].key)  // result: cola
print(sortedDictByValue[1].value)  // result: 10

// sorting by key
let sortedDictByKey = unsortedDict.sorted{ $0.key < $1.key } // in alphabetical order use "<"
// alternative:
// let sortedDictByKey = unsortedDict.sorted{ $0 < $1 }  // without ".key"
print("sorted dict: \(sortedDictByKey)")
// result: "sorted dict: [(key: "cola", value: 10), (key: "fanta", value: 12), (key: "sprite", value: 8)]\n"

// highest value
print(sortedDictByKey.first!.key)  // result: cola
print(sortedDictByKey.first!.value)  // result: 10
// lowest value
print(sortedDictByKey.last!.key)  // result: sprite
print(sortedDictByKey.last!.value)  // result: 8
// by index
print(sortedDictByKey[1].key)  // result: fanta
print(sortedDictByKey[1].value)  // result: 12