Java编程内功-数据结构与算法「归并排序」

开发 后端 算法
归并排序(merge-sort)是利用归并的思想实现的排序方法,该算法采用经典的分治(divide-and-conquer)策略(分治法将问题分(divide)成一些小的问题然后递归求解,而治(conquer)的阶段则将分的阶段得到的答案"修补"在一起,即分而治之).

[[393503]]

基本介绍

归并排序(merge-sort)是利用归并的思想实现的排序方法,该算法采用经典的分治(divide-and-conquer)策略(分治法将问题分(divide)成一些小的问题然后递归求解,而治(conquer)的阶段则将分的阶段得到的答案"修补"在一起,即分而治之).

示意图

说明:可以看到这种结构很像一颗完全二叉树,本文的归并排序我们采用递归去实现(也可以采用迭代的方式去实现).分阶段可以理解为就是递归拆分子序列的过程.

再来看看治阶段,我们需要将两个已经有序的子序列合并成一个有序序列,比如下图的最有一次合并,要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列,合并为最终序列[1,2,3,4,5,6,7,8],来看下实现步骤.

代码示例

  1. package com.structures.sort; 
  2.  
  3. blic class MergeSort { 
  4.   public static void main(String[] args) { 
  5.       int[] arr = new int[80000]; 
  6.       for (int i = 0; i < 80000; i++) { 
  7.           arr[i] = (int) (Math.random() * 8000000); 
  8.       } 
  9.       int[] temp = new int[arr.length]; 
  10.       long start = System.currentTimeMillis(); 
  11.  
  12.       mergeSort(arr,0,arr.length-1,temp); 
  13.       long end = System.currentTimeMillis(); 
  14.       System.out.println("耗时:" + ((end - start)) + "ms"); 
  15.       /* 
  16.       耗时:15ms 
  17.        */ 
  18.   } 
  19.  
  20.   //分+合 
  21.   public static void mergeSort(int[] arr, int leftint rightint[] temp) { 
  22.       if (left < right) { 
  23.           int mid = (left + right) / 2; 
  24.           //向左递归进行分解 
  25.           mergeSort(arr, left, mid, temp); 
  26.           //向右递归进行分解 
  27.           mergeSort(arr, mid + 1, righttemp); 
  28.           //合并 
  29.           merge(arr, left, mid, righttemp); 
  30.       } 
  31.   } 
  32.  
  33.   /** 
  34.    * 合并 
  35.    * @param arr   已排序的原始数组 
  36.    * @param left  左边有序序列的初始索引 
  37.    * @param mid   中间索引 
  38.    * @param right 右边索引 
  39.    * @param temp  做中转数组 
  40.    */ 
  41.   public static void merge(int[] arr, int leftint mid, int rightint[] temp) { 
  42.       int i = left;//初始化i,左边有序序列的初始索引 
  43.       int j = mid + 1;//初始化j,右边有序序列的初始索引 
  44.       int t = 0;//指向temp数组的当前索引 
  45.  
  46.       //(一) 
  47.       //先把左右两边(有序)的数据按照规则填充到temp数组 
  48.       //直到左右两边的有序序列,有一边处理完毕为止,即全部填充到temp数组 
  49.       while (i <= mid && j <= right) { 
  50.           //如果左边的有序序列小于等于右边的有序序列的当前元素 
  51.           //即将左边的当前元素拷贝到temp数组 
  52.           //然后t++,i++后移 
  53.           if (arr[i] <= arr[j]) { 
  54.               temp[t] = arr[i]; 
  55.               t += 1; 
  56.               i += 1; 
  57.           } else {//反之,将右边有序序列的当前元素,填充到temp数组 
  58.               temp[t] = arr[j]; 
  59.               t += 1; 
  60.               j += 1; 
  61.           } 
  62.       } 
  63.  
  64.       //(二) 
  65.       //把有剩余数据的一边的数据依次填充到temp 
  66.       while (i <= mid) {//左边的还有剩余,填充到temp数组 
  67.           temp[t] = arr[i]; 
  68.           t += 1; 
  69.           i += 1; 
  70.       } 
  71.       while (j <= right) { 
  72.           temp[t] = arr[j]; 
  73.           t += 1; 
  74.           j += 1; 
  75.       } 
  76.  
  77.       //(三) 
  78.       //将temp数组的元素拷贝到arr 
  79.       //注意并不是每次都拷贝所有 
  80.       //第一次合并leftTemp = 0,right = 1,第二次合并leftTemp = 2,right = 3,第三次合并leftTemp = 0,right = 3... 
  81.       t = 0; 
  82.       int leftTemp = left
  83.       while (leftTemp <= right) { 
  84.           arr[leftTemp] = temp[t]; 
  85.           leftTemp += 1; 
  86.           t += 1; 
  87.       } 
  88.   } 

 【编辑推荐】

 

责任编辑:姜华 来源: 今日头条
相关推荐

2021-03-23 08:33:22

Java数据结构算法

2021-04-22 10:07:45

Java数据结构算法

2021-04-15 09:36:44

Java数据结构算法

2021-03-09 06:30:32

JAVA数据结构算法

2021-04-13 09:37:41

Java数据结构算法

2021-03-18 08:44:20

Java数据结构算法

2021-05-12 09:07:09

Java数据结构算法

2021-03-10 08:42:19

Java数据结构算法

2021-03-08 06:28:57

JAVA数据结构与算法稀疏数组

2021-03-17 09:27:36

Java数据结构算法

2021-03-12 09:13:47

Java数据结构算法

2021-03-26 08:40:28

Java数据结构算法

2021-03-29 10:13:47

Java编程数据结构算法

2021-03-14 08:27:40

Java数据结构算法

2021-04-07 09:26:37

Java数据结构算法

2021-05-13 07:34:56

Java数据结构算法

2023-03-08 08:03:09

数据结构算法归并排序

2021-03-24 10:41:04

Java数据结构算法

2021-04-23 09:12:09

Java数据结构算法

2021-03-11 08:53:20

Java数据结构算法
点赞
收藏

51CTO技术栈公众号