Ordenar diccionario por claves

Quiero ordenar un diccionario en Swift. Tengo un diccionario como:

"A" => Array[]
"Z" => Array[]
"D" => Array[]

etc. Quiero que sea como

"A" => Array[]
"D" => Array[]
"Z" => Array[]

etc.

He intentado muchas soluciones en SO pero nadie trabajó para mí. Estoy usando XCode6 Beta 5 y en él algunos están dando error de compilación y algunas soluciones están dando excepciones. Entonces, cualquiera que pueda publicar la copia de trabajo de la clasificación del diccionario.

let dictionary = [
    "A" : [1, 2],
    "Z" : [3, 4],
    "D" : [5, 6]
]

let sortedKeys = Array(dictionary.keys).sorted(<) // ["A", "D", "Z"]

EDITAR:

La matriz ordenada del código anterior contiene solo claves, mientras que los valores deben recuperarse del diccionario original. Sin embargo, 'Dictionary'también es un 'CollectionType'par de (clave, valor) y podemos usar la 'sorted'función global para obtener una matriz ordenada que contenga tanto claves como valores, de esta manera:

let sortedKeysAndValues = sorted(dictionary) { $0.0 < $1.0 }
println(sortedKeysAndValues) // [(A, [1, 2]), (D, [5, 6]), (Z, [3, 4])]

EDIT2: la sintaxis Swift cambiante mensual prefiere actualmente

let sortedKeys = Array(dictionary.keys).sort(<) // ["A", "D", "Z"]

Lo global sortedestá en desuso.

Swift 2.0

Versión actualizada de la respuesta de Ivica M:

let wordDict = [
     "A" : [1, 2],
     "Z" : [3, 4],
     "D" : [5, 6]
]

let sortedDict = wordDict.sort { $0.0 < $1.0 }
print("\(sortedDict)") // 

Swift 3

wordDict.sorted(by: { $0.0 < $1.0 })

Aviso:

No se sorprenda de que el tipo resultante sea una matriz en lugar de un diccionario. ¡Los diccionarios no se pueden ordenar ! El tipo de datos resultante es una matriz ordenada, al igual que en la respuesta de @ Ivica.

Si desea iterar sobre las claves y los valores en un orden ordenado por clave, este formulario es bastante sucinto

let d = [
    "A" : [1, 2],
    "Z" : [3, 4],
    "D" : [5, 6]
]

for (k,v) in Array(d).sorted({$0.0 < $1.0}) {
    println("\(k):\(v)")
}

En swift 4 puedes escribirlo de manera más inteligente:

let d = [ 1 : "hello", 2 : "bye", -1 : "foo" ]
d = [Int : String](uniqueKeysWithValues: d.sorted{ $0.key < $1.key })

Intenté todo lo anterior, en pocas palabras todo lo que necesitas es

let sorted = dictionary.sorted { $0.key < $1.key }
let keysArraySorted = Array(sorted.map({ $0.key }))
let valuesArraySorted = Array(sorted.map({ $0.value }))

Para Swift 4, lo siguiente me ha funcionado:

let dicNumArray = ["q":[1,2,3,4,5],"a":[2,3,4,5,5],"s":[123,123,132,43,4],"t":[00,88,66,542,321]]

let sortedDic = dicNumArray.sorted { (aDic, bDic) -> Bool in
    return aDic.key < bDic.key
}

Esta es una alternativa elegante para ordenar el diccionario en sí:

A partir de Swift 4 y 5

let sortedKeys = myDict.keys.sorted()

for key in sortedKeys {
   // Ordered iteration over the dictionary
   let val = myDict[key]
}

En Swift 5 , para ordenar el Diccionario por CLAVES

let sortedYourArray = YOURDICTIONARY.sorted( by: { $0.0 < $1.0 })

Para ordenar el Diccionario por VALORES

let sortedYourArray = YOURDICTIONARY.sorted( by: { $0.1 < $1.1 })

Para Swift 3, el siguiente tipo retorna el diccionario ordenado por claves:

let unsortedDictionary = ["4": "four", "2": "two", "1": "one", "3": "three"]

let sortedDictionary = unsortedDictionary.sorted(by: { $0.0.key < $0.1.key })

print(sortedDictionary)
// ["1": "one", "2": "two", "3": "three", "4": "four"]

"ordenado" en iOS 9 y xcode 7.3, swift 2.2 es imposible, cambie "ordenado" a "ordenar", así:

let dictionary = ["main course": 10.99, "dessert": 2.99, "salad": 5.99]
let sortedKeysAndValues = Array(dictionary).sort({ $0.0 < $1.0 })
print(sortedKeysAndValues)

//sortedKeysAndValues = ["desert": 2.99, "main course": 10.99, "salad": 5.99]

Swift 5

Ingrese el diccionario que desea ordenar alfabéticamente por teclas.

// Sort inputted dictionary with keys alphabetically.
func sortWithKeys(_ dict: [String: Any]) -> [String: Any] {
    let sorted = dict.sorted(by: { $0.key < $1.key })
    var newDict: [String: Any] = [:]
    for sortedDict in sorted {
        newDict[sortedDict.key] = sortedDict.value
    }
    return newDict
}

dict.sorted (por: {$ 0.key <$ 1.key}) por sí mismo devuelve una tupla (valor, valor) en lugar de un diccionario [valor: valor]. Por lo tanto, el bucle for analiza la tupla para que regrese como un diccionario. De esa manera, pones un diccionario y recuperas un diccionario.

Swift 4 y 5

Para la clasificación de claves de cadena:

dictionary.keys.sorted(by: {$0.localizedStandardCompare($1) == .orderedAscending})

Ejemplo:

var dict : [String : Any] = ["10" : Any, "2" : Any, "20" : Any, "1" : Any]

dictionary.keys.sorted() 

["1" : Any, "10" : Any, "2" : Any, "20" : Any]

dictionary.keys.sorted(by: {$0.localizedStandardCompare($1) == .orderedAscending})

["1" : Any, "2" : Any, "10" : Any, "20" : Any]

Para Swift 3, lo siguiente me funcionó y la sintaxis de Swift 2 no funcionó:

// menu is a dictionary in this example

var menu = ["main course": 10.99, "dessert": 2.99, "salad": 5.99]

let sortedDict = menu.sorted(by: <)

// without "by:" it does not work in Swift 3

Swift 3 está ordenado (por: <)

let dictionary = [
    "A" : [1, 2],
    "Z" : [3, 4],
    "D" : [5, 6]
]

let sortedKeys = Array(dictionary.keys).sorted(by:<) // ["A", "D", "Z"]