Arrays 在Swift中查找数组中最大值的正确方法

到目前为止，我有一个简单（但可能昂贵）的方法：

以及我在学校里是如何学习的：

var myMax = 0
for i in 0..myArray.count {
    if (myArray[i] > myMax){myMax = myArray[i]}
}

有没有更好的方法从Swift中的整数数组中获取最大值？理想情况下，Ruby的

.max
更新：应该是可以接受的答案，因为
maxElement
出现在Swift中


使用万能的
reduce
：

let nums = [1, 6, 3, 9, 4, 6];
let numMax = nums.reduce(Int.min, { max($0, $1) })

let randomNumbers = [4, 7, 1, 9, 6, 5, 6, 9]
let maxNumber = randomNumbers.reduce(randomNumbers[0]) { $0 > $1 ? $0 : $1 } //result is 9

同样地：

let numMin = nums.reduce(Int.max, { min($0, $1) })

reduce
获取第一个值，即内部累加器变量的初始值，然后将传递的函数（此处为匿名函数）依次应用于累加器和数组的每个元素，并将新值存储在累加器中。然后返回最后一个累加器值。
其他答案都是正确的，但不要忘记也可以使用收集运算符，如下所示：

var numbers = [1, 2, 7, 5];    
var val = sort(numbers){$0 > $1}[0];

var list = [1, 2, 3, 4]
var max: Int = (list as AnyObject).valueForKeyPath("@max.self") as Int

您也可以用同样的方法找到平均值：

var avg: Double = (list as AnyObject).valueForKeyPath("@avg.self") as Double

此语法可能不如其他一些解决方案清晰，但有趣的是，仍然可以使用
-valueForKeyPath:
）
给定：

let numbers = [1, 2, 3, 4, 5]

Swift 3：

numbers.min() // equals 1
numbers.max() // equals 5

Swift 2：

numbers.minElement() // equals 1
numbers.maxElement() // equals 5

使用Swift 1.2（或更早版本），您现在需要使用：

let nums = [1, 6, 3, 9, 4, 6];
let numMax = nums.reduce(Int.min, combine: { max($0, $1) })

在使用双值时，我使用了如下内容：

let nums = [1.3, 6.2, 3.6, 9.7, 4.9, 6.3];
let numMax = nums.reduce(-Double.infinity, combine: { max($0, $1) })

您还可以对数组进行排序，然后使用
数组。首先
或
数组。最后
在Swift 2.0中，
minElement
和
maxElement
成为
SequenceType
协议的方法，您应该像这样调用它们：

let a = [1, 2, 3]
print(a.maxElement()) //3
print(a.minElement()) //1

将
maxElement
用作类似
maxElement（a）的函数现在是不可用的

Swift的语法在不断变化，因此我可以在Xcode version7beta6中确认这一点

它将来可能会被修改，因此我建议您最好在使用这些方法之前检查文档。
对于Swift 5，
数组
，与其他符合协议的对象一样（
字典
，
集
，等等），有两种方法称为
max（）
和
max（by:）
返回序列中的最大元素，如果序列为空，则返回
nil


#1.使用
Array
的
max（）
方法
如果序列中的元素类型符合
Comparable
协议（可能是
String
、
Float
、
Character
或自定义类或结构之一），则可以使用具有以下特性的
max（）
：

返回序列中的最大元素

以下游乐场代码显示如何使用
max（）
：

返回序列中的最大元素，使用给定谓词作为元素之间的比较

以下游乐场代码显示如何使用
max（by:）
：

