归并排序的JAVA实现

转自:http://blog.csdn.net/chenjin_zhong/article/details/6045659

——————————————————————————————————————————————

  1. public class MergeSort {
  2. /**
  3. * 归并排序
  4. * 简介:将两个(或两个以上)有序表合并成一个新的有序表 即把待排序序列分为若干个子序列,每个子序列是有序的。然后再把有序子序列合并为整体有序序列
  5. * 时间复杂度为O(nlogn)
  6. * 稳定排序方式
  7. * @param nums 待排序数组
  8. * @return 输出有序数组
  9. */
  10. public static int[] sort(int[] nums, int low, int high) {
  11. int mid = (low + high) / 2;
  12. if (low < high) {
  13. // 左边
  14. sort(nums, low, mid);
  15. // 右边
  16. sort(nums, mid + 1, high);
  17. // 左右归并
  18. merge(nums, low, mid, high);
  19. }
  20. return nums;
  21. }
  22. public static void merge(int[] nums, int low, int mid, int high) {
  23. int[] temp = new int[high - low + 1];
  24. int i = low;// 左指针
  25. int j = mid + 1;// 右指针
  26. int k = 0;
  27. // 把较小的数先移到新数组中
  28. while (i <= mid && j <= high) {
  29. if (nums[i] < nums[j]) {
  30. temp[k++] = nums[i++];
  31. } else {
  32. temp[k++] = nums[j++];
  33. }
  34. }
  35. // 把左边剩余的数移入数组
  36. while (i <= mid) {
  37. temp[k++] = nums[i++];
  38. }
  39. // 把右边边剩余的数移入数组
  40. while (j <= high) {
  41. temp[k++] = nums[j++];
  42. }
  43. // 把新数组中的数覆盖nums数组
  44. for (int k2 = 0; k2 < temp.length; k2++) {
  45. nums[k2 + low] = temp[k2];
  46. }
  47. }
  48. // 归并排序的实现
  49. public static void main(String[] args) {
  50. int[] nums = { 2, 7, 8, 3, 1, 6, 9, 0, 5, 4 };
  51. MergeSort.sort(nums, 0, nums.length-1);
  52. System.out.println(Arrays.toString(nums));
  53. }
  54. }
时间: 2024-10-12 21:27:36

归并排序的JAVA实现的相关文章

leecode 归并排序 链表(java)

写了好久,终于写成了.第一次zai leecode错题,题目质量很高,适合面试,与 1.归并排序是稳定的,在java中 Arrays.sort(a);中对于对象的排序就是归并排序.对于原子类型数据使用的是快排. 2.算法复杂度,我们都知道归并排序的最好最坏最差复杂度为nlogn,空间复杂度为n,在链表当中,空间复杂度j降为O(1). 3.写链表的排序 1.分: 使用书上的快慢指针来获得中间节点,分割成2个链表 2.和: 将两个链表合成一个,比较简单 3. 主程序 ListNode lmerge(

归并排序算法--java

归并排序(Merge)是将两个(或两个以上)有序表合并成一个新的有序表,即把待排序序列分为若干个子序列,每个子序列是有序的.然后再把有序子序列合并为整体有序序列. 归并排序是建立在归并操作上的一种有效的排序算法.该算法是采用分治法(Divide and Conquer)的一个非常典型的应用. 将已有序的子序列合并,得到完全有序的序列:即先使每个子序列有序,再使子序列段间有序.若将两个有序表合并成一个有序表,称为2-路归并. 归并排序算法稳定,数组需要O(n)的额外空间,链表需要O(log(n))

排序算法入门之归并排序(java实现)

归并排序是采用分治法的典型应用. 参考<数据结构与算法分析-Java语言描述> 归并排序其实要做两件事: (1)"分解"--将序列每次折半划分. (2)"合并"--合并两个已排序的表. 合并:对于两个输入数组A和B,一个输出数组C,以及3个计数器Actr.Bctr.Cctr,他们的初始置于对应数组的开始端.A[Actr]和B[Bctr]中较小的拷贝到C中的下一个位置,相关的计数器向前推进一步.当两个输入表有一个用完时,则将另一个表中剩余的部分拷贝到C中.

归并排序算法-Java实现

简介: 归并(Merge)排序法是将两个(或两个以上)有序表合并成一个新的有序表,即把待排序序列分为若干个子序列,每个子序列是有序的.然后再把有序子序列合并为整体有序 基本思想: 将一个无序数组,利用递归和分治的方法划分为最小半子集,最终划分为完全二叉树.然后对半子集进行排序并进行递归合并到最后. 复杂度分析: 时间复杂度为O(nlogn)  空间复杂度为O(n+logn)  两两比较,不存在跳跃,因此归并排序是一种稳定的排序算法  归并排序是一种比较占内存,但却效率高且稳定的算法 工作原理 (

排序算法-归并排序(Java)

package com.rao.sort; import java.util.Arrays; /** * @author Srao * @className MergeSort * @date 2019/12/7 10:24 * @package com.rao.sort * @Description 归并排序 */public class MergeSort { /** * 归并排序:递归写法 * @param arr:要排序的数组 * @param left:数组最左边的元素的下标 * @p

递归和迭代两种方式实现归并排序(Java版)

递归版 package MergeSort; import Utils.SortUtils; /** * 归并排序递归版 * @author liguodong */ public class Demo02 { public static void mergeSort(int[] a){ mSort(a, a, 0, a.length-1); } /** * * @param SR为待排序的数据 * @param TR1为排序之后的数据 * @param s * @param t */ publ

单向链表的归并排序(Java)

Sort a linked list in O(n log n) time using constant space complexity. 1 package SortList; 2 3 import java.util.Iterator; 4 5 class ListNode { 6 7 int val; 8 ListNode next; 9 ListNode(int val) { 10 this.val = val; 11 } 12 } 13 14 public class Solutio

归并排序模板(Java)

import java.util.Scanner; import java.io.BufferedInputStream; class Main{ static int N = (int) 1e5 + 10,len; static int[] q = new int[N],temp = new int[N]; static void mergeSort(int[] q,int l,int r){ if(l>=r) return; int mid=(l+r)>>1; mergeSort(q

Leetcode 148. Sort List 归并排序 in Java

148. Sort List Total Accepted: 81218 Total Submissions: 309907 Difficulty: Medium Sort a linked list in O(n log n) time using constant space complexity. /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; *