Resumen: Ocho algoritmo de ordenación

directorio

En primer lugar, una especie de inserción

1, tipo inserción directa

 

2, la clasificación de la colina

 

En segundo lugar, la selección especie

1, tipo simple selección

 

2, heapsort

 

En tercer lugar, tipo de cambio

1, ordenamiento de burbuja

 

2, más o menos rápida

 

En cuarto lugar, la fusión especie

---

En primer lugar, una especie de inserción

1, tipo inserción directa

Se cree algoritmo: ordenar la matriz que se divide en dos partes, que todos los elementos de la matriz (con exclusión de los elementos para ser insertados), la otra parte es para ser insertado elemento; primera porción de un primer tipo es completa, y luego insertar el elemento. ordenadas en el que la primera parte se divide de nuevo en dos partes realizadas por.

Aquí el arr predeterminado [0] es drenado porción de secuencia, Arr [j] = arr [j - 1]; representa la corriente que ser resuelto si el número es menor que el número de traverse de atrás hacia delante, a continuación, se mueve hacia atrás, arr [j] = temp; representa los valores correspondientes a la posición de inserción.

int[] arr = {1,4,2,8,74,12,9,30,8,11,22,87,12,44,28};
int gap = 1,i,j;
int temp;
int len = arr.length;
for(i = 1;i < len;i++){
    temp = arr[i];
    for(j = i;j >= 1&&arr[j - 1] > temp;j -= 1){
        arr[j] = arr[j - 1];
    }
    arr[j] = temp;
}

La complejidad del tiempo promedio	mejor de los casos	peor de los casos	espacio complejidad
O (N $ ² $)	O (n)	O (N $ ² $)	O (1)

 

2, la clasificación de la colina

Array para ser ordenada brecha de paquetes en pasos de, a continuación, los elementos de cada grupo mediante el método de inserción directa tipo de clasificación; binario cada hueco se reduce a continuación, el ciclo de funcionamiento descrito anteriormente, cuando hueco = 1, utilizando la inserción directa, completa Ordenar. )

De hecho, el paso directo de ordenación por inserción es comparar dos valores 1, que es la operación de clasificación Colina representado convirtió en brecha. Esta es una optimización de ordenación por inserción directa.

int[] arr = {1,4,2,8,74,12,9,30,8,11,22,87,12,44,28};

int gap = 1,i,j;
int temp;
int len = arr.length;
while(gap < len /3){
    gap = gap * 3 + 1;
}
for(;gap > 0; gap /= 3){
    for(i = gap ; i < len;i++){
        temp = arr[i];
        for(j = i;j >= gap && arr[j - gap]> temp;j -= gap){
            arr[j] = arr[j - gap];
        }
        arr[j] = temp;
    }
}

 

La complejidad del tiempo promedio	mejor de los casos	peor de los casos	espacio complejidad
O (nlog2 n)	O (nlog2 n)	O (nlog2 n)	O (1)

 

En segundo lugar, la selección especie

1, tipo simple selección

Este algoritmo es relativamente sencillo, es encontrar el valor más pequeño cada vez, y luego guardar su cambio anterior primer subíndice 1,2 ..... arr.Length-1.

int[] arr = {1,4,2,8,74,12,9,30,8,11,22,87,12,44,28};
for(int i = 0;i < arr.length - 1;i++){
    int min = i;
    for(int j = i + 1;j < arr.length;j++){
        if(arr[j] < arr[i]){
            min = j;
        }
    }
    if(min != i){
        int temp = arr[i];
        arr[i] = arr[min];
        arr[min] = temp;
    }
}

O (N $ ² $)

O (N $ ² $)

O (N $ ² $)

O (1)

 

2, heapsort

En primer lugar primera matriz en pilas, en la parte superior es un gran montón. Luego de atravesar cada uno tomando las grandes pilas superiores elemento superior, de nuevo heapify. La secuenciación completa.

public static void main(String[] args) {
//        int[] arr = {1,4,2,8,74,12,9,30,8,11,22,87,12,44,28};
        int[] arr = {2,5,3,1,10,4};
        heap_sort(arr,arr.length);
        for(int k = 0;k < arr.length;k++){
            System.out.print(arr[k] + " ");
        }

    }
    //通过堆排序，输出
    public static void heap_sort(int[] arr,int len){
        build_heapify(arr,len);
        for(int i = len - 1;i >= 0; i--){
            swap(arr,i,0);
            heapify(arr,i,0);
        }
    }
    //构建整个堆，每一个堆节点
    public static void build_heapify(int[] arr,int len){
        int last_node_index = len - 1;
        int parent_index = (last_node_index - 1) / 2;
        for(int i  = parent_index;i >= 0;i--){
            heapify(arr,len,i);
        }
    }
    //对单个堆进行排序
    public static void heapify(int []arr,int len,int i){
        if(i >= len)
            return ;
        int left = i * 2 + 1;
        int right = i * 2 + 2;
        int max = i;
        if(left < len && arr[max] < arr[left])
            max = left;
        if(right < len &&arr[max] < arr[right])
            max = right;
        if(max != i){
            swap(arr,max,i);
            heapify(arr,len,max);
        }
    }
    public static void swap(int[] arr,int x,int y){
        int temp = arr[x];
        arr[x] = arr[y];
        arr[y] = temp;
    }

