Question

我有一个具有属性的对象：Name，Relevance，Timestamp。

我希望数组中的对象按最相关（“Relevance”）和Most Recent（“Timestamp”）隔行扫描。

如：相关，近期，相关，近期等......

现在，我有一个基于时间复杂度为O（n log n）的单个键进行排序的解决方案。

这是我在Swift中的解决方案：

func mergeSort(array: [Entity]) -> [Entity] {
    guard array.count > 1 else { return array }    // 1

    let middleIndex = array.count / 2              // 2

    let leftArray = mergeSort(Array(array[0..<middleIndex]))             // 3

    let rightArray = mergeSort(Array(array[middleIndex..<array.count]))  // 4

    return merge(leftPile: leftArray, rightPile: rightArray)             // 5
}


    func merge(leftPile leftPile: [Entity], rightPile: [Entity]) -> [Entity] {
    // 1
    var leftIndex = 0
    var rightIndex = 0

    // 2
    var orderedPile = [Entity]()

    // 3
    while leftIndex < leftPile.count && rightIndex < rightPile.count {
            if leftPile[leftIndex].timestamp.isGreaterThanDate(rightPile[rightIndex].timestamp) {
                orderedPile.append(leftPile[leftIndex])
                leftIndex += 1
            } else if leftPile[leftIndex].timestamp.isLessThanDate(rightPile[rightIndex].timestamp) {
                orderedPile.append(rightPile[rightIndex])
                rightIndex += 1
            }
            else{
                orderedPile.append(leftPile[leftIndex])
                leftIndex += 1
                orderedPile.append(rightPile[rightIndex])
                rightIndex += 1
            }
    }

    // 4
    while leftIndex < leftPile.count {
        orderedPile.append(leftPile[leftIndex])
        leftIndex += 1
    }

    while rightIndex < rightPile.count {
        orderedPile.append(rightPile[rightIndex])
        rightIndex += 1
    }

    return orderedPile
}

代码将数组排序为“Most Recent”，我也可以将密钥从“timestamp”更改为“related”，将其排序为“Most Related”。

但是，我想要如上所述的隔行扫描排序具有最短的复杂性。有没有人有这个好的解决方案？

Answer 1

按相关性排序。

按近期排序复制。

以备用顺序合并副本，保留合并中的副本的字典，而不是再次添加它们。

两种排序为O(n log(n))，O(n)的合并为O(n log(n))。

Swift：使用备用键合并排序算法

1 个答案: