普通归并排序

public class MergeSort {
/**
* @param arr 待排序的数组
* @param left 本次归并的左边界
* @param mid 本次归并的中间位置,也就是分界线
* @param right 本次归并的右边界
* @param <T> 泛型
* @local aux 辅助空间(Auxiliary Space)
*/
private static <T extends Comparable<? super T>> void merge(T[] arr, int left, int mid, int right) {
T[] aux = java.util.Arrays.copyOfRange(arr, left, right + 1); //aux,i j分别是这两半的起始指针。将这两个闭区间归并[left ... mid] [mid + 1 ... right]
int i = left;
int j = mid + 1; for (int t = left; t <= right; t++) {//把arr数组中的[left...right]区间都覆盖了,就完事了
if (i > mid) { //i == mid + 1 时越界(跃出左半数组)
arr[t] = aux[j++ - left];
} else if (j > right) {//j == right + 1 时越界(跃出右半数组)
arr[t] = aux[i++ - left];
} else if (aux[i - left].compareTo(aux[j - left]) < 0) {//如果i-left小,那么插入。(左半边数组的指针所指的数小)
arr[t] = aux[i++ - left];
} else { //如果j-left小,那么插入。(右半边数组的指针所指的数小)
arr[t] = aux[j++ - left];
}
}
} private static <T extends Comparable<? super T>> void sort(T[] arr, int left, int right) {
if (left >= right) {
return;
} int mid = (left + right) / 2;
sort(arr, left, mid);
sort(arr, mid + 1, right);
merge(arr, left, mid, right);
} public static <T extends Comparable<? super T>> void sort(T[] arr) {
sort(arr, 0, arr.length - 1);
} private static void printArr(Object[] arr) {
for (Object o : arr) {
System.out.print(o);
System.out.print("\t");
}
System.out.println();
} public static void main(String args[]) {
Integer[] arr = {3, 5, 1, 7, 2, 9, 8, 0, 4, 6};
printArr(arr);//3 5 1 7 2 9 8 0 4 6
sort(arr);
printArr(arr);//0 1 2 3 4 5 6 7 8 9
}
}

归并优化:利用插入排序

当递归到规模足够小时,利用插入排序

public class MergeSort {
/**
* @param arr 待排序的数组
* @param left 本次归并的左边界
* @param mid 本次归并的中间位置,也就是分界线
* @param right 本次归并的右边界
* @param <T> 泛型
* @local aux 辅助空间(Auxiliary Space)
*/
private static <T extends Comparable<? super T>> void merge(T[] arr, int left, int mid, int right) {
T[] aux = java.util.Arrays.copyOfRange(arr, left, right + 1); //aux,i j分别是这两半的起始指针。将这两个闭区间归并[left ... mid] [mid + 1 ... right]
int i = left;
int j = mid + 1; for (int t = left; t <= right; t++) {//把arr数组中的[left...right]区间都覆盖了,就完事了
if (i > mid) { //i == mid + 1 时越界(跃出左半数组)
arr[t] = aux[j++ - left];
} else if (j > right) {//j == right + 1 时越界(跃出右半数组)
arr[t] = aux[i++ - left];
} else if (aux[i - left].compareTo(aux[j - left]) < 0) {//如果i-left小,那么插入。(左半边数组的指针所指的数小)
arr[t] = aux[i++ - left];
} else { //如果j-left小,那么插入。(右半边数组的指针所指的数小)
arr[t] = aux[j++ - left];
}
}
} /**
* @param arr 当规模小的时候对arr采用插入排序
* @param left 待排序部分的左边界
* @param right 待排序部分的右边界
* @param <T> 泛型
*/
private static <T extends Comparable<? super T>> void insertionSort(T[] arr, int left, int right) {
for (int i = left + 1; i <= right; i++) {
T temp = arr[i];
int j = i - 1;
while (j >= 0 && temp.compareTo(arr[j]) < 0) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = temp;
}
} private static <T extends Comparable<? super T>> void sort(T[] arr, int left, int right) {
if (right - left < 7) { //对小规模数据进行插入排序
insertionSort(arr, left, right);
return;
} int mid = (left + right) / 2;
sort(arr, left, mid);
sort(arr, mid + 1, right);
merge(arr, left, mid, right);
} public static <T extends Comparable<? super T>> void sort(T[] arr) {
sort(arr, 0, arr.length - 1);
} private static void printArr(Object[] arr) {
for (Object o : arr) {
System.out.print(o);
System.out.print("\t");
}
System.out.println();
} public static void main(String args[]) {
Integer[] arr = {3, 5, 1, 7, 2, 9, 8, 0, 4, 6};
printArr(arr);//3 5 1 7 2 9 8 0 4 6
sort(arr);
printArr(arr);//0 1 2 3 4 5 6 7 8 9
}
}  

归并排序继续优化:归并前判断一下是否还有必要归并

