Come misurare "ordinamento"

Mi chiedo se esiste un modo standard per misurare la "ordinamento" di un array? Un array che ha il numero medio di possibili inversioni sarebbe considerato al massimo indifferenziato? Con ciò voglio dire che è sostanzialmente il più lontano possibile dall'essere ordinati o in ordine inverso.

No, dipende dalla tua applicazione. Le misure di ordinamento sono spesso indicate come misure di disordine , che sono funzioni da a , dove è la raccolta di tutte le sequenze finite di interi non negativi distinti. Il sondaggio di Estivill-Castro e Wood [1] elenca e discute 11 diverse misure di disordine nel contesto di algoritmi di ordinamento adattivo.$N^{<N}$$\mathbb{R}$$N^{<N}$

Il numero di inversioni potrebbe funzionare in alcuni casi, ma a volte è insufficiente. Un esempio dato in [1] è la sequenza

che ha un numero quadratico di inversioni, ma consiste solo di due corse ascendenti. È quasi ordinato, ma questo non viene catturato dalle inversioni.

[1] Estivill-Castro, Vladmir e Derick Wood. "Un sondaggio sugli algoritmi di ordinamento adattivo." ACM Computing Surveys (CSUR) 24.4 (1992): 441-476.

Mannila [1] assiomatizza la presortedness (con un focus sugli algoritmi basati sul confronto) come segue (parafrasando).

Lascia che un set totalmente ordinato. Quindi una mappatura da (le sequenze di elementi distinti da ) ai naturali è una misura di presortedness se soddisfa le condizioni di seguito.$\Sigma$$m$$\Sigma^{\star}$$\Sigma$

1. Se è ordinato, allora .$X \in \Sigma^{\star}$$m(X) = 0$

2. Se con , e per tutti , quindi .$X,Y \in \Sigma^{\star}$$X = x_1 \dots x_n$$Y = y_1 \dots y_n$$x_i < x_i \iff y_i < y_j$$i,j \in [1..n]$$m(X) = m(Y)$

3. Se è una sottosequenza di , allora .$X$$Y \in \Sigma^{\star}$$m(X) \leq m(Y)$

4. Se per tutti e per alcuni , allora .$x_i < y_j$$i \in [1..|X|]$$j \in [1..|Y|]$$X,Y \in \Sigma^{\star}$$m(X \cdot Y) \leq m(X) + m(Y)$

5. $m(a \cdot X) \leq |X| + m(X)$ per tutti e .$X \in \Sigma^{\star}$$a \in E \setminus X$

Esempi di tali misure sono il

• numero di inversioni,
• numero di swap,
• il numero di elementi che non sono massimi da sinistra a destra e
• la lunghezza di una sottosequenza crescente più lunga (sottratta dalla lunghezza di input).

Si noti che sono state definite distribuzioni casuali che utilizzano queste misure, ovvero tali da rendere più o meno probabili sequenze più / meno ordinate. Queste sono chiamate distribuzioni simili a Ewens [2, Ch. 4-5; 3, Esempio 12; 4], un caso speciale di cui è la cosiddetta distribuzione Mallows . I pesi sono parametrici in una costante e soddisfano$\theta > 0$

$\qquad\displaystyle \operatorname{Pr}(X) = \frac{\theta^{\,m(X)}}{\sum_{Y \in \Sigma^{\star} \cap \Sigma^{|X|}} \theta^{\,m(Y)}}$ .

Nota come definisce la distribuzione uniforme (per tutti ).$\theta = 1$$m$

Poiché è possibile campionare le permutazioni con queste misure in modo efficiente, questo corpus di lavoro può essere utile nella pratica quando si confrontano gli algoritmi di ordinamento.

1. Misure di presortedness e algoritmi di smistamento ottimali di H. Mannila (1985)
2. Strutture combinatorie logaritmiche: un approccio probabilistico di R. Arratia, AD Barbour e S. Tavaré (2003)
3. Sull'aggiunta di un elenco di numeri (e altri processi determinanti a dipendenza singola) di A. Borodin, P. Diaconis e J. Fulman (2010)
4. Distribuzioni simili a Ewens e analisi degli algoritmi di N. Auger et al. (2016)

Ho la mia definizione di "ordinamento" di una sequenza.

Data qualsiasi sequenza [a, b, c, ...] la confrontiamo con la sequenza ordinata contenente gli stessi elementi, contiamo il numero di corrispondenze e lo dividiamo per il numero di elementi nella sequenza.

Ad esempio, data la sequenza [5,1,2,3,4]procediamo come segue:

1) ordina la sequenza: [1,2,3,4,5]

2) confrontare la sequenza ordinata con l'originale spostandola di una posizione alla volta e contando il numero massimo di corrispondenze:

        [5,1,2,3,4]
[1,2,3,4,5]                            one match

        [5,1,2,3,4]
  [1,2,3,4,5]                          no matches

        [5,1,2,3,4]
    [1,2,3,4,5]                        no matches

        [5,1,2,3,4]
      [1,2,3,4,5]                      no matches

        [5,1,2,3,4]
        [1,2,3,4,5]                    no matches

        [5,1,2,3,4]
          [1,2,3,4,5]                  4 matches

        [5,1,2,3,4]
            [1,2,3,4,5]                no matches

                ...

         [5,1,2,3,4]
                 [1,2,3,4,5]            no matches

3) Il numero massimo di partite è 4, possiamo calcolare la "ordinamento" come 4/5 = 0,8.

L'ordinamento di una sequenza ordinata sarebbe 1 e l'ordinamento di una sequenza con elementi disposti in ordine inverso sarebbe 1 / n.

L'idea alla base di questa definizione è stimare la quantità minima di lavoro che dovremmo fare per convertire qualsiasi sequenza nella sequenza ordinata. Nell'esempio sopra abbiamo bisogno di spostare solo un elemento, il 5 (ci sono molti modi, ma lo spostamento di 5 è il più efficiente). Quando gli elementi sarebbero posizionati in ordine inverso, dovremmo spostare 4 elementi. E quando la sequenza è stata ordinata, non è necessario alcun lavoro.

Spero che la mia definizione abbia un senso.

Se hai bisogno di qualcosa di rapido e sporco (i segni di sommatoria mi spaventano) ho scritto una funzione di disordine super facile in C ++ per una classe chiamata Array che genera array int riempiti con numeri generati casualmente:

void Array::disorder() {
    double disorderValue = 0;
    int counter = this->arraySize;
    for (int n = 0; n < this->arraySize; n++) {
        disorderValue += abs(((n + 1) - array[n]));
//      cout << "disorderValue variable test value = " << disorderValue << endl;
        counter++;
    }
    cout << "Disorder Value = " << (disorderValue / this->arraySize) / (this->arraySize / 2) << "\n" << endl;
}

La funzione confronta semplicemente il valore di ciascun elemento con l'indice dell'elemento + 1 in modo che un array in ordine inverso abbia un valore di disordine di 1 e un array ordinato abbia un valore di disordine di 0. Non sofisticato, ma funzionante.

Michael