Come calcolare il runtime nel caso peggiore di questo algoritmo di ricerca

Ho scritto una speciale funzione indexOf per un elenco di valori univoci non ordinati.

Posso cercare uno o più valori (non ordinati), passati come array / elenco, e la funzione mi restituirà un array / elenco di indici (eventualmente vuoto).

In base alle seguenti circostanze:

• So che i valori che sto cercando sono nella lista
• Non mi interessa l'ordine in cui vengono restituiti gli indici
• L'unicità

Sto facendo quanto segue:

1. Passa attraverso l'elenco (di dimensione n)
2. Confronta i valori con tutti i valori nell'elenco di ricerca
3. Se c'è un'interruzione di corrispondenza, aggiungi ai risultati, apri il ciclo e rimuovi il valore trovato dall'elenco di ricerca (quindi è più piccolo sull'elemento successivo)
4. Se non ci sono più valori da cercare, interrompi la lista-traversal.

Mi piacerebbe sapere come analizzare questo algoritmo e in particolare cosa è il runtime del caso peggiore. (Immagino se sto cercando tutti i valori contenuti nella lista.)

Fonte in JavaScript:

function multipleIndexOf(search, arr) {

    var searchArr = search.slice(0);
    var result = [];

    /* loop through array */
    for (var i = 0, l = arr.length; i < l; i++) {

        /* loop through search values */
        for (var i2 = 0, l2 = searchArr.length; i2 < l2; i2++) {

            /* if a search value matches... */
            if (arr[i] == searchArr[i2]) {
                /* add to result */
                result.push(i);

                /* remove from array */
                searchArr.splice(i2, 1);

                /* continue search with next */
                break;
            }
        }

        if (searchArr.length == 0) {
            break;
        }
    }

    return result;
}