public class MergeSort {
/**
* @param arr 待排序的数组
* @param left 本次归并的左边界
* @param mid 本次归并的中间位置,也就是分界线
* @param right 本次归并的右边界
* @param <T> 泛型
* @local aux 辅助空间(Auxiliary Space)
*/
private static <T extends Comparable<? super T>> void merge(T[] arr, int left, int mid, int right) {
T[] aux = java.util.Arrays.copyOfRange(arr, left, right + 1); //aux,i j分别是这两半的起始指针。将这两个闭区间归并[left ... mid] [mid + 1 ... right]
int i = left;
int j = mid + 1; for (int t = left; t <= right; t++) {//把arr数组中的[left...right]区间都覆盖了,就完事了
if (i > mid) { //i == mid + 1 时越界(跃出左半数组)
arr[t] = aux[j++ - left];
} else if (j > right) {//j == right + 1 时越界(跃出右半数组)
arr[t] = aux[i++ - left];
} else if (aux[i - left].compareTo(aux[j - left]) < 0) {//如果i-left小,那么插入。(左半边数组的指针所指的数小)
arr[t] = aux[i++ - left];
} else { //如果j-left小,那么插入。(右半边数组的指针所指的数小)
arr[t] = aux[j++ - left];
}
}
} /**
* @param arr 当规模小的时候对arr采用插入排序
* @param left 待排序部分的左边界
* @param right 待排序部分的右边界
* @param <T> 泛型
*/
private static <T extends Comparable<? super T>> void insertionSort(T[] arr, int left, int right) {
for (int i = left + 1; i <= right; i++) {
T temp = arr[i];
int j = i - 1;
while (j >= 0 && temp.compareTo(arr[j]) < 0) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = temp;
}
} private static <T extends Comparable<? super T>> void sort(T[] arr, int left, int right) {
// 先注释掉,为了测试
// if (right - left < 7) { //对小规模数据进行插入排序
// insertionSort(arr, left, right);
// return;
// }
if (left >= right) {
return;
} int mid = (left + right) / 2;
sort(arr, left, mid);
sort(arr, mid + 1, right); //在归并前判断一下,如果左边的最大的比右边的最小的还小(或者等于),那就不用归并了,已经有序了。
if (arr[mid].compareTo(arr[mid + 1]) <= 0) {
return;
}
merge(arr, left, mid, right);
} public static <T extends Comparable<? super T>> void sort(T[] arr) {
sort(arr, 0, arr.length - 1);
} private static void printArr(Object[] arr) {
for (Object o : arr) {
System.out.print(o);
System.out.print("\t");
}
System.out.println();
} public static void main(String args[]) {
Integer[] arr = {3, 5, 1, 7, 2, 9, 8, 0, 4, 6};
printArr(arr);//3 5 1 7 2 9 8 0 4 6
sort(arr);
printArr(arr);//0 1 2 3 4 5 6 7 8 9
}
}  

归并排序继续优化:只在排序前开辟一次空间

public class MergeSort {
public static <T extends Comparable<? super T>> void sort(T[] arr) {
T[] aux = (T[]) new Comparable[arr.length];
sort(arr, aux, 0, arr.length - 1);
} private static <T extends Comparable<? super T>> void sort(T[] arr, T[] aux, int left, int right) {
if (right - left < 4) {
insertionSort(arr, left, right);
return;
}
// if (left >= right) {
// return;
// } int mid = (left + right) / 2;
sort(arr, aux, left, mid);
sort(arr, aux, mid + 1, right);
if (arr[mid].compareTo(arr[mid + 1]) > 0) {
merge(arr, aux, left, mid, right);
}
} private static <T extends Comparable<? super T>> void merge(T[] arr, T[] aux, int left, int mid, int right) {
System.arraycopy(arr, left, aux, left, right - left + 1); int i = left;
int j = mid + 1;
for (int t = left; t <= right; t++) {
if (i > mid) {
arr[t] = aux[j++];
} else if (j > right) {
arr[t] = aux[i++];
} else if (aux[i].compareTo(aux[j]) < 0) {
arr[t] = aux[i++];
} else {
arr[t] = aux[j++];
}
}
} private static <T extends Comparable<? super T>> void insertionSort(T[] arr, int left, int right) {
for (int i = left + 1; i <= right; i++) {
T temp = arr[i];
int j = i - 1;
while (j >= left && temp.compareTo(arr[j]) < 0) {
arr[j + 1] = arr[j--];
}
arr[j + 1] = temp;
}
} private static void printArr(Object[] arr) {
for (Object o : arr) {
System.out.print(o);
System.out.print("\t");
}
System.out.println();
} public static void main(String args[]) {
Integer[] arr = {3, 5, 1, 7, 2, 9, 8, 0, 4, 6};
printArr(arr);//3 5 1 7 2 9 8 0 4 6
sort(arr);
printArr(arr);//0 1 2 3 4 5 6 7 8 9
}
}

  

