要求如下:

1、已知一個數組，按照單個元素在陣列中出現的次數作為重新排序的依據，個數多的排在前面
2、相同個數時候，元素值大的排前面

例子:

[1, 2, 2, 3, 5, 5]
經過計算得到的結果是：
[5, 5, 2, 2, 3, 1]

一種解決方法是:

import UIKit

extension Sequence where Iterator.Element == Int{
    private func removeRepeats()->[Int]{
        let set = Set(self)
        return Array(set
 
).sorted {$0>$1}
    }

    private func countFor(value:Int)->Int{
        return filter {$0 == value}.count
    }

    func sortByRepeatCount()->[Iterator.Element]{
        var wets = [[Int]]()
        let clearedAry = removeRepeats()
        for i in clearedAry{
            wets.append([i,countFor(value
 
: i)])
        }

        wets = wets.sorted {
            $0[1] > $1[1]
        }

        var result = [Int]()
        for x in wets{
            let i = x[0]
            let count = x[1]
            for _ in 0..<count{
                result.append(i)
            }
        }

        return result
    }
}

var
 
 ary = [1,1,2,1,3,3,4,5,4,6,6,6]
print(ary.sortByRepeatCount())
//輸出 "[6, 6, 6, 1, 1, 1, 4, 4, 3, 3, 5, 2]\n"

別的網友提供了更直觀更簡單的方法:

extension SequenceType where Generator.Element : Hashable {
    func frequencies() -> [Generator.Element:Int] {
        var results : [Generator.Element:Int] = [:]
        for element in self {
            results[element] = (results[element] ?? 0) + 1
        }
        return results
    }
}

let alpha = [2,8,2,6,1,8,2,6,6]
let beta = [6,6,6,2,2,2,8,8,1]

let sorted = alpha.frequencies().sort {
    if $0.1 > $1.1 { // if the frequency is higher, return true
        return true
    } else if $0.1 == $1.1 { // if the frequency is equal
        return $0.0 > $1.0 // return value is higher
    } else {
        return false // else return false
    }
}

注意後一種解決辦法只能在Swift2.x中執行,如果要在Swift3中執行需要略做修改,請參考我寫的另一篇博文: