[Swift]LeetCode977. 有序数组的平方 | Squares of a Sorted Array

原文地址：https://www.cnblogs.com/strengthen/p/10294613.html 

Given an array of integers A sorted in non-decreasing order, return an array of the squares of each number, also in sorted non-decreasing order. 

Example 1:

Input: [-4,-1,0,3,10]
Output: [0,1,9,16,100]

Example 2:

Input: [-7,-3,2,3,11]
Output: [4,9,9,49,121] 

Note:

1. 1 <= A.length <= 10000
2. -10000 <= A[i] <= 10000
3. A is sorted in non-decreasing order.

---

给定一个按非递减顺序排序的整数数组 A，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。 

示例 1：

输入：[-4,-1,0,3,10]
输出：[0,1,9,16,100]

示例 2：

输入：[-7,-3,2,3,11]
输出：[4,9,9,49,121] 

提示：

1. 1 <= A.length <= 10000
2. -10000 <= A[i] <= 10000
3. A 已按非递减顺序排序。

---

300ms

class Solution {
    func sortedSquares(_ A: [Int]) -> [Int] {
    if A.count == 1 {
        return A.map{
            $0 * $0
        }
    }
    
    var result: [Int] = [Int]()
    var i: Int = 0
    var j: Int = A.count - 1
    
    while i != j {
        if module(A[i]) >= module(A[j]) {
            result.append(A[i] * A[i])
            i += 1
        } else {
            result.append(A[j] * A[j])
            j -= 1
        }
    }
    result.append(A[i] * A[i])
    
    return result.reversed()
}

func module(_ number: Int) -> Int {
    if number < 0 {
        return -number
    } else {
        return number
    }
 }
}

---

308ms

class Solution {
    func sortedSquares(_ A: [Int]) -> [Int] {
        var ans = [Int]()
        
        if let posI = A.firstIndex(where: { $0 >= 0 }) {
            var left = posI - 1
            var right = posI
            
            while left >= 0 || right < A.count {
                if left >= 0 && (right >= A.count || A[left] * A[left] < A[right] * A[right]) {
                    ans.append(A[left] * A[left])
                    left -= 1
                } else {
                    ans.append(A[right] * A[right])
                    right += 1
                }
            }
        } else {
            // if no value is larger than 0 -> all of them are negative
            for i in (0..<A.count).reversed() {
                ans.append(A[i] * A[i])
            }
        }
            
        return ans
    }
}

---

356ms

class Solution {
    func sortedSquares(_ A: [Int]) -> [Int] {
        var maxNumber = 0
        var map:[Int:Int] = [:]
        for i in 0 ..< A.count {
            maxNumber = max(maxNumber, abs(A[i]))
            let key = abs(A[i])
            if let v = map[key] {
                map[abs(A[i])] = v + 1
            }else {
                map[abs(A[i])] = 1
            }
        }
        var output:[Int] = []
        for i in 0 ... maxNumber {
            if let count = map[i] {
                let value = i*i
                if count == 1 {
                    output.append(value)
                } else {
                    output += Array(repeating: value, count: count)
                }
            }
        }
        return output
    }
}

---

376ms

class Solution {
    func sortedSquares(_ A: [Int]) -> [Int] {
        return A.map({$0 * $0}).sorted()
    }
}

---

380ms

class Solution {
    func sortedSquares(_ A: [Int]) -> [Int] {
        var nonSortedArray = [Int]()
        for value in A {
           nonSortedArray.append(value * value)
        }
        
        return nonSortedArray.sorted()
    }
}

---

400ms

class Solution {
    func sortedSquares(_ A: [Int]) -> [Int] {
         return A.reduce(into: [], { $0.append($1 * $1) }).sorted(by: <)
    }
}

---

404ms

class Solution {
    func sortedSquares(_ A: [Int]) -> [Int] {
        return A.lazy.map{$0 * $0}.sorted(by: {$0 < $1})
    }
}

---

416ms

class Solution {
    func sortedSquares(_ A: [Int]) -> [Int] {
        return A.map { Int(pow(Double($0), 2)) }.sorted()
    }
}

---

6284ms

class Solution {
    func sortedSquares(_ A: [Int]) -> [Int] {
        var A = A.map{ abs($0) }
        func fastSort(_ B: [Int]) -> [Int] {
            guard !B.isEmpty else { return [] }
            let midIndex = B.count/2
            return fastSort(Array(B.filter{ $0 < B[midIndex] })) + Array(B.filter{ $0 == B[midIndex] }) + fastSort(Array(B.filter{ $0 > B[midIndex] }))
        }
        return fastSort(A).map{ $0*$0 }
    }
}