Mesclar classificação
princípio
A ideia central de Merge Sort (Merge Sort) é que se quisermos classificar uma matriz, primeiro dividimos a matriz em duas partes a partir do meio e, em seguida, classificamos as duas partes separadamente e, em seguida, mesclamos as duas partes classificadas. , de modo que os arrays inteiros sejam todos ordenados. A classificação por mesclagem usa a ideia de dividir e conquistar.
Dividir e conquistar
Dividir e conquistar, como o nome indica, é dividir e conquistar, resolver um grande problema em subproblemas menores. Quando os pequenos subproblemas são resolvidos, os grandes problemas são resolvidos. As ideias de dividir e conquistar são geralmente implementadas por recursão. Dividir para conquistar é uma ideia de processamento para resolver problemas, e a recursão é uma técnica de programação, as duas não entram em conflito. Para recursão, é necessário encontrar a fórmula de recursão e as condições de término, então escreva a fórmula recursiva mergeSort (m-> n) = merge (mergeSort (m-> k), mergeSort (k + 1-> n)); Terminar quando m = n. Ou seja, quando queremos classificar a sequência entre m-> n, podemos na verdade dividi-la em classificar a sequência entre m-> k e classificar a sequência entre k + 1-> n e, em seguida, conectar a fusão do A série ordenada é chamada de série final. Da mesma forma, a classificação de cada série pode continuar a ser dividida para formar recursão.
O processo do algoritmo é o seguinte
Descrição do algoritmo:
- Divida a sequência de entrada de comprimento n em duas subsequências de comprimento n / 2;
- Use a classificação por mesclagem para essas duas subsequências, respectivamente;
- Finalmente, as duas subsequências classificadas são mescladas em uma sequência final classificada.
Código
public class MergeSort {
//1.如果要排序一个数组，我们先把数组从中间分成前后两部分，然后对前后两部分分别排序
//2.再将排好序的两部分合并在一起，这样整个数组就都有序了
public static void main(String[] args) {
int[] array = {
5, 2, 6, 9, 0, 3, 11, 7};
MergeSort sort = new MergeSort();
int[] ints = sort.mergeSort(array);
System.out.println(Arrays.toString(ints));
}
public int[] mergeSort(int[] arr) {
if (arr.length < 2) {
return arr;
}
//将数组从中间拆分成左右两部分
int mid = arr.length / 2;
int[] left = Arrays.copyOfRange(arr, 0, mid);
int[] right = Arrays.copyOfRange(arr, mid, arr.length);
return merge(mergeSort(left), mergeSort(right));
}
//合并两个有序数组并返回新的数组
public int[] merge(int[] left, int[] right) {
//创建一个新的数组，等于left+right之和
int[] newArray = new int[left.length + right.length];
//定义两个指针,分别代表两个数组的下标
int lindex = 0;
int rindex = 0;
for (int i = 0; i < newArray.length; i++) {
if(lindex >= left.length){
newArray[i] = right[rindex++];
}else if(rindex >= right.length){
newArray[i] = left[lindex++];
}else if(left[lindex] < right[rindex] ){
newArray[i] = left[lindex++];
}else{
newArray[i] = right[rindex++];
}
}
return newArray;
}
}
1: Qual é a complexidade de tempo da classificação de mesclagem?
A eficiência de execução de merge sort não tem nada a ver com a ordem do array original a ser classificado, então sua complexidade de tempo é muito estável, independentemente do melhor caso, pior caso ou caso médio, a complexidade de tempo é O (nlogn) .
2: Qual é a complexidade do espaço do merge sort ?
A complexidade do espaço de merge sort é O (n).
3: A classificação por mesclagem é um algoritmo de classificação estável?
A estabilidade do algoritmo de classificação por mesclagem não depende da função de mesclagem merge (). Ou seja, a parte do código onde duas submatrizes ordenadas são mescladas em uma matriz ordenada. Ao analisar a função de mesclagem, descobrimos que a ordenação por mesclagem também é um algoritmo de classificação estável .