归并排序及优化(Java实现)的更多相关文章

  1. 怎么优化JAVA程序的执行效率和性能?

    现在java程序已经够快的了,不过有时写出了的程序效率就不怎么样,很多细节值得我们注意,比如使用StringBuffer或者StringBuilder来拼接或者操作字符串就比直接使用String效率高 ...

  2. Tomcat 优化 java.lang.OutOfMemoryError: Java heap space 的解决方法

    Tomcat 优化 java.lang.OutOfMemoryError: Java heap space 的解决方法 java.lang.OutOfMemoryError: Java heap sp ...

  3. jvm系列(十):如何优化Java GC「译」

    本文由CrowHawk翻译,是Java GC调优的经典佳作. 本文翻译自Sangmin Lee发表在Cubrid上的"Become a Java GC Expert"系列文章的第三 ...

  4. jvm系列(七):如何优化Java GC「译」

    本文由CrowHawk翻译,地址:如何优化Java GC「译」,是Java GC调优的经典佳作. Sangmin Lee发表在Cubrid上的”Become a Java GC Expert”系列文章 ...

  5. jvm系列(十):如何优化Java GC「

    转自:https://www.cnblogs.com/ityouknow/p/7653129.html 本文由CrowHawk翻译,地址:如何优化Java GC「译」,是Java GC调优的经典佳作. ...

  6. 归并排序(非递归,Java实现)

    归并排序(非递归):自底向上 public class MergeSort { /** * @param arr 待排序的数组 * @param left 本次归并的左边界 * @param mid ...

  7. MergeSort(归并排序)算法Java实现

    归并排序  归并排序 (merge sort) 是一类与插入排序.交换排序.选择排序不同的另一种排序方法.归并的含义是将两个或两个以上的有序表合并成一个新的有序表.归并排序有多路归并排序.两路归并排序 ...

  8. 冒泡排序优化JAVA

    本文对传统的冒泡排序进行了一些优化,减少了循环次数. 时间复杂度 若文件的初始状态是正序的,一趟扫描即可完成排序.所需的关键字比较次数 C 和记录移动次数 M 均达到最小值: C(min)=n-1 , ...

  9. 如何优化 Java 性能?

    对于 Java 性能比较关心的同学大概都知道<Java Performance>这本书,一般而言,很多同学在日常写 Java Code 的时候很少去关心性能问题,但是在我们写 Code 的 ...

随机推荐

  1. Docker系统八:Docker的存储驱动

    Docker存储驱动 1. Docker存储驱动历史 Docker目前支持的greph driver包括: AUFS device-mapper btrfs overlayfs(重点) 关于各存储驱的 ...

  2. AWS EC2 通过Linux终端:使用ssh连接到Linux实例

    AWS的ubuntu主机登录用户是ubuntu 只能通过秘钥的方式登录 如果在linux终端通过ssh远程登录步骤如下: 假如申请EC2主机的时候下载的key名称叫my-key.pem,并保存在本地l ...

  3. chrome使用Timeline做性能分析

    使用Timeline做性能分析 Timeline面板记录和分析了web应用运行时的所有活动情况,这是研究和查找性能问题的最佳途径.###Timeline面板概览 Timeline面板主要有三个部分构成 ...

  4. 1000多个项目中的十大JavaScript错误以及如何避免

    通过统计数据库中的1000多个项目,我们发现在 JavaScript 中最常出现的错误有10个.下面会向大家介绍这些错误发生的原因以及如何防止. 对于这些错误发生的次数,我们是通过收集的数据统计得出的 ...

  5. 浅谈this关键字

    在我学习this关键字的时候,通过查找资料总结出一些this的特殊用法, 供大家参考,代码里面有我总结的分析过程! 箭头函数里的this: var username = "全局"; ...

  6. Davinci DM6446开发攻略——linux-2.6.18移植

     TI DAVINCI 使用最新的内核是montavista linux-2.6.18,之前说过,国内很多公司,包括开发板的软件包,一直在使用montavista linux-2.6.10,这个版本准 ...

  7. Android 开发环境搭建与Hello World

    Hello World 到这里, 环境搭建就没问题了. 接下来, 创建一个Android 的Hello World. 1.  添加一个安卓虚拟设备 直接点击虚拟设备管理图标或是  Window--&g ...

  8. asp.net+jQueryRotate开发幸运大转盘

    在线抽奖程序在很多网站上很多,抽奖形式多种多样,Flash抽奖偏多,本文将给大家介绍jQuery转盘抽奖,结合代码实例将使用jQuery和asp.net来实现转盘抽奖程序,为了便于理解,文章贴出实现源 ...

  9. Openstack_O版(otaka)部署_准备环境和依赖软件

    架构介绍 本次案列为基本的三节点部署 一:网络: 1.管理网络:192.168.198.0/24 2.数据网络:10.0.0.0/24 二:操作系统: CentOS Linux release 7.3 ...

  10. Drying POJ - 3104

    It is very hard to wash and especially to dry clothes in winter. But Jane is a very smart girl. She ...