What difficulties can arise when sorting data in an array?

1. Stability of sorting: Some sorting algorithms may change the order of elements with equal value. If the order is important, a stable algorithm should be used.
2. Performance: The execution time of sorting depends on the size of the array and the chosen algorithm. For large arrays, an efficient algorithm (e.g., O(n log n)) is required.
3. Memory consumption: Some algorithms require additional memory for temporary data storage (e.g., merge sort), which can be problematic when working with large arrays on devices with limited memory.
4. Comparison of elements: If the elements in the array are not standard data types (numbers, strings), a custom comparison method must be provided.
5. Mutability: If the array is immutable, sorting will return a new array, which may increase memory usage. For mutable arrays, sorting is performed in place.
6. Parallelism/Multithreading: Sorting in a multithreaded environment requires caution to avoid race conditions and ensure the correctness of the result.

Example of implementing a custom comparison method for sorting of custom objects:

struct Person {
    let name: String
    let age: Int
}

let people = [Person(name: "Alice", age: 30), Person(name: "Bob", age: 25), Person(name: "Charlie", age: 30)]

// Sorting by age, then by name
let sortedPeople = people.sorted { (p1, p2) -> Bool in
    if p1.age != p2.age {
        return p1.age < p2.age
    } else {
        return p1.name < p2.name
    }
}