Deje para que para una muestra muy corta como se pueda calcular de encontrar el orden estático de las diferencias por pares: { 1 , 3 , 6 , 2 , 7 , 5 } $Q_n = C_n.\{|X_i-X_j|;i < j\}_{(k)}$$\{1,3,6,2,7,5\}$$k$

    7 6 5 3 2 1
1   6 5 4 2 1
2   5 4 3 1
3   4 3 2
5   2 1
6   1
7

h = [n / 2] + 1 = 4

k = h (h-1) / 2 = 8

Así $Q_n=C_n. 2$

Obviamente, para muestras grandes que constan de 80,000 registros, necesitamos memoria muy grande.

¿Hay alguna forma de calcular $Q_n$ en el espacio 1D en lugar de 2D?

Un enlace a la respuesta ftp://ftp.win.ua.ac.be/pub/preprints/92/Timeff92.pdf aunque no puedo entenderlo completamente.

Actualización: El quid de la cuestión es que para lograr la complejidad de tiempo $O(n\log(n))$ , se necesita en el orden de almacenamiento $O(n)$ .

No, $O(n\log(n))$ es el límite teórico inferior para la complejidad temporal de (ver (1)) seleccionar el elemento $k^{th}$ entre todos los $\frac{n(n-1)}{2}$ posibles$|x_i - x_j|: 1 \leq i \lt j \leq n$.

Puede obtener espacio $O(1)$ , pero solo verificando ingenuamente todas las combinaciones de $x_i-x_j$ en el tiempo $O(n^2)$ .

La buena noticia es que puede usar el estimador de escala $\tau$ (consulte (2) y (3) para obtener una versión mejorada y algunas comparaciones de temporización), implementado en la función scaleTau2()del Rpaquete robustbase. El estimador $\tau$ univariado es un estimador de escala de dos pasos (es decir, re-ponderado). Tiene una eficiencia gaussiana del 95 por ciento, un punto de ruptura del 50 por ciento y la complejidad del tiempo $O(n)$ y el espacio $O(1)$ (además se puede hacer fácilmente 'en línea', reduciendo la mitad de los costos computacionales en uso repetido, aunque usted tendrá que cavar en el Rcódigo para implementar esta opción, es bastante sencillo de hacer).

1. La complejidad de la selección y clasificación en X + Y y matrices con columnas ordenadas GN Frederickson y DB Johnson, Journal of Computer and System Sciences Volume 24, Issue 2, April 1982, páginas 197-208.
2. Yohai, V. y Zamar, R. (1988). Estimaciones de regresión de alto punto de ruptura mediante la minimización de una escala eficiente. Revista de la Asociación Americana de Estadística 83 406–413.
3. Maronna, R. y Zamar, R. (2002). Estimaciones sólidas de ubicación y dispersión para conjuntos de datos de alta dimensión. Technometrics 44 307–317

Editar Para usar esto

1. Arranca R(es gratis y se puede descargar desde aquí )
2. Instale el paquete escribiendo:

install.packages("robustbase")

3. Cargue el paquete escribiendo:

library("robustbase")

4. Cargue su archivo de datos y ejecute la función:

mydatavector <- read.table("address to my file in text format", header=T)
scaleTau2(mydatavector)

(Respuesta muy corta) El texto para comentar dice

Evite responder preguntas en los comentarios.

así que aquí va: hay un documento sobre un algoritmo en línea que aparentemente funciona bastante bien: aplicando el estimador línea$Q_n$ .

EDITAR

(por el usuario user603). El algoritmo vinculado a este artículo es una versión en versión de ventana móvil de .$Q_n$

$\{x_i\}_{i=1}^N$$n<N$$\{x_i\}_{i=t-n+1}^t$$Q_n$$N-n+1$$Q_n$$\{Q_n^i\}_{i=1}^{N-n+1}$

$Q_n^i|Q_n^{i-1}$ $O(n\log(n))$$Q_n^i$

$Q_n$$\{x_i\}_{i=1}^N$$O(n^2)$

esta es mi implementación de Qn ...

Estaba programando esto en C y el resultado es este:

void bubbleSort(double *datos, int N)
{
 for (int j=0; j<N-1 ;j++)     
  for (int i=j+1; i<N; i++)    
   if (datos[i]<datos[j])      
   {
    double tmp=datos[i];
    datos[i]=datos[j];
    datos[j]=tmp;
   }
}

double  fFactorial(long N)    
{
 double factorial=1.0;

 for (long i=1; i<=N; ++i)
  factorial*=(double)i;

 return factorial;  
}

double fQ_n(double *datos, int N)  // Rousseeuw's and Croux (1993) Qn scale estimator
{
 bubbleSort(datos, N);

 int m=(int)((fFactorial((long)N))/(fFactorial(2)*fFactorial((long)N-2)));

 double D[m];
 //double Cn=2.2219;      //not used now :) constant value https://www.itl.nist.gov/div898/software/dataplot/refman2/auxillar/qn_scale.htm

 int k=(int)((fFactorial((long)N/2+1))/(fFactorial(2)*fFactorial((long)N/2+1-2)));

 int y=0;

 for (int i=0; i<N; i++)
  for (int j=N-1; j>=0; j--)
   if (i<j)
   {
    D[y]=abs(datos[i]-datos[j]);
    y++;
   }

 bubbleSort(D, m);

 return D[k-1];
}

int main(int argc, char **argv)    
{
 double datos[6]={1,2,3,5,6,7};
 int N=6;

 // Priting in terminal the final solution
 printf("\n==[Results] ========================================\n\n");

 printf(" Q_n=%0.3f\n",fQ_n(datos,N));

 return 0;
}