func linearSearch<T: Equatable>(_ array: [T], _ target: T) -> Int? {
    for (index, element) in array.enumerated() {
        if element == target {
            return index
        }
    }
    return nil
}

func binarySearch<T: Comparable>(_ array: [T], _ target: T) -> Int? {
    var low = 0
    var high = array.count - 1

    while low <= high {
        let mid = (low + high) / 2
        if array[mid] == target {
            return mid
        } else if array[mid] < target {
            low = mid + 1
        } else {
            high = mid - 1
        }
    }
    return nil
}

let dictionary = ["Alice": 25, "Bob": 30]
let age = dictionary["Alice"]  // O(1) поиск

func bubbleSort<T: Comparable>(_ array: [T]) -> [T] {
    var result = array
    for i in 0..<result.count {
        for j in 1..<result.count - i {
            if result[j] < result[j-1] {
                result.swapAt(j, j-1)
            }
        }
    }
    return result
}

func quickSort<T: Comparable>(_ array: [T]) -> [T] {
    guard array.count > 1 else { return array }
    let pivot = array[array.count/2]
    let less = array.filter { $0 < pivot }
    let equal = array.filter { $0 == pivot }
    let greater = array.filter { $0 > pivot }
    return quickSort(less) + equal + quickSort(greater)
}

func mergeSort<T: Comparable>(_ array: [T]) -> [T] {
    guard array.count > 1 else { return array }
    let middle = array.count / 2
    let left = mergeSort(Array(array[0..<middle]))
    let right = mergeSort(Array(array[middle..<array.count]))
    return merge(left, right)
}

private func merge<T: Comparable>(_ left: [T], _ right: [T]) -> [T] {
    var result: [T] = []
    var leftIndex = 0
    var rightIndex = 0

    while leftIndex < left.count && rightIndex < right.count {
        if left[leftIndex] < right[rightIndex] {
            result.append(left[leftIndex])
            leftIndex += 1
        } else {
            result.append(right[rightIndex])
            rightIndex += 1
        }
    }

    result += left[leftIndex..<left.count]
    result += right[rightIndex..<right.count]
    return result
}

let sortedArray = array.sorted()  // Гибридный алгоритм (Introsort)
let index = array.firstIndex(of: element)  // Оптимизированный поиск

let request: NSFetchRequest<User> = User.fetchRequest()
request.sortDescriptors = [NSSortDescriptor(key: "name", ascending: true)]

// Поиск подстроки (алгоритм Бойера-Мура)
if string.contains("search term") { ... }

// Сортировка перед отображением в UITableView
displayData = sourceData.sorted { $0.date > $1.date }