[Descripción del problema]
给你一个整数数组 nums，将该数组升序排列。
示例 1：
输入：nums = [5,2,3,1]
输出：[1,2,3,5]
[Pensamiento] respuesta
1. ordenación por inserción (familiar)
Cada vez que un digital de inserción de una matriz ordenada, se convierten en una longitud más larga de una matriz ordenada, después de las operaciones limitadas, ordenó matrices como un todo.
- Optimización: "a digital de inserción de una matriz ordenada" Este paso no puede utilizarse para el intercambio gradualmente, asignado a la primera utilización de "variables temporales" y, a continuación después del cambio "elementos apropiados", desocupado una posición, y finalmente el "variable temporal estrategia de "asignado a la vacante (es decir, la imagen de arriba se entiende). Codificación de tiempo si no se tiene cuidado, probablemente modificar el valor de la matriz, la propuesta de la puesta en marcha de múltiples
Complejidad de tiempo: O (N ^ 2) la complejidad espacial: O (1)
public class Solution {
// 插入排序：稳定排序，在接近有序的情况下，表现优异
public int[] sortArray(int[] nums) {
int len = nums.length;
// 循环不变量：将 nums[i] 插入到区间 [0, i) 使之成为有序数组
for (int i = 1; i < len; i++) {
// 先暂存这个元素，然后之前元素逐个后移，留出空位
int temp = nums[i];
int j = i;
// 注意边界 j > 0
while (j > 0 && nums[j - 1] > temp) {
nums[j] = nums[j - 1];
j--;
}
nums[j] = temp;
}
return nums;
}
}
作者：liweiwei1419
链接：https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/
2. ordenamiento por mezcla (enfoque)
Con el espacio adicional, la fusión de dos matrices ordenadas se hacen más largos y disposición ordenada.
complejidad Tiempo: O (NlogN) complejidad espacio: O (N)
- Optimización 1: giro en "ordenación por inserción", el código fuente de Java que tiene una similar este tipo de operaciones "inter-celular" en uso "entre células" es un parámetro muy larga duración, necesidad de la toma de prueba, me refiero aquí al código fuente del JDK;
- Optimización 2: En las dos matrices"sí se ordena según las circunstancias, no es necesaria la consolidación;
- Optimización 3: Usar toda la gama de funcionamiento de un provisionales "Combinar dos matrices ordenadas", para evitar la creación de una matriz temporal de la destrucción y el consumo, para evitar el cálculo del índice de desplazamiento.
- Nota: Cuando combinación de tipo de realización, prestar especial atención a no aplicar este algoritmo a una especie no estable, la diferencia de <= y <, están especificados en el código.
public class Solution {
// 归并排序
/**
* 列表大小等于或小于该大小，将优先于 mergeSort 使用插入排序
*/
private static final int INSERTION_SORT_THRESHOLD = 7;
public int[] sortArray(int[] nums) {
int len = nums.length;
int[] temp = new int[len];
mergeSort(nums, 0, len - 1, temp);
return nums;
}
/**
* 对数组 nums 的子区间 [left, right] 进行归并排序
*
* @param nums
* @param left
* @param right
* @param temp 用于合并两个有序数组的辅助数组，全局使用一份，避免多次创建和销毁
*/
private void mergeSort(int[] nums, int left, int right, int[] temp) {
// 小区间使用插入排序
if (right - left <= INSERTION_SORT_THRESHOLD) {
insertionSort(nums, left, right);
return;
}
int mid = left + (right - left) / 2;
// Java 里有更优的写法，在 left 和 right 都是大整数时，即使溢出，结论依然正确
// int mid = (left + right) >>> 1;
mergeSort(nums, left, mid, temp);
mergeSort(nums, mid + 1, right, temp);
// 如果数组的这个子区间本身有序，无需合并
if (nums[mid] <= nums[mid + 1]) {
return;
}
mergeOfTwoSortedArray(nums, left, mid, right, temp);
}
/**
* 对数组 arr 的子区间 [left, right] 使用插入排序
*
* @param arr 给定数组
* @param left 左边界，能取到
* @param right 右边界，能取到
*/
private void insertionSort(int[] arr, int left, int right) {
for (int i = left + 1; i <= right; i++) {
int temp = arr[i];
int j = i;
while (j > left && arr[j - 1] > temp) {
arr[j] = arr[j - 1];
j--;
}
arr[j] = temp;
}
}
/**
* 合并两个有序数组：先把值复制到临时数组，再合并回去
*
* @param nums
* @param left
* @param mid [left, mid] 有序，[mid + 1, right] 有序
* @param right
* @param temp 全局使用的临时数组
*/
private void mergeOfTwoSortedArray(int[] nums, int left, int mid, int right, int[] temp) {
//void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
System.arraycopy(nums, left, temp, left, right + 1 - left);
int i = left;
int j = mid + 1;
//两条有序序列合并
for (int k = left; k <= right; k++) {
//left mid +1
//[1,1,2,3] [5,6,7,8]
//边界 左边遍历完 右边还没开始 右边持续插入
if (i == mid + 1) {
nums[k] = temp[j];
//没能改变值
j++;
// [5,6,7,8] [1,1,2,3]
//边界 右边遍历完 左边还没开始 左边持续插入
} else if (j == right + 1) {
nums[k] = temp[i];
i++;
} else if (temp[i] <= temp[j]) {
// 注意写成 < 就丢失了稳定性（相同元素原来靠前的排序以后依然靠前）
nums[k] = temp[i];
i++;
} else {
// temp[i] > temp[j]
nums[k] = temp[j];
j++;
}
}
}
}
作者：liweiwei1419
链接：https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/
3. Ordenación rápida (enfoque)
QuickSort cada vez que un elemento programado (este elemento debe permanecer en su estancia posición final), y luego ir recursivamente porción fila de su izquierda y derecha, a fin de proceder, hasta una matriz ordenada;
[imágenes de cadenas extranjeras volcado falla, la estación de origen puede tener un mecanismo de cadena de seguridad, se recomienda guardar las fotos subidas directamente hacia abajo (img-bH18YcEd-1585662450983) ( https://upload-images.jianshu.io/upload_images/17025746-9d7d9ff3a2826052.png?imageMogr2/auto -orient / tira% 7CimageView2 / 2 / w / 1240)]
import java.util.Random;
public class Solution {
// 快速排序 1：基本快速排序
/**
* 列表大小等于或小于该大小，将优先于 quickSort 使用插入排序
*/
private static final int INSERTION_SORT_THRESHOLD = 7;
private static final Random RANDOM = new Random();
public int[] sortArray(int[] nums) {
int len = nums.length;
quickSort(nums, 0, len - 1);
return nums;
}
private void quickSort(int[] nums, int left, int right) {
// 小区间使用插入排序
if (right - left <= INSERTION_SORT_THRESHOLD) {
insertionSort(nums, left, right);
return;
}
int pIndex = partition(nums, left, right);
quickSort(nums, left, pIndex - 1);
quickSort(nums, pIndex + 1, right);
}
/**
* 对数组 nums 的子区间 [left, right] 使用插入排序
*
* @param nums 给定数组
* @param left 左边界，能取到
* @param right 右边界，能取到
*/
private void insertionSort(int[] nums, int left, int right) {
for (int i = left + 1; i <= right; i++) {
int temp = nums[i];
int j = i;
while (j > left && nums[j - 1] > temp) {
nums[j] = nums[j - 1];
j--;
}
nums[j] = temp;
}
}
//版本 1：基本快排：把等于切分元素的所有元素分到了数组的同一侧，可能会造成递归树倾斜；
private int partition(int[] nums, int left, int right) {
//避免有序数组 效率低下
////随机生成一个整数，这个整数的范围就是[0,right - left + 1）
int randomIndex = RANDOM.nextInt(right - left + 1) + left;
swap(nums, left, randomIndex);
// 基准值
int pivot = nums[left];
int lt = left;
// 循环不变量：
// all in [left + 1, lt] < pivot
// all in [lt + 1, i) >= pivot
for (int i = left + 1; i <= right; i++) {
if (nums[i] < pivot) {
lt++;
swap(nums, i, lt);
}
}
swap(nums, left, lt);
return lt;
}
//版本 2：双指针快排：把等于切分元素的所有元素等概率地分到了数组的两侧，避免了递归树倾斜，递归树相对平衡；
private int partition(int[] nums, int left, int right) {
int randomIndex = left + RANDOM.nextInt(right - left + 1);
swap(nums, randomIndex, left);
int pivot = nums[left];
int lt = left + 1;
int gt = right;
// 循环不变量：
// all in [left + 1, lt) <= pivot
// all in (gt, right] >= pivot
while (true) {
while (lt <= right && nums[lt] < pivot) {
lt++;
}
while (gt > left && nums[gt] > pivot) {
gt--;
}
if (lt > gt) {
break;
}
// 细节：相等的元素通过交换，等概率分到数组的两边
swap(nums, lt, gt);
lt++;
gt--;
}
swap(nums, left, gt);
return gt;
}
private void swap(int[] nums, int index1, int index2) {
int temp = nums[index1];
nums[index1] = nums[index2];
nums[index2] = temp;
}
}
作者：liweiwei1419
链接：https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/
Versión 3: de tres mano rápida de drenaje: elemento de corte es igual a todos los elementos de la matriz intermedia empujados en que hay muchos sub-elementos y los elementos de corte son iguales en el caso de intervalo recursiva reducido en gran medida
mampara () de combinación en QUICKSORT ()
private void quickSort(int[] nums, int left, int right) {
// 小区间使用插入排序
if (right - left <= INSERTION_SORT_THRESHOLD) {
insertionSort(nums, left, right);
return;
}
int randomIndex = left + RANDOM.nextInt(right - left + 1);
swap(nums, randomIndex, left);
// 循环不变量：
// all in [left + 1, lt] < pivot
// all in [lt + 1, i) = pivot
// all in [gt, right] > pivot
int pivot = nums[left];
int lt = left;
int gt = right + 1;
int i = left + 1;
while (i < gt) {
if (nums[i] < pivot) {
lt++;
swap(nums, i, lt);
i++;
} else if (nums[i] == pivot) {
i++;
} else {
gt--;
swap(nums, i, gt);
}
}
swap(nums, left, lt);
// 注意这里，大大减少了两侧分治的区间
quickSort(nums, left, lt - 1);
quickSort(nums, gt, right);
}
作者：liweiwei1419
链接：https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/
4. pila de clasificación (heap es importante comprender pila de clasificación basado en las circunstancias individuales)
Montón se selecciona una especie de optimizar la especie, necesidad ordenación por selección para seleccionar el elemento más grande (complejidad de O (N) O (N)) por el enfoque "de advertencia de salud" no está prevista secciones, y "pila de clasificación," no pone programado para ser parte de la construcción de un "montón", por lo que puede ordenar O (logN) forma O (\ log N) elegir elemento más grande;
- Referencia sección montón "Algoritmo"
public class Solution {
public int[] sortArray(int[] nums) {
int len = nums.length;
// 将数组整理成堆
heapify(nums);
// 循环不变量：区间 [0, i] 堆有序
for (int i = len - 1; i >= 1; ) {
// 把堆顶元素（当前最大）交换到数组末尾
swap(nums, 0, i);
// 逐步减少堆有序的部分
i--;
// 下标 0 位置下沉操作，使得区间 [0, i] 堆有序
siftDown(nums, 0, i);
}
return nums;
}
/**
* 将数组整理成堆（堆有序）
*
* @param nums
*/
private void heapify(int[] nums) {
int len = nums.length;
// 只需要从 i = (len - 1) / 2 这个位置开始逐层下移
for (int i = (len - 1) / 2; i >= 0; i--) {
siftDown(nums, i, len - 1);
}
}
/**
* @param nums
* @param k 当前下沉元素的下标
* @param end [0, end] 是 nums 的有效部分
*/
private void siftDown(int[] nums, int k, int end) {
while (2 * k + 1 <= end) {
int j = 2 * k + 1;
if (j + 1 <= end && nums[j + 1] > nums[j]) {
j++;
}
if (nums[j] > nums[k]) {
swap(nums, j, k);
} else {
break;
}
k = j;
}
}
private void swap(int[] nums, int index1, int index2) {
int temp = nums[index1];
nums[index1] = nums[index2];
nums[index2] = temp;
}
}
作者：liweiwei1419
链接：https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/
5. Selección Ordenar
Selección de una porción mínima de cada sección de intercambio no programada para el inicio de la no programada mayor parte, a través de varios pasos, toda la matriz puede ser programado. A saber: primero seleccione la más pequeña, y luego seleccione el segundo más pequeño, y así sucesivamente.
complejidad Tiempo: O (N) la complejidad espacial: O (1)
// 选择排序：每一轮选择最小元素交换到未排定部分的开头
import java.util.Arrays;
public class Solution {
// 选择排序：每一轮选择最小元素交换到未排定部分的开头
public int[] sortArray(int[] nums) {
int len = nums.length;
// 循环不变量：[0, i) 有序，且该区间里所有元素就是最终排定的样子
for (int i = 0; i < len - 1; i++) {
// 选择区间 [i, len - 1] 里最小的元素的索引，交换到下标 i
int minIndex = i;
for (int j = i + 1; j < len; j++) {
if (nums[j] < nums[minIndex]) {
minIndex = j;
}
}
swap(nums, i, minIndex);
}
return nums;
}
private void swap(int[] nums, int index1, int index2) {
int temp = nums[index1];
nums[index1] = nums[index2];
nums[index2] = temp;
}
public static void main(String[] args) {
int[] nums = {5, 2, 3, 1};
Solution solution = new Solution();
int[] res = solution.sortArray(nums);
System.out.println(Arrays.toString(res));
}
}
作者：liweiwei1419
链接：https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/
6. colina de clasificación (no se recomienda dedicar más tiempo a la comprensión)
optimización de ordenación por inserción. En el tipo de inserción, si el número después de una más pequeña, habría llegado frente a los de cambio varias veces. "Colina de la clasificación" para mejorar este enfoque. Con el uso de intervalos de ordenación por inserción, hasta el último "intervalo" es 1 cuando la norma es la "ordenación por inserción", esta vez en el elemento de la matriz está ya "casi ordenada"
complejidad del tiempo de Shell tipo de conclusión todavía hay una clara sólo una gama
public class Solution {
// 希尔排序
public int[] sortArray(int[] nums) {
int len = nums.length;
int h = 1;
// 使用 Knuth 增量序列
// 找增量的最大值
while (3 * h + 1 < len) {
h = 3 * h + 1;
}
while (h >= 1) {
// insertion sort
for (int i = h; i < len; i++) {
insertionForDelta(nums, h, i);
}
h = h / 3;
}
return nums;
}
/**
* 将 nums[i] 插入到对应分组的正确位置上，其实就是将原来 1 的部分改成 gap
*
* @param nums
* @param gap
* @param i
*/
private void insertionForDelta(int[] nums, int gap, int i) {
int temp = nums[i];
int j = i;
// 注意：这里 j >= deta 的原因
while (j >= gap && nums[j - gap] > temp) {
nums[j] = nums[j - gap];
j -= gap;
}
nums[j] = temp;
}
}
作者：liweiwei1419
链接：https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/
7. ordenamiento de burbuja (entender)
Cada vez que a través de la comparación del par de bucle exterior, la más grande al final de cada ronda no son parte de los elementos en una matriz de programada
public class Solution {
// 冒泡排序：超时
public int[] sortArray(int[] nums) {
int len = nums.length;
for (int i = len - 1; i >= 0; i--) {
// 先默认数组是有序的，只要发生一次交换，就必须进行下一轮比较，
// 如果在内层循环中，都没有执行一次交换操作，说明此时数组已经是升序数组
boolean sorted = true;
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
swap(nums, j, j + 1);
sorted = false;
}
}
if (sorted) {
break;
}
}
return nums;
}
private void swap(int[] nums, int index1, int index2) {
int temp = nums[index1];
nums[index1] = nums[index2];
nums[index2] = temp;
}
}
作者：liweiwei1419
链接：https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/
8. secuenciación de recuento (información)
Cada valor que aparece hacer un recuento, a continuación, pequeñas a grandes de salida de matriz ordenada de acuerdo con el recuento.
- enfoque mantenimiento de la estabilidad es: el prefijo a la matriz y para hacer el recuento, cuando la parte posterior asignación a la etapa 2, de acuerdo con los datos del original asignación de matriz de entrada de atrás hacia delante, prefijos, y cada elemento de la matriz sostiene el índice almacenado información (aquí no decir demasiado delgada, tenía que no es importante, no es difícil de entender).
Autor: liweiwei1419
enlace: https: //leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/
public class Solution {
// 计数排序
private static final int OFFSET = 50000;
public int[] sortArray(int[] nums) {
int len = nums.length;
// 由于 -50000 <= A[i] <= 50000
// 因此"桶" 的大小为 50000 - (-50000) = 10_0000
// 并且设置偏移 OFFSET = 50000，目的是让每一个数都能够大于等于 0
// 这样就可以作为 count 数组的下标，查询这个数的计数
int size = 10_0000;
// 计数数组
int[] count = new int[size];
// 计算计数数组
for (int num : nums) {
count[num + OFFSET]++;
}
// 把 count 数组变成前缀和数组
for (int i = 1; i < size; i++) {
count[i] += count[i - 1];
}
// 先把原始数组赋值到一个临时数组里，然后回写数据
int[] temp = new int[len];
System.arraycopy(nums, 0, temp, 0, len);
// 为了保证稳定性，从后向前赋值
for (int i = len - 1; i >= 0; i--) {
int index = count[temp[i] + OFFSET] - 1;
nums[index] = temp[i];
count[temp[i] + OFFSET]--;
}
return nums;
}
}
作者：liweiwei1419
链接：https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/
9. Selección Ordenar (aprender)
- La clasificación basada en palabras clave, por ejemplo, ordenación numérica, los bits, diez, cien es la palabra clave. Para datos ordenados por fecha: año, mes, día, hora, minuto, segundo es la palabra clave
- "Radix sort", utiliza un "contar Ordenar"
public class Solution {
// 基数排序：低位优先
private static final int OFFSET = 50000;
public int[] sortArray(int[] nums) {
int len = nums.length;
// 预处理，让所有的数都大于等于 0，这样才可以使用基数排序
for (int i = 0; i < len; i++) {
nums[i] += OFFSET;
}
// 第 1 步：找出最大的数字
int max = nums[0];
for (int num : nums) {
if (num > max) {
max = num;
}
}
// 第 2 步：计算出最大的数字有几位，这个数值决定了我们要将整个数组看几遍
int maxLen = getMaxLen(max);
// 计数排序需要使用的计数数组和临时数组
int[] count = new int[10];
int[] temp = new int[len];
// 表征关键字的量：除数
// 1 表示按照个位关键字排序
// 10 表示按照十位关键字排序
// 100 表示按照百位关键字排序
// 1000 表示按照千位关键字排序
int divisor = 1;
// 有几位数，外层循环就得执行几次
for (int i = 0; i < maxLen; i++) {
// 每一步都使用计数排序，保证排序结果是稳定的
// 这一步需要额外空间保存结果集，因此把结果保存在 temp 中
countingSort(nums, temp, divisor, len, count);
// 交换 nums 和 temp 的引用，下一轮还是按照 nums 做计数排序
int[] t = nums;
nums = temp;
temp = t;
// divisor 自增，表示采用低位优先的基数排序
divisor *= 10;
}
int[] res = new int[len];
for (int i = 0; i < len; i++) {
res[i] = nums[i] - OFFSET;
}
return res;
}
private void countingSort(int[] nums, int[] res, int divisor, int len, int[] count) {
// 1、计算计数数组
for (int i = 0; i < len; i++) {
// 计算数位上的数是几，先取个位，再十位、百位
int remainder = (nums[i] / divisor) % 10;
count[remainder]++;
}
// 2、变成前缀和数组
for (int i = 1; i < 10; i++) {
count[i] += count[i - 1];
}
// 3、从后向前赋值
for (int i = len - 1; i >= 0; i--) {
int remainder = (nums[i] / divisor) % 10;
int index = count[remainder] - 1;
res[index] = nums[i];
count[remainder]--;
}
// 4、count 数组需要设置为 0 ，以免干扰下一次排序使用
for (int i = 0; i < 10; i++) {
count[i] = 0;
}
}
/**
* 获取一个整数的最大位数
*
* @param num
* @return
*/
private int getMaxLen(int num) {
int maxLen = 0;
while (num > 0) {
num /= 10;
maxLen++;
}
return maxLen;
}
}
作者：liweiwei1419
链接：https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/
10. Selección Ordenar (aprender)
ublic class Solution {
// 桶排序
// 1 <= A.length <= 10000
// -50000 <= A[i] <= 50000
// 10_0000
private static final int OFFSET = 50000;
public int[] sortArray(int[] nums) {
int len = nums.length;
// 第 1 步：将数据转换为 [0, 10_0000] 区间里的数
for (int i = 0; i < len; i++) {
nums[i] += OFFSET;
}
// 第 2 步：观察数据，设置桶的个数
// 步长：步长如果设置成 10 会超出内存限制
int step = 1000;
// 桶的个数
int bucketLen = 10_0000 / step;
int[][] temp = new int[bucketLen + 1][len];
int[] next = new int[bucketLen + 1];
// 第 3 步：分桶
for (int num : nums) {
int bucketIndex = num / step;
temp[bucketIndex][next[bucketIndex]] = num;
next[bucketIndex]++;
}
// 第 4 步：对于每个桶执行插入排序
for (int i = 0; i < bucketLen + 1; i++) {
insertionSort(temp[i], next[i] - 1);
}
// 第 5 步：从桶里依次取出来
int[] res = new int[len];
int index = 0;
for (int i = 0; i < bucketLen + 1; i++) {
int curLen = next[i];
for (int j = 0; j < curLen; j++) {
res[index] = temp[i][j] - OFFSET;
index++;
}
}
return res;
}
private void insertionSort(int[] arr, int endIndex) {
for (int i = 1; i <= endIndex; i++) {
int temp = arr[i];
int j = i;
while (j > 0 && arr[j - 1] > temp) {
arr[j] = arr[j - 1];
j--;
}
arr[j] = temp;
}
}
}
作者：liweiwei1419
链接：https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/
[Resumen]
. ##### 1 Resumen clasificación algoritmo
[Imagen volcado fuera de la cadena falla, la estación de origen puede tener un mecanismo de cadena de seguridad, se recomienda guardar las fotos subidas directamente hacia abajo (img-1VAMavOi-1585662450986) ( https: //upload-images.jianshu .IO / upload_images / 17025746-64aa4a7d0e174744.png? imageMogr2 / auto-orientar / tira% 7CimageView2 / 2 / w / 1240)]
1.1 Inserción Ordenar
- Complejidad de tiempo: O (N ^ 2) la complejidad espacial: O (1)
- Pros: En la matriz "casi ordenada" tuvo un buen desempeño, en particular, se comportan en un "corto matriz" también es muy bueno. Debido a las características de "corta matriz" está previsto que cada elemento de su posición final no será demasiado lejos
- Aplicación: Al realizar el tipo de tareas dentro de la célula de inter-se puede activar mediante la "ordenación por inserción"
1.2 de combinación especie
- complejidad del tiempo: la complejidad O (NlogN) Espacio: O (N)
- la idea del algoritmo: recursividad, dividir y conquistar la resolución de problemas en el campo ideológico del algoritmo es muy común, escribiendo "combinación de tipo" aprender el pensamiento recursivo, comprender los detalles de recursión familiarizados con la idea de la partición, es un muy buen material de aprendizaje.
- Beneficios: "merge sort", "ordenación rápida" que la cosa buena es, significa que el espacio adicional, se puede lograr "estable especie", Java estaba clasificando tarea para la "matriz de objetos", es decir, el uso de combinación de clase (una versión mejorada del TimSort aquí no introducida).
1.3 fila rápida
- complejidad del tiempo: O (NlogN) Espacio complejidad: O (logN)
- Algoritmo idea: Divide y vencerás (divide y idea de conquista), y "combinación de tipo" diferente "ordenación rápida" en "puntos" no quieren "combinación de tipo" sin cerebro que se partió en dos en esta materia, en lugar de utilizar el método de partición, por lo tanto, no existe un proceso "juntos" en.
[Volcar imagen no pasa la cadena, la estación de origen puede tener mecanismo de cadena de seguridad, se recomienda guardar la imagen abajo subido directamente (img-BWOPzOP8-1585662450988) (https://upload-images.jianshu.io/upload_images/17025746-ad48df7591da38ac.png ? imageMogr2 / Orientación automática / Strip% 7CimageView2 / 2 / w / 1240)]
- Contras: rápida estabilidad Ordenar perdido, si necesita un establo rápida tipo, es necesario definir la función de comparación específica, un proceso llamado "estabilización" en aquí no realizado. - :( desventajas para casos de prueba específicos: el orden inverso de la matriz o array) elemento debe aleatorización segmentación (pivote), de lo contrario, se encuentra en la matriz de entrada ordenados matriz o matriz en orden inverso cuando el género rápida será muy lento (equivalente al ordenamiento de burbuja o "ordenación por selección");
1.4 heapsort
- complejidad Tiempo: O (NlogN) complejidad espacio: O (1)
- Pila de clasificación es la selección especie de optimización, es necesario seleccionar el tipo de imprevisto elegido en parte el elemento más grande (complejidad de O (N)) por "Atención de la Salud", enfoque, y "pila de clasificación," tomaron parte no programada acumulación en un "montón", por lo que puede ordenar O (logN) es elegido por el elemento más grande;
- Montón es una estructura de datos muy interesante, que en muchos idiomas también se nombra como "cola de prioridad." Se basa en una matriz de estructura de "árbol", estructuras de datos similares, así como "disjuntos-set", "línea de árboles" y así sucesivamente. "Cola de prioridad" es una cola especial, en orden de prioridad del equipo, a partir de ese momento que la "cola ordinaria" no hay diferencia. Arrays "cola de prioridad" se pueden utilizar para lograr, también se puede conseguir con una matriz ordenada, pero siempre y cuando una estructura lineal, la complejidad será alto, por lo tanto, la estructura de "árbol" tiene ventajas, para lograr la mejor "cola de prioridad" es "montón ".
1.5 Selección Ordenar
- Complejidad de tiempo: O (N ^ 2) la complejidad espacial: O (1)
- Ventajas: Número mínimo de intercambios.
- 1 idea algoritmo: algoritmo voraz: cada decisión tan sólo mirar a la corriente, la corriente óptima, el óptimo global. Nota: esta idea no es aplicable en todo momento.
- ALGORITMO 2: ideología menos política: el bucle exterior cada vez que un elemento programado, la escala del problema se reduce gradualmente hasta que esté completamente resuelto, es decir, "de grandes y pequeñas, de la pequeña". El uso de "menos ideología política" algoritmo típico es el famoso "búsqueda binaria."
1.6 ordenación Shell
- complejidad del tiempo: no está claro
1.7 ordenamiento de burbuja (entender)
- Complejidad de tiempo: O (N ^ 2) la complejidad espacial: O (1)
- Pros: "ordenamiento de burbuja" tiene una característica: Durante el recorrido, las matrices de detección precoz se ordenan, poniendo fin a una especie, en lugar de la "ordenación por selección" que, incluso si los datos de entrada está en orden ", seleccione Ordenar "todavía tienen que" lugares pasar por todos los procesos tonta".
Selección Ordenar Count 1.8 1.9 1.10 Selección Ordenar
- Complejidad de tiempo: O (N) de optimización
- Características: un lugar donde el número está determinado por el tamaño de esta misma decisión número, que no requiere la comparación. También se puede considerar un hash de pensamiento: el valor mapeado de direcciones.
- Características: Se necesita cierto espacio adicional para completar la tarea de clasificar
- Contras: escena aplicable tanto, principalmente debido a la utilización de estos tres clasificación deben asegurarse de que cada elemento de la matriz de entrada están dentro de un rango razonable
- Ventajas: estable tipo puede implementarse como, sin estabilización
2. Especificación Código
2.1 invariantes de bucle (descarga rápida)
- mantener la variable "invariantes de bucle" que se define antes del inicio del ciclo, ciclo, después del final del ciclo, siendo la misma naturaleza, la naturaleza del problema se define en términos de características hechas por el hombre.
"Bases para demostrar la eficacia del algoritmo es escribir el código para garantizar el cumplimiento de lazo invariante, no es igual al número de escritura, el primer cambio o el primer invariante de bucle ++, sería particularmente claro, nunca se equivoca, vamos a cumplir con el "invariantes de bucle", escrito como un comentario en el código.
No se recomienda 2.2 estilo de código "algoritmo de 4"
- El código está escrito posters, y debe tratar de evitar el código de estilo personal, utilizando el texto estándar para garantizar la legibilidad, la escalabilidad.
[Volcar imagen no pasa la cadena, la estación de origen puede tener mecanismo de cadena de seguridad, se recomienda guardar la imagen abajo cargado directamente (IMG-ntkuZXCs-1585662450990) ( https://upload-images.jianshu.io/upload_images/17025746-5aba0141df398096.png ? imageMogr2 / Orientación automática / Gaza 7CimageView2% / 2 / W / 1240 es)]
2.3 optimización nombre de la variable - lt es menor que la abreviatura representa un (estrictamente) menos de;
- Es mayor que gt abreviatura representa mayor (en sentido estricto) de uno;
- le es menor o igual abreviaturas, mostrando menos (este código no se utiliza);
- es una abreviatura ge mayor que o igual a, mayor que o igual expresada (este código no se utiliza).
3. Ordenar la entrada exitosa entrevista por escrito no se asuste
public int[] sortArray(int[] nums) {
Arrays.sort(nums);
return nums;
}
Amway página web:
Algoritmo para la presentación dinámica
conexión de referencia: https: //leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/