let dictionary=[“船”：15，“车”：20，“自行车”：40]
让keyMaxElement=dictionary.max（by:{（a，b）->Bool-in
返回a.keyBool-in
返回a.value

类路由：CustomStringConvertible{
让距离：Int
变量说明：字符串{return“路径与距离：\（距离）”}
初始（距离：Int）{
self.distance=距离
}
}
让路线=[
路线（距离：20），
路线（距离：30），
路线（距离：10）
]
设maxRoute=routes.max（by:{（a，b）->Bool-in
返回a.距离
您可以与
reduce
一起使用：

let nums = [1, 6, 3, 9, 4, 6];
let numMax = nums.reduce(Int.min, { max($0, $1) })

let randomNumbers = [4, 7, 1, 9, 6, 5, 6, 9]
let maxNumber = randomNumbers.reduce(randomNumbers[0]) { $0 > $1 ? $0 : $1 } //result is 9

Swift 3.0

您可以通过编程方式尝试此代码

func getSmallAndGreatestNumber() -> Void {

    let numbers = [145, 206, 116, 809, 540, 176]
    var i = 0
    var largest = numbers[0]
    var small = numbers[0]
    while i < numbers.count{

        if (numbers[i] > largest) {
            largest = numbers[i]
        }
        if (numbers[i] < small) {
            small = numbers[i]
        }
        i = i + 1
    }
    print("Maximum Number ====================\(largest)")// 809
    print("Minimum Number ====================\(small)")// 116
}

func getSmallAndGreatestNumber（）->Void{
让数字=[145、206、116、809、540、176]
变量i=0
var最大值=数字[0]
var小=数字[0]
当我数的时候{
如果（数字[i]>最大值）{
最大=数字[i]
}
如果（数字[i]<小）{
小=数字[i]
}
i=i+1
}
打印（“最大数量=========\（最大）”）/809
打印（“最小数量==========================\（小）”）//116
}

为Swift 3/4更新：

使用下面简单的代码行从数组中查找最大值

var num = [11, 2, 7, 5, 21]
var result = num.sorted(){
    $0 > $1
}
print("max from result: \(result[0])") // 21

下面是对此处发布的解决方案的性能测试

这是Swift 5最快的

array.max（）？您正在运行一个时间复杂度为O（N）的for循环。这实际上比大多数排序算法都好，相当于像
reduce
这样的高阶方法的性能

所以我认为在性能方面，for循环是最好的。我不认为你能找到比O（N）更好的办法来找到max

当然，只需使用apple提供的
.max（）
方法即可。
您可以编写一个扩展。是的，只有一行：
maxElement（myArray）
。看看下面第二个答案（鲁道夫·阿达姆科维奇的答案）是什么。你把这个被接受的答案改成@mattymcgee。我已经更新了这个被接受的答案。太好了，正是我想要的。似乎有很多东西不在iBook中！这些只是一般的函数式编程技术，它们不是特定于Swift的。@Jean Philippel实际上可以将其简化为：
nums.reduce（Int.min，max）
既然
max
的原型已经匹配了
reduce
所期望的类型，这有什么原因不能与double数组一起工作吗？min/max函数签名与combine:parameter签名匹配，所以您只需传递函数本身：
让numMax=nums。
let dictionary = ["Boat" : 15, "Car" : 20, "Bike" : 40]

let keyMaxElement = dictionary.max(by: { (a, b) -> Bool in
    return a.key < b.key
})

let valueMaxElement = dictionary.max(by: { (a, b) -> Bool in
    return a.value < b.value
})

print(String(describing: keyMaxElement)) // prints: Optional(("Car", 20))
print(String(describing: valueMaxElement)) // prints: Optional(("Bike", 40))

class Route: CustomStringConvertible {

    let distance: Int
    var description: String { return "Route with distance: \(distance)" }

    init(distance: Int) {
        self.distance = distance
    }

}

let routes = [
    Route(distance: 20),
    Route(distance: 30),
    Route(distance: 10)
]

let maxRoute = routes.max(by: { (a, b) -> Bool in
    return a.distance < b.distance
})

print(String(describing: maxRoute)) // prints: Optional(Route with distance: 30)

let randomNumbers = [4, 7, 1, 9, 6, 5, 6, 9]
let maxNumber = randomNumbers.reduce(randomNumbers[0]) { $0 > $1 ? $0 : $1 } //result is 9

func getSmallAndGreatestNumber() -> Void {

    let numbers = [145, 206, 116, 809, 540, 176]
    var i = 0
    var largest = numbers[0]
    var small = numbers[0]
    while i < numbers.count{

        if (numbers[i] > largest) {
            largest = numbers[i]
        }
        if (numbers[i] < small) {
            small = numbers[i]
        }
        i = i + 1
    }
    print("Maximum Number ====================\(largest)")// 809
    print("Minimum Number ====================\(small)")// 116
}

var num = [11, 2, 7, 5, 21]
var result = num.sorted(){
    $0 > $1
}
print("max from result: \(result[0])") // 21