Varias formas de clasificación por inserción directa

Complejidad del tiempo de clasificación de inserción directa

La complejidad de tiempo promedio de la ordenación por inserción también es O (n ^ 2), y la complejidad del espacio es un orden constante de O (1). La complejidad de tiempo específica también está relacionada con el orden de la matriz.

En la ordenación por inserción, cuando la matriz a ordenar está ordenada, es la situación óptima. Solo necesita comparar el número actual con el número anterior. En este momento, debe comparar N-1 veces en total, y el tiempo la complejidad es O (N). El peor de los casos es que la matriz que se va a ordenar está en orden inverso y el número de comparaciones es el máximo. El peor de los casos es O (n ^ 2).

Estabilidad de clasificación por inserción directa La clasificación por inserción
directa es un algoritmo estable, que satisface la definición de un algoritmo estable.
Estabilidad del algoritmo: suponga que hay a [i] = a [j] en la secuencia, si antes de ordenar, a [i] está delante de a [j]; y después de ordenar, a [i] todavía está en a [j ] frente. ¡Entonces este algoritmo de clasificación es estable!

La primera

 public static void sort(Comparable[] arr){

        int n = arr.length;
        for (int i = 0; i < n; i++) {
            // 寻找元素 arr[i] 合适的插入位置
           for( int j = i ; j > 0 ; j -- )
                if( arr[j].compareTo( arr[j-1] ) < 0 )
                    swap( arr, j , j-1 );
                else
                    break;
        }
    }
    //核心代码---结束
    private static void swap(Object[] arr, int i, int j) {
        Object t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }

El segundo

public static void sort(int[] a) {
        for (int i = 0, j = i; i < a.length - 1; j = ++i) {
            int ai = a[i + 1];
            while (ai < a[j]) {
                a[j + 1] = a[j];
                if (j-- == 0) {
                    break;
                }
            }
            a[j + 1] = ai;
        }
    }

El tercero

public static void selfSort2(int[] a){
        for (int i,j=0;++j<a.length;){
            int ai=a[i=j];
            if(a[i]<a[i-1]){
                while (--i>=0 && ai<a[i]){
                    a[i+1]=a[i];
                }
                a[i+1]=ai;
            }
        }
    }

El cuarto

public static void StraightSort(int[] arr) {
        int tmp;
        int i;
        int j;
        for (i = 1; i < arr.length; i++) {
            tmp = arr[i];
            for (j = i - 1; j >= 0 && arr[j] > tmp; j--) {
                arr[j + 1] = arr[j];
            }
            arr[j + 1] = tmp;
        }
    }

 

Supongo que te gusta

Origin blog.csdn.net/GoSaint/article/details/113871181
Recomendado
Clasificación