Le tri par fusion et son analyse de la complexité temporelle
Qu'est-ce que le tri par fusion ?
Le tri par fusion incarne l'idée de diviser pour mieux régner, diviser le tableau d'origine, trier chaque partie séparément, puis les fusionner une par une, et enfin obtenir le résultat souhaité.
- Diviser le tableau
- trier le tableau
- Comment trier (du plus petit au plus grand)
partie de code
/**
* @author `dongxu.kwb`
* @date `2022/8/30`
*/
public class MergeSort {
public static void main(String[] args) {
int[] arr = {
79,3213,3,5,45,65};
mergeSort(arr);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
public static void mergeSort(int[] arr) {
//判断下数组是否为空,或者是一个数
if (arr == null || arr.length < 2) {
return;
}
//给整个数组分割并且排序
process(arr, 0, arr.length - 1);
}
/**
* 主要负责递归
* @param arr
* @param left
* @param right
*/
public static void process(int[] arr, int left, int right) {
//递归结束条件
if (left == right) {
return;
}
//找中点
int mid = left + ((right - left) >> 1);
//左右拆分并且排序
process(arr, left, mid);
process(arr, mid + 1, right);
//排序
merge(arr, left, mid, right);
}
/**
* 主要负责排序
* @param arr
* @param left
* @param mid
* @param right
*/
public static void merge(int[] arr, int left, int mid, int right) {
int[] help = new int[right - left + 1];
int i = 0;
int p1 = left; //左指针
int p2 = mid + 1; //右指针
//如果左右指针都没超出边界
while (p1 <= mid && p2 <= right) {
help[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
}
//左指针超出边界
while (p1 <= mid) {
help[i++] = arr[p1++];
}
//右指针超出边界
while (p2 <= right){
help[i++] = arr[p2++];
}
//将排好序的部分同步到arr原数组中
for (int i1 = 0; i1 < help.length; i1++) {
arr[left + i1] = help[i1];
}
}
}
Analyse de complexité temporelle
Nous avons constaté que dans les fonctions récursives, les sous-récursions ont la même chance. Ainsi, l'expression principale peut être utilisée.
Voir l'article pour l'expression maître : https://blog.csdn.net/abaidaye/article/details/126603143
process(arr, left, mid);
process(arr, mid + 1, right);
Parce que dans la fonction de fusion, quoi qu'il arrive, les deux pointeurs s'additionnent pour traverser n nombres donc d=O(n).
Par conséquent, la formule principale pour cette question est : T(n) = 2 * T(n/2) + O(n).
A ce moment logba log^a_bl o gbun== d, donc la complexité temporelle est O(n log 2 n log_2^nl o g2n)