“Sıralılık” nasıl ölçülür?

Bir dizinin "sıralama" sının standart bir yolu olup olmadığını merak ediyorum. Ortanca muhtemel ters çevrme sayısına sahip olan bir dizi, en fazla sıralanmamış olarak kabul edilir mi? Demek istediğim, temelde olabildiğince sıralı veya ters sıralı olmaktır.

Hayır, uygulamanıza bağlı. Sortedness ölçüleri genellikle adını alır bozukluğun önlemler ile ilgili fonksiyonları, için R , K < N belirgin negatif olmayan tamsayılar bütün sonlu dizilerin koleksiyonudur. Estivill-Castro ve Wood [1] tarafından yapılan anket uyarlamalı sıralama algoritmaları bağlamında 11 farklı bozukluk ölçütünü listeliyor ve tartışıyor.$N^{<N}$$\mathbb{R}$$N^{<N}$

Ters çevrimlerin sayısı bazı durumlarda işe yarayabilir, ancak bazen yetersizdir. [1] 'de verilen örnek dizidir.

ikinci dereceden tersine çevrilmiş olan, ancak yalnızca iki artan yoldan oluşur. Neredeyse sıralanır, ancak bu ters çevrimler tarafından ele geçirilmez.

[1] Estivill-Castro, Vladmir ve Derick Wood. "Uyarlamalı sıralama algoritmaları araştırması." ACM Hesaplama Anketleri (CSUR) 24.4 (1992): 441-476.

Mannila [1], benzerliği (karşılaştırma-temelli algoritmalara odaklanarak) aşağıdaki şekilde (parantezleme) aksiyomlaştırır.

Let tamamen sipariş seti. Daha sonra bir eşleştirme m gelen Σ ⋆ (farklı elemanların sekansları Σ doğal insanlar) a, presortedness ölçüsü , aşağıdaki koşulları bunu ise tatmin.$\Sigma$$m$$\Sigma^{\star}$$\Sigma$

1. Eğer sonra sıralanır m ( x ) = 0 .$X \in \Sigma^{\star}$$m(X) = 0$

2. Eğer ile X = x 1 ... x , n , Y = y 1 ... Y , n ve x i < x $X,Y \in \Sigma^{\star}$$X = x_1 \dots x_n$$Y = y_1 \dots y_n$ hepsi için i , j ∈ [ 1 .. n ] , sonra m ( X ) = m ( Y ) .$x_i < x_i \iff y_i < y_j$$i,j \in [1..n]$$m(X) = m(Y)$

3. Eğer bir alt sekans olup , Y ∈ Σ ⋆ , ardından m ( X ) ≤ m ( Y ) .$X$$Y \in \Sigma^{\star}$$m(X) \leq m(Y)$

4. If $x_i < y_j$ for all $i \in [1..|X|]$ and $j \in [1..|Y|]$ for some $X,Y \in \Sigma^{\star}$, then $m(X \cdot Y) \leq m(X) + m(Y)$.

5. için her x ∈ Σ ⋆ ve bir ∈ e ∖ x .$m(a \cdot X) \leq |X| + m(X)$$X \in \Sigma^{\star}$$a \in E \setminus X$

Bu tür önlemlere örnekler

• inversiyon sayısı
• takas sayısı,
• soldan sağa maksima olmayan elemanların sayısı ve
• en uzun artan alt dizilimin uzunluğu (giriş uzunluğundan çıkarılır).

$\theta > 0$

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

Note how $\theta = 1$ defines the uniform distribution (for all $m$).

Since it is possible to sample permutations w.r.t. these measures efficiently, this body of work can be useful in practice when benchmarking sorting algorithms.

1. Measures of Presortedness and Optimal Sorting Algorithms by H. Mannila (1985)
2. Logarithmic combinatorial structures: a probabilistic approach by R. Arratia, A.D. Barbour and S. Tavaré (2003)
3. On adding a list of numbers (and other one-dependent determinantal processes) by A. Borodin, P. Diaconis and J. Fulman (2010)
4. Ewens-like distributions and Analysis of Algorithms by N. Auger et al. (2016)

I have my own definition of "sortedness" of a sequence.

Given any sequence [a,b,c,…] we compare it with the sorted sequence containing the same elements, count number of matches and divide it by the number of elements in the sequence.

For example, given sequence [5,1,2,3,4] we proceed as follows:

1) sort the sequence: [1,2,3,4,5]

2) compare the sorted sequence with the original by moving it one position at a time and counting the maximal number of matches:

        [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) The maximal number of matches is 4, we can calculate the "sortedness" as 4/5 = 0.8.

Sortedness of a sorted sequence would be 1, and sortedness of a sequence with elements placed in reversed order would be 1/n.

The idea behind this definition is to estimate the minimal amount of work we would need to do to convert any sequence to the sorted sequence. In the example above we need to move just one element, the 5 (there are many ways, but moving 5 is the most efficient). When the elements would be placed in reversed order, we would need to move 4 elements. And when the sequence were sorted, no work is needed.

I hope my definition makes sense.

If you need something quick and dirty (summation signs scare me) I wrote a super easy disorder function in C++ for a Class named Array which generates int arrays filled with randomly generated numbers:

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;
}

Function simply compares the value in each element to the index of the element + 1 so that an array in reverse order has a disorder value of 1, and a sorted array has a disorder value of 0. Not sophisticated, but working.

Michael