标签：min 一个 一般来说 运行时 mat 语句 趋势 结合 存在
/** * @description: 完成一趟合并 * @param a 输入数组 * @param low,mid,high a[low...high] 是待排序序列， 其中a[low...mid]和 a[mid+1...high]已有序 */ private static void merge (int a [],int low,int mid,int high) { for(int k=low;k<=high;k++){ aux[k] = a[k]; // 将待排序序列a[low...high]拷贝到辅助数组的相同位置 } int i = low; // 游标i,开始时指向待排序序列中左半边的头元素 int j = mid+1; // 游标j,开始时指向待排序序列中右半边的头元素 for(int k=low;k<=high;k++){ if(i>mid){ a[k] = aux[j++]; // 左半边用尽 }else if(j>high){ a[k] = aux[i++]; // 右半边用尽 }else if(aux[j]<aux[i]){ a[k] = aux[j++]; // 右半边当前元素小于左半边当前元素， 取右半边元素 }else { a[k] = aux[i++]; // 右半边当前元素大于等于左半边当前元素，取左半边元素 } } } }
sort(a,low,mid); sort(a,mid+1,high); merge(a,low,mid,high);
/** * @Author: HuWan Peng * @Date Created in 9:44 2017/11/29 */ public class MergeSort { private static int aux []; /** * @description: 1. 初始化辅助数组aux，使其长度和原数组相同 * 2. 包装sort，向外只暴露一个数组参数 */ public static void sort(int a []){ aux = new int[a.length]; sort(a,0,a.length-1); } /** * @description: 基于递归的归并排序算法 */ private static void sort (int a [], int low,int high) { if(low>=high) { return; } // 终止递归的条件 int mid = low + (high - low)/2; // 取得序列中间的元素 sort(a,low,mid); // 对左半边递归 sort(a,mid+1,high); // 对右半边递归 merge(a,low,mid,high); // 单趟合并 } /** * @description: 单趟合并算法 * @param a 输入数组 * @param low,mid,high a[low...high] 是待排序序列,其中a[low...mid]和 a[mid+1...high]已有序 */ private static void merge (int a [],int low,int mid,int high) { int i = low; // 游标i,开始时指向待排序序列中左半边的头元素 int j = mid+1; // 游标j,开始时指向待排序序列中右半边的头元素 for(int k=low;k<=high;k++){ aux[k] = a[k]; // 将待排序序列a[low...high]拷贝到辅助数组的相同位置 } for(int k=low;k<=high;k++){ if(i>mid){ a[k] = aux[j++]; // 左半边用尽 }else if(j>high){ a[k] = aux[i++]; // 右半边用尽 }else if(aux[j]<aux[i]){ a[k] = aux[j++]; // 右半边当前元素小于左半边当前元素， 取右半边元素 }else { a[k] = aux[i++]; // 右半边当前元素大于等于左半边当前元素，取左半边元素 } } } }
public class Test { public static void main (String args[]){ int [] a = {1,6,3,2,9,7,8,1,5,0}; MergeSort.sort(a); for(int i=0;i<a.length;i++){ System.out.println(a[i]); } } }
0 1 1 2 3 5 6 7 9
sort(a,low,mid); // A sort(a,mid+1,high); // B merge(a,low,mid,high);// C
（下面展示的归并进行了一些优化，对小数组使用插入排序）
if(low>=high) { return; }
if(low + M>=high) { // 数组长度小于10的时候 InsertSort.sort(int a [], int low,int high) // 切换到插入排序 return; }
private static void sort (int a [], int low,int high) { if(low + 10>=high) { // 数组长度小于10的时候 InsertSort.sort(int a [], int low,int high) // 切换到插入排序 return; } // 终止递归的条件 int mid = low + (high - low)/2; // 取得序列中间的元素 sort(a,low,mid); // 对左半边递归 sort(a,mid+1,high); // 对右半边递归 merge(a,low,mid,high); // 单趟合并 }
private static void sort (int a [], int low,int high) { if(low>=high) { return; } // 终止递归的条件 int mid = low + (high - low)/2; // 取得序列中间的元素 sort(a,low,mid); // 对左半边递归 sort(a,mid+1,high); // 对右半边递归 if(a[mid]<=a[mid+1]) return; // 避免不必要的归并 merge(a,low,mid,high); // 单趟合并 }
for(int k=low;k<=high;k++){ aux[k] = a[k]; // 将待排序序列a[low...high]拷贝到辅助数组的相同位置 }
public static void sort(int a []){ aux = a.clone(); // 拷贝一个和a所有元素相同的辅助数组 sort(a,aux,0,a.length-1); } /** * @description: 基于递归的归并排序算法 */ private static void sort (int a[], int aux[], int low,int high) { if(low>=high) { return; } // 终止递归的条件 int mid = low + (high - low)/2; // 取得序列中间的元素 sort(aux, a,low,mid); // 对左半边递归 sort(aux, a,mid+1,high); // 对右半边递归 merge(a, aux, low,mid,high); // 单趟合并 }
/** * @Author: HuWan Peng * @Date Created in 9:44 2017/11/29 */ public class MergeSort { private static int aux []; /** * @description: 1. 初始化辅助数组aux，使其和原数组元素完全相同 * 2. 包装sort，向外只暴露一个数组参数 */ public static void sort(int a []){ aux = a.clone(); // 拷贝一个和a所有元素相同的辅助数组 sort(a,aux,0,a.length-1); } /** * @description: 基于递归的归并排序算法 */ private static void sort (int a[], int aux[], int low,int high) { if(low>=high) { return; } // 终止递归的条件 int mid = low + (high - low)/2; // 取得序列中间的元素 sort(aux, a,low,mid); // 对左半边递归 sort(aux, a,mid+1,high); // 对右半边递归 merge(a, aux, low,mid,high); // 单趟合并 } /** * @description: 单趟合并算法 * @param a 输入数组 * @param low,mid,high a[low...high] 是待排序序列,其中a[low...mid]和 a[mid+1...high]已有序 */ private static void merge (int a [],int aux [],int low,int mid,int high) { int i = low; // 游标i,开始时指向待排序序列中左半边的头元素 int j = mid+1; // 游标j,开始时指向待排序序列中右半边的头元素 // 这里的for循环拷贝已经去除掉了 for(int k=low;k<=high;k++){ if(i>mid){ a[k] = aux[j++]; // 左半边用尽 }else if(j>high){ a[k] = aux[i++]; // 右半边用尽 }else if(aux[j]<aux[i]){ a[k] = aux[j++]; // 右半边当前元素小于左半边当前元素， 取右半边元素 }else { a[k] = aux[i++]; // 右半边当前元素大于等于左半边当前元素，取左半边元素 } } } }
/** * @Author: HuWan Peng * @Date Created in 23:42 2017/11/30 */ public class MergeSort2 { private static int aux []; public static void sort(int a []){ int N = a.length; aux = new int [N]; for (int size =1; size<N;size = size+size){ for(int low =0;low<N-size;low+=size+size) { merge(a,low,low+size-1,Math.min(low+size+size-1,N-1)); } } } private static void merge (int a [],int low,int mid,int high) { int i = low; // 游标i,开始时指向待排序序列中左半边的头元素 int j = mid+1; // 游标j,开始时指向待排序序列中右半边的头元素 for(int k=low;k<=high;k++){ aux[k] = a[k]; } for(int k=low;k<=high;k++){ if(i>mid){ a[k] = aux[j++]; // 左半边用尽 }else if(j>high){ a[k] = aux[i++]; // 右半边用尽 }else if(aux[j]<aux[i]){ a[k] = aux[j++]; // 右半边当前元素小于左半边当前元素， 取右半边元素 }else { a[k] = aux[i++]; // 右半边当前元素大于等于左半边当前元素，取左半边元素 } } } }
【算法】一个小白的算法笔记： 归并排序算法的编码和优化 (,,? ? ?,,)
标签：min 一个 一般来说 运行时 mat 语句 趋势 结合 存在
原文地址：http://www.cnblogs.com/penghuwan/p/7940440.html