La complejidad del tiempo promedio	mejor de los casos	peor de los casos	espacio complejidad
O (nlog2n)	O (nlog2n)	O (nlog2n)	O (1)

 

En tercer lugar, tipo de cambio

1, ordenamiento de burbuja

Este algoritmo es relativamente sencillo burbujeante, directa máxima a la última posición.

for(int i = arr.length;i >= 0;i--){
    for(int j = 0;j < i&& j + 1 < i;j++){
        if (arr[j] > arr[j + 1]){
            int temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
}

La complejidad del tiempo promedio	mejor de los casos	peor de los casos	espacio complejidad
O (N $ ² $)	O (n)	O (N $ ² $)	O (1)

 

2, más o menos rápida

Ordenar rápida ordenamiento de burbuja es una optimización de esta idea es: seleccionar un valor de referencia, el lado izquierdo del valor de referencia es inferior a su derecha son mayores que su valor.

public static void quick_sort(int[] arr ,int low,int high){
    if(arr.length < 0 || low > high)
        return ;
    int left = low;
    int right = high;
    //保存基准值
    int temp = arr[left];
    while(left < right){
        //从后向前找到比基准小的元素
        while(left < right && arr[right] >= temp){
            right--;
        }
        arr[left] = arr[right];
        //从前往后找到比基准大的元素
        while(left < right && arr[left] <= temp){
            left++;
        }
        arr[right] = arr[left];
    }
    arr[left] = temp;
    quick_sort(arr,low,left - 1);
    quick_sort(arr,left + 1,high);
}

O (nlog₂n)

O (nlog₂n)

O (N $ ² $)

O (1) (en lugar de partición versión recursiva)

 

En cuarto lugar, la fusión especie

pensado:

. ① cada dos adyacentes números de secuencia se fusionan operación, un suelo (N / 2) secuencias, cada secuencia que comprende dos elementos ordenados;

. ② La secuencia anterior de nuevo se unen para formar un (n / 4) secuencias de suelo, cada secuencia que comprende cuatro elementos;

③. Repita el paso ②, hasta que todos los elementos ordenados.

 

public static int[] mergingSort(int[] arr){
    if(arr.length <= 1)
        return arr;
    int num = arr.length >> 1;
    int[] arrLeft = Arrays.copyOfRange(arr,0,num);
    int[] arrRight = Arrays.copyOfRange(arr,num,arr.length);
    return mergeTwoArray(mergingSort(arrLeft),mergingSort(arrRight));
}

public static int[] mergeTwoArray(int[] arr1,int[] arr2){
    int[] result = new int[arr1.length + arr2.length];
    int i = 0,j = 0, k = 0;
    while(i < arr1.length && j < arr2.length){
        if(arr1[i] < arr2[j]){
            result[k++] = arr1[i++];
        }else{
            result[k++] = arr2[j++];
        }
    }
    while(i < arr1.length){
        result[k++] = arr1[i++];
    }
    while(j < arr2.length){
        result[k++] = arr2[j++];
    }
    return result;
}

En quinto lugar, Radix sort

El uso de cubo tipo de pensamiento

public static void radixSort(int[] arrays){
    int max = findMax(arrays);

    //遍历位数
    for(int i = 1;max / i > 0;i *= 10){
        int[][] buckets = new int[arrays.length][10];
        //获取每一位数字(个、十、百、千位...分配到桶子里)
        for(int j = 0;j < arrays.length;j++){
            int num = (arrays[j] / i) % 10;
            //将其放入桶子里
            buckets[j][num] = arrays[j];
        }
        //回收桶子里的元素
        int k = 0;

        for(int j = 0;j < 10;j++){
            for(int y = 0;y < arrays.length;y++){
                if(buckets[y][j]!=0){
                    arrays[k++] = buckets[y][j];
                }
            }
        }
    }
}

public static int findMax(int[] arrays){
    int max = 0;
    for(int i = 0;i < arrays.length;i++){
        if(arrays[i] > max){
            max =arrays[i];
        }
    }
    return max;
}