Java中的快速排序，用于大量元素

我需要一些帮助。我已经用Java实现了快速排序，现在我正在测试使用50.000到15.000.000个元素所需的时间。问题是这需要很长时间。例如：

50.000 Elements, 38 seconds.
100.000 Elements, 230 seconds.
250.000 Elements, I'm still waiting (around 8 minutes)

这样行吗？这是我的密码：

/* Clase que implementa el QuickSort */
public class QuickSort {
    private static final int corte = 3;
    private int i, j;

    public void ordenar(Comparable[] a, int izquierda, int derecha) {

        if (izquierda + corte <= derecha) {

            Comparable pivote = mediana(a, izquierda, derecha);

            i = izquierda;
            j = derecha - 1;

            for (;;) {
                while (a[++i].compareTo(pivote) < 0) {
                }
                while (a[--j].compareTo(pivote) > 0) {
                }
                if (i < j) {
                    intercambiar(a, i, j);
                } else {
                    break;
                }

                intercambiar(a, i, derecha - 1);
            }

            ordenar(a, izquierda, i - 1);
            ordenar(a, i + 1, derecha);

        } else {

            InsertSort(a);
        }
    }

    private static Comparable mediana(Comparable[] a, int izquierda, int derecha) {
        int centro = (izquierda + derecha) / 2;

        if (a[centro].compareTo(a[izquierda]) < 0) {
            intercambiar(a, izquierda, centro);
        }

        if (a[derecha].compareTo(a[izquierda]) < 0) {
            intercambiar(a, izquierda, derecha);
        }

        if (a[derecha].compareTo(a[centro]) < 0) {
            intercambiar(a, centro, derecha);
        }

        intercambiar(a, centro, derecha - 1);
        return a[derecha - 1];

    }

    private static void intercambiar(Comparable[] arreglo, int a, int b) {
        Comparable temporal;
        temporal = arreglo[a];
        arreglo[a] = arreglo[b];
        arreglo[b] = temporal;

    }

    private void InsertSort(Comparable[] lista) {

        for (int i = 1; i < lista.length; i++) {
            Comparable auxiliar = lista[i];
            int j = i - 1;

            while (j >= 0 && lista[j].compareTo(auxiliar) > 0) {

                lista[j + 1] = lista[j];
                j = j - 1;

            }

            lista[j + 1] = auxiliar;

        }
    }
}



public class Test {

    public static void main (String [] args) {
        long tInicial = 0;
        long tFinal = 0;
        long tRes = 0;
        int tam = 250000;

        Arreglo B = new Arreglo (tam);

        System.out.print("Prueba de Tiempo:");
        B.cargarArreglo();
        tInicial = System.currentTimeMillis();
        B.ordenarArreglo();
        tFinal = System.currentTimeMillis();

        tRes = tFinal - tInicial;
        System.out.println();
        System.out.println("Tiempo Transcurrido (ms): " + tRes + " para " + tam + " elementos.");
    }
}

/*Clase que实现快速排序*/
公共类快速排序{
私有静态最终整数=3；
私人int i，j；
公共无效或无效（可比[]a，内部izquierda，内部derecha）{
如果（izquierda+corte 0）{
}
if（i=0&&lista[j].比较（辅助）>0）{
lista[j+1]=lista[j]；
j=j-1；
}
lista[j+1]=辅助；
}
}
}
公开课考试{
公共静态void main（字符串[]args）{
长细观=0；
长tFinal=0；
长tRes=0；
int tam=250000；
Arreglo B=新Arreglo（tam）；
系统输出打印（“Prueba de Tiempo:”）；
B.cargarrareglo（）；
Tinical=System.currentTimeMillis（）；
B.Ordenarareglo（）；
tFinal=System.currentTimeMillis（）；
tRes=t最终-微小；
System.out.println（）；
系统输出println（“Tiempo Transcurrido（ms）：“+tRes+”para“+tam+”elementos”）；
}
}

快速排序的运行时间是（平均）O（n log n）或（最坏情况）O（n^2）。这意味着50.000的运行时间为50.000*10.819778284410283~540000。对于250.000，运行时间为：250.000*12.429216196844383~3.100.000。因此，250.000的运行时间大约是50.000运行时间的6倍。另一个因素是内存管理。从50000到250000个元素的系数实际上是：~12.63。考虑到O（n^2）的最坏情况，这仍然是可以的。

不

InsertSort（a）对整个数组排序？为什么要将整个数组作为快速排序递归的基本情况进行排序？太好了！那是我的错误！非常感谢。很多现在，250.000个元素需要328毫秒才能完成。谢谢你，伙计：）