逆句算法的复杂度

Question

我正在研究 Python 中的数据结构问题，我必须以最有效的方式反转数组中单词的顺序。我想出了以下问题的解决方案

def reverse(arr, st, end):
    while st < end:
        arr[st], arr[end] = arr[end], arr[st]
        end -= 1
        st += 1

def reverse_arr(arr):
    arr = arr[::-1]
    st_index = 0
    length = len(arr)

    for i, val in enumerate(arr):
        if val == ' ':
            end_index = i-1
            reverse(arr, st_index, end_index)
            st_index = end_index + 2

        if i == length - 1:
            reverse(arr, st_index, length-1)

    return arr

如果 arr 是：

arr = [ 'p', 'e', 'r', 'f', 'e', 'c', 't', ' ',
        'm', 'a', 'k', 'e', 's', ' ',
        'p', 'r', 'a', 'c', 't', 'i', 'c', 'e' ]

返回：

['p', 'r', 'a', 'c', 't', 'i', 'c', 'e', ' ', 
 'm', 'a', 'k', 'e', 's', ' ', 
 'p', 'e', 'r', 'f', 'e', 'c', 't']

该解决方案运行良好，但我不明白该算法的复杂度是 O(n)。它写到遍历数组两次，每个项目的动作数量恒定是线性的，即 O(n)，其中 n 是数组的长度。

我认为它应该超过 O(n)，因为根据我的说法，每个单词的长度不是固定的，反转每个单词的时间复杂度取决于单词的长度。有人可以更好地解释这一点吗？

Answer 1

reverse 每个单词都会被调用一次。在该调用期间，它会为每个角色做大量的工作。

您可以用字数和平均字长（即O(wordCount*averageWordLength)）或数组中的字符总数来表示它。如果你做后者，很容易看出你仍然在为每个字符做恒定的工作量（因为reverse 和reverse_arr 都在为每个字符做恒定的工作量，没有两个reverse 调用会包含相同的字符），导致O(characterCount) 复杂性。

我不会假设解释中的“数组的长度”是指单词的数量，而是字符的数量，或者他们假设单词长度具有固定的上限（其中复杂度确实是O(wordCount))。

TL;DR: n in O(n) 是 characterCount，而不是 wordCount。

Answer 2

def reverse(arr, st, end):
    while st < end:
        arr[st], arr[end] = arr[end], arr[st]
        end -= 1
        st += 1

def reverse_Cha(arr):
    arr = arr[::-1]
    st_index = 0
    length = len(arr)

    for i, val in enumerate(arr):
        if val == ' ':
            end_index = i-1
            reverse(arr, st_index, end_index)
            st_index = end_index + 2

        if i == length - 1:
            reverse(arr, st_index, length-1)

    return arr

def reverse_Jon(arr):
    r = [ch for word in ' '.join(''.join(arr).split()[::-1]) for ch in word]
    return r

def reverse_Nua(arr):
    rev_arr = list(' '.join(''.join(arr).split()[::-1]))
    return rev_arr

如果我们考虑 3 个建议的解决方案：您的为 reverse_Cha，Jon Clements 的为 reverse_Jon，我的为 reverse_Nua。 我们注意到，当我们使用[::-1] 时，我们有O(n)，当我们检查列表的每个元素时（长度n）等等。

reverse_Cha 使用[::-1]，然后检查每个元素两次（读取然后交换），因此复杂性取决于元素的总数（O(3n+c) 我们写为O(n)（+c 来来自O(1)操作））

reverse_Jon 使用[::-1]，然后检查每个元素两次（检查每个单词的每个字符），因此复杂性取决于元素总数和单词数（O(3n+m)，我们写为O(n+m) （用m字数）

reverse_Nua使用[::-1]，然后坚持python列表函数，复杂度因此仍然取决于元素的总数（这次直接O(n)）

就性能而言（1e6 循环），我们得到了reverse_Cha: 2.785867s； reverse_Jon：4.11845s（由于for）； reverse_Nua: 1.185973s。

Answer 3

我认为这是一个纯粹的理论问题，因为在现实世界的应用程序中，您可能宁愿将列表拆分为一个单词的子列表，然后以相反的顺序重新加入子列表 - 这需要更多内存，但速度要快得多。

话虽如此，我想指出您展示的算法确实是 O(n) - 它取决于您的单词的 total 长度，而不是个别的话。换句话说：20 个 3 个字母的单词、6 个 10 个字母的单词、10 个 6 个字母的单词都需要相同的时间……你总是只遍历每个字母两次：在单个单词的反转期间一次（这是第一次调用reverse 在reverse_arr 中）和整个数组的反转期间一次（第二次调用reverse）。