Un no-recursivo
¿Cuál es la combinación de una especie?
- Merge sort (Merge-SORT) se basa en una operación de combinación eficiente de algoritmo de ordenación, que es muy típica aplicación utiliza un divide y vencerás (divide y vencerás) a. La secuencia combinada se ha ordenado, ordenado totalmente secuencia; es decir, cada secuencia de primera ordenado, y luego ordenado hacer secuencias entre segmentos. Si dos se combinaron en una lista ordenada lista ordenada, llamado modo de combinación. un método para ordenar fusión de una especie estable.
/**
* 非递归代码实现
*/
private static <T extends Comparable> void mergeSort(T[] arr){
for (int i = 1;i<arr.length;i*=2){
merge(arr,i);
}
}
private static<T extends Comparable> void merge(T[] arr, int gap) {
int left1 = 0;
int right1 = left1+gap-1;
int left2 = right1+1;
int right2 = left2+gap-1>arr.length-1?arr.length-1:left2+gap-1;//防止right越界
T []brr =(T[]) new Comparable[arr.length];//brr实质就是一个中间数组,存储每次并归后的值,然后再传给arr
//为下次归并做准备
int j = 0;//控制brr数组下标
//前提有两个归并段
while (left2<arr.length){//保证了第二个归并段的存在
while (left1<=right1 && left2<=right2){//防止越界
if (arr[left1].compareTo(arr[left2])<0){//谁小谁进新数组
brr[j++] = arr[left1++];
}else {
brr[j++] = arr[left2++];
}
}
if (left2>right2){//说明left2已经走完了,没元素了,那就让left1到right1剩下元素直接入brr就可以了
while (left1<=right1){
brr[j++] = arr[left1++];
}
}
if (left1>right1){//同理
while (left2<=right2){
brr[j++] = arr[left2++];
}
}
//更新指针
left1 = right2+1;
right1 = left1+gap-1;
left2 = right1+1;
right2 = left2+gap-1>arr.length-1?arr.length-1:left2+gap-1;
}
//只剩一个归并段
while (left1<=arr.length-1){
brr[j++] = arr[left1++];
}
System.arraycopy(brr,0,arr,0,arr.length);
}
En segundo lugar, recursiva
- Nos centramos vistazo a la ejecución de código recursivo: De hecho, nada subetapa especial, se trata de salir de elementos de la matriz, pero estamos acostumbrados a completar la secuenciación del proceso recursivo, que es muy importante, la forma en la recursividad? Modo de empleo?
Código de puntos de proceso aplicación:
- por ejemplo: int [] arr = { 2,5,6,7,8,9,5}, subíndices 0 a 6, podemos definir el comienzo y final coordenadas de dos elementos arr, y luego definir un intermedios coordenadas de elementos, de manera análoga a método dicotomía que divide los elementos de
códigos:
public static<T extends Comparable> void mergeSort2(T []arr,int left,int right,T[]brr){
if (left<right){
int mid = left+(right-left)/2;//中间索引
mergeSort2(arr,left,mid,brr);//左递归
mergeSort2(arr,mid+1,right,brr);//右递归
//合并
merge2(arr,left,mid,right,brr);
}
}
El código combinado para lograr:
//分合
public static<T extends Comparable> void mergeSort2(T []arr,int left,int right,T[]brr){
if (left<right){
int mid = left+(right-left)/2;//中间索引
mergeSort2(arr,left,mid,brr);//左递归
mergeSort2(arr,mid+1,right,brr);//右递归
//合并
merge2(arr,left,mid,right,brr);
}
}
/**
* @param arr 原始数组
* @param left 左边有序序列的初始索引
* @param mid 中间索引
* @param right 右边索引
* @param brr 中转索引
* @param <T>
*/
public static<T extends Comparable<T>> void merge2(T[]arr,int left,int mid,int right,T[]brr){
int i = left;//初始化 i ,左边序列初始索引
int j = mid +1;//右边序列初始索引
int t = 0;//控制brr数组下标
while (i<= mid && j<=right){
if (arr[i].compareTo(arr[j])<0){//小的入栈
brr[t++] = arr[i++];
}else {
brr[t++] = arr[j++];
}
}
//把剩余元素直接加到brr中
while (i<=mid){//左边序列有剩余
brr[t++] = arr[i++];
}
while (j<=right){//右边元素有剩余
brr[t++] = arr[j++];
}
//把brr数组拷贝到arr
t = 0;
int brrLeft = left;//
while (brrLeft<=right){
arr[brrLeft++] = brr[t++];//0-1,2-3,0-3
}
}