La complessità temporale della stringa iterativa è in realtà O (n ^ 2) o O (n)?

Sto lavorando a un problema fuori dal CTCI.

Il terzo problema del capitolo 1 ti fa prendere una stringa come

'Mr John Smith '

e ti chiede di sostituire gli spazi intermedi con %20:

'Mr%20John%20Smith'

L'autore offre questa soluzione in Python, chiamandola O (n):

def urlify(string, length):
    '''function replaces single spaces with %20 and removes trailing spaces'''
    counter = 0
    output = ''
    for char in string:
        counter += 1
        if counter > length:
            return output
        elif char == ' ':
            output = output + '%20'
        elif char != ' ':
            output = output + char
    return output

La mia domanda:

Capisco che questo è O (n) in termini di scansione attraverso la stringa effettiva da sinistra a destra. Ma le stringhe in Python non sono immutabili? Se ho una stringa e aggiungo un'altra stringa con l' +operatore, non alloca lo spazio necessario, copia sull'originale e quindi copia sulla stringa aggiunta?

Se ho una raccolta di nstringhe ciascuna di lunghezza 1, allora ciò richiede:

1 + 2 + 3 + 4 + 5 + ... + n = n(n+1)/2

o O (n ^ 2) volta , sì? O mi sbaglio nel modo in cui Python gestisce l'aggiunta?

In alternativa, se tu fossi disposto a insegnarmi a pescare: come potrei scoprirlo da solo? Non ho avuto successo nei miei tentativi di Google una fonte ufficiale. Ho trovato https://wiki.python.org/moin/TimeComplexity ma questo non ha nulla sulle stringhe.

In CPython, l'implementazione standard di Python, c'è un dettaglio di implementazione che lo rende solitamente O (n), implementato nel codice che il ciclo di valutazione del bytecode richiede +o +=con due operandi stringa . Se Python rileva che l'argomento a sinistra non ha altri riferimenti, chiama reallocper tentare di evitare una copia ridimensionando la stringa in posizione. Questo non è qualcosa su cui dovresti mai fare affidamento, perché è un dettaglio di implementazione e perché se reallocfinisce per dover spostare la stringa frequentemente, le prestazioni degradano comunque a O (n ^ 2).

Senza gli strani dettagli di implementazione, l'algoritmo è O (n ^ 2) a causa della quantità quadratica di copie coinvolte. Un codice come questo avrebbe senso solo in un linguaggio con stringhe mutabili, come C ++, e anche in C ++ che vorresti usare +=.

L'autore fa affidamento su un'ottimizzazione che sembra essere qui, ma non è esplicitamente affidabile. strA = strB + strCè tipicamente O(n), rendendo la funzione O(n^2). Tuttavia, è abbastanza facile assicurarsi che l'intero processo sia O(n), utilizzare un array:

output = []
    # ... loop thing
    output.append('%20')
    # ...
    output.append(char)
# ...
return ''.join(output)

In poche parole, l' appendoperazione viene ammortizzata O(1) , (sebbene tu possa renderla forte O(1)pre-allocando l'array alla giusta dimensione), facendo il ciclo O(n).

E poi lo joinè anche O(n), ma va bene perché è fuori dal ciclo.

Ho trovato questo frammento di testo su Python Speed> Usa i migliori algoritmi e gli strumenti più veloci :

La concatenazione di stringhe viene eseguita meglio con ''.join(seq)che è un O(n)processo. Al contrario, l'utilizzo degli operatori '+'o '+='può dare come risultato un O(n^2)processo perché è possibile creare nuove stringhe per ogni passaggio intermedio. L'interprete CPython 2.4 attenua in qualche modo questo problema; tuttavia, ''.join(seq)rimane la migliore pratica

Per i futuri visitatori: poiché è una domanda CTCI, non è richiesto alcun riferimento al pacchetto learning urllib qui, in particolare come per OP e il libro, questa domanda riguarda gli array e le stringhe.

Ecco una soluzione più completa, ispirata allo pseudo di @ njzk2:

text = 'Mr John Smith'#13 
special_str = '%20'
def URLify(text, text_len, special_str):
    url = [] 
    for i in range(text_len): # O(n)
        if text[i] == ' ': # n-s
            url.append(special_str) # append() is O(1)
        else:
            url.append(text[i]) # O(1)

    print(url)
    return ''.join(url) #O(n)


print(URLify(text, 13, '%20'))