归并排序（解析及代码实现）

最新推荐文章于 2025-06-26 11:22:49 发布

原创最新推荐文章于 2025-06-26 11:22:49 发布 · 566 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#归并排序 #排序算法 #Tag

常用的几种排序方法专栏收录该内容

6 篇文章

订阅专栏

本文深入讲解了归并排序算法的工作原理及其实现细节。通过递归分解数组为有序子数组，并逐步合并这些子数组来实现排序过程。介绍了适用于多种数据类型（如double、float等）的归并排序方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

//归并排序常用与排序组合俩个有序的数列，使之变成一个整体有序的序列
//对于俩个有序的序列，只需按顺序将第一个进行比较，大/小者按排序要求放在一个新得数列中
//对于一个无序的数列用归并排序时需要将整个数列分解成一个个有序的数列（分解为1）

//运用归并，使之有序，虽然归并排序的时间复杂度与快排一样是属于O(n*logn)级，但是需要额外空间复杂度O(n)

public static boolean mergeSort(double[] a, int low, int high, int type) {
		if(low>=high)
			return false;
		//将a[]分为俩瓣，不断分解，直至为1
		int mid=(low+high)/2;
		mergeSort(a, low, mid, type);//此函数执行完即low~mid区间排序完成
		mergeSort(a, mid+1, high, type);
		//合并
		merge(a,low,high,type);
		return true;
	}
	private static void merge(double[] a, int low, int high, int type) {
		//另请空间。储存排序完的数列
		double[] b=new double[high-low+1];
		int p=low;
		int mid=(low+high)/2;
		int r=mid+1;
		int k=0;
		while(p<=mid&&r<=high){
			if(a[p]<a[r]){
				if(type==0)//从小到大排
					b[k++]=a[p++];
				else//从大到小排
					b[k++]=a[r++];
			}else{
				if(type==0)
					b[k++]=a[r++];
				else
					b[k++]=a[p++];
			}
		}
		if(p>mid)//左边合并完，右边照搬
			while(r<=high)
				b[k++]=a[r++];
		else//右边合并完，左边照搬
			while(p<=mid)
				b[k++]=a[p++];
			
		//复制回去，是a[low]~a[high]有序
		for (int i = 0; i < b.length; i++) {
			a[low+i]=b[i];
		}
		
	}

//以下是完整代码，只是实现重载

package cn.hncu.sort;

public class MergeSort {

	//归并排序常用与排序组合俩个有序的数列，使之变成一个整体有序的序列
	//对于俩个有序的序列，只需按顺序将第一个进行比较，大/小者按排序要求放在一个新得数列中
	//对于一个无序的数列用归并排序时需要将整个数列分解成一个个有序的数列（分解为1）
	//运用归并，使之有序，虽然归并排序的时间复杂度与快排一样是属于O(n*logn)级，但是需要额外空间复杂度O(n)
	public static void mergeSort(double[] a){
		mergeSort(a,0);
	}
	public static void mergeSort(double[] a,int type){
		mergeSort(a,0,a.length-1,type);
	}
	public static boolean mergeSort(double[] a, int low, int high) {
		return mergeSort(a, low, high, 0);
	}
	public static boolean mergeSort(double[] a, int low, int high, int type) {
		if(low>=high)
			return false;
		//将a[]分为俩瓣，不断分解，直至为1
		int mid=(low+high)/2;
		mergeSort(a, low, mid, type);//此函数执行完即low~mid区间排序完成
		mergeSort(a, mid+1, high, type);
		//合并
		merge(a,low,high,type);
		return true;
	}
	private static void merge(double[] a, int low, int high, int type) {
		//另请空间。储存排序完的数列
		double[] b=new double[high-low+1];
		int p=low;
		int mid=(low+high)/2;
		int r=mid+1;
		int k=0;
		while(p<=mid&&r<=high){
			if(a[p]<a[r]){
				if(type==0)//从小到大排
					b[k++]=a[p++];
				else//从大到小排
					b[k++]=a[r++];
			}else{
				if(type==0)
					b[k++]=a[r++];
				else
					b[k++]=a[p++];
			}
		}
		if(p>mid)//左边合并完，右边照搬
			while(r<=high)
				b[k++]=a[r++];
		else//右边合并完，左边照搬
			while(p<=mid)
				b[k++]=a[p++];
			
		//复制回去，是a[low]~a[high]有序
		for (int i = 0; i < b.length; i++) {
			a[low+i]=b[i];
		}
		
	}
	//float[]数组
	public static void mergeSort(float[] a,int type){
		mergeSort(a,0,a.length-1,type);
	}
	public static void mergeSort(float[] a){
		mergeSort(a, 0);
	}
	public static boolean mergeSort(float[] a,int first,int end,int type){
		if(first<0)
			return false;
		if(end>=a.length)
			return false;
		if(first>end)
			return false;
		double[] b=new double[end-first+1];
		for (int i = 0; i < b.length; i++) {
			b[i]=a[i+first];
		}
		mergeSort(b, 0, b.length-1, type);
		for (int i = 0; i < b.length; i++) {
			a[i+first]=(float)b[i];
		}
		return true;
	}
	public static boolean mergeSort(float[] a,int first,int end) {
		return mergeSort(a, first, end, 0);
	}
	//long[]数组
	public static void mergeSort(long[] a,int type){
		mergeSort(a,0,a.length-1,type);
	}
	public static void mergeSort(long[] a){
		mergeSort(a, 0);
	}
	public static boolean mergeSort(long[] a,int first,int end,int type){
		if(first<0)
			return false;
		if(end>=a.length)
			return false;
		if(first>end)
			return false;
		double[] b=new double[end-first+1];
		for (int i = 0; i < b.length; i++) {
			b[i]=a[i+first];
		}
		mergeSort(b, 0, b.length-1, type);
		for (int i = 0; i < b.length; i++) {
			a[i+first]=(long)b[i];
		}
		return true;
	}
	public static boolean mergeSort(long[] a,int first,int end) {
		return mergeSort(a, first, end, 0);
	}
	//int[]数组
	public static void mergeSort(int[] a,int type){
		mergeSort(a, 0, a.length-1, type);
	}
	public static void mergeSort(int[] a){
		mergeSort(a, 0);
	}
	public static boolean mergeSort(int[] a,int first,int end,int type){
		if(first<0)
			return false;
		if(end>=a.length)
			return false;
		if(first>end)
			return false;
		double[] b=new double[end-first+1];
		for (int i = 0; i < b.length; i++) {
			b[i]=a[i+first];
		}
		mergeSort(b, 0, b.length-1, type);
		for (int i = 0; i < b.length; i++) {
			a[i+first]=(int)b[i];
		}
		return true;
	}
	public static boolean mergeSort(int[] a,int first,int end) {
		return mergeSort(a, first, end, 0);
	}
	//short[]数组
	public static void mergeSort(short[] a,int type){
		mergeSort(a, 0, a.length-1, type);
	}
	public static void mergeSort(short[] a){
		mergeSort(a, 0);
	}
	public static boolean mergeSort(short[] a,int first,int end,int type){
		if(first<0)
			return false;
		if(end>=a.length)
			return false;
		if(first>end)
			return false;
		double[] b=new double[end-first+1];
		for (int i = 0; i < b.length; i++) {
			b[i]=a[i+first];
		}
		mergeSort(b, 0, b.length-1, type);
		for (int i = 0; i < b.length; i++) {
			a[i+first]=(short)b[i];
		}
		return true;
	}
	public static boolean mergeSort(short[] a,int first,int end) {
		return mergeSort(a, first, end, 0);
	}
	//byte[]数组
	public static void mergeSort(byte[] a,int type){
		mergeSort(a, 0, a.length-1, type);
	}
	public static void mergeSort(byte[] a){
		mergeSort(a, 0);
	}
	public static boolean mergeSort(byte[] a,int first,int end,int type){
		if(first<0)
			return false;
		if(end>=a.length)
			return false;
		if(first>end)
			return false;
		double[] b=new double[end-first+1];
		for (int i = 0; i < b.length; i++) {
			b[i]=a[i+first];
		}
		mergeSort(b, 0, b.length-1, type);
		for (int i = 0; i < b.length; i++) {
			a[i+first]=(byte)b[i];
		}
		return true;
	}
	public static boolean mergeSort(byte[] a,int first,int end) {
		return mergeSort(a, first, end, 0);
	}
	//char[]数组
	public static void mergeSort(char[] a,int type){
		mergeSort(a, 0, a.length-1, type);
	}
	public static void mergeSort(char[] a){
		mergeSort(a, 0);
	}
	public static boolean mergeSort(char[] a,int first,int end,int type){
		if(first<0)
			return false;
		if(end>=a.length)
			return false;
		if(first>end)
			return false;
		double[] b=new double[end-first+1];
		for (int i = 0; i < b.length; i++) {
			b[i]=a[i+first];
		}
		mergeSort(b, 0, b.length-1, type);
		for (int i = 0; i < b.length; i++) {
			a[i+first]=(char)b[i];
		}
		return true;
	}
	public static boolean mergeSort(char[] a,int first,int end) {
		return mergeSort(a, first, end, 0);
	}
	//String[]数组
	public static void mergeSort(String[] a){
		mergeSort(a,0);
	}
	public static void mergeSort(String[] a,int type){
		mergeSort(a,0,a.length-1,type);
	}
	public static boolean mergeSort(String[] a, int low, int high) {
		return mergeSort(a, low, high, 0);
	}
	public static boolean mergeSort(String[] a, int low, int high, int type) {
		if(low>=high)
			return false;
		//将a[]分为俩瓣，不断分解，直至为1
		int mid=(low+high)/2;
		mergeSort(a, low, mid, type);//此函数执行完即low~mid区间排序完成
		mergeSort(a, mid+1, high, type);
		//合并
		merge(a,low,high,type);
		return true;
	}
	private static void merge(String[] a, int low, int high, int type) {
		//另请空间。储存排序完的数列
		String[] b=new String[high-low+1];
		int p=low;
		int mid=(low+high)/2;
		int r=mid+1;
		int k=0;
		while(p<=mid&&r<=high){
			if(a[p].compareTo(a[r])<0){
				if(type==0)//从小到大排
					b[k++]=a[p++];
				else//从大到小排
					b[k++]=a[r++];
			}else{
				if(type==0)
					b[k++]=a[r++];
				else
					b[k++]=a[p++];
			}
		}
		if(p>mid)//左边合并完，右边照搬
			while(r<=high)
				b[k++]=a[r++];
		else//右边合并完，左边照搬
			while(p<=mid)
				b[k++]=a[p++];
			
		//复制回去，是a[low]~a[high]有序
		for (int i = 0; i < b.length; i++) {
			a[low+i]=b[i];
		}
		
	}
	
	//输出
	private static void print(String[] a) {
		for (String x : a) {
			System.out.print(x+" ");
		}
		System.out.println();
	}
	private static void print(double[] a) {
		for (double x : a) {
			System.out.print(x+" ");
		}
		System.out.println();
	}
	private static void print(float[] a) {
		for (float x : a) {
			System.out.print(x+" ");
		}
		System.out.println();
	}
	private static void print(long[] a) {
		for (long x : a) {
			System.out.print(x+" ");
		}
		System.out.println();
	}
	private static void print(int[] a) {
		for (int x : a) {
			System.out.print(x+" ");
		}
		System.out.println();
	}
	private static void print(short[] a) {
		for (short x : a) {
			System.out.print(x+" ");
		}
		System.out.println();
	}
	private static void print(byte[] a) {
		for (byte x : a) {
			System.out.print(x+" ");
		}
		System.out.println();
	}
	private static void print(char[] a) {
		for (char x : a) {
			System.out.print(x+" ");
		}
		System.out.println();
	}
}