java 归并排序

归并排序,体现“分治法”的思想
import java.util.Arrays;

public class MergeSort {
public static void main(String[] args) {
	int [] a ={1,5,6,2,3,4,7,9,8};
	mergeSort(a,0,a.length-1);
	System.out.println("归并排序结果="+Arrays.toString(a));
}

private static void mergeSort(int[] a, int i, int j) {
	// TODO Auto-generated method stub
	int mid =(i+j)/2;
	if(i<j){
		mergeSort(a,i,mid);
		mergeSort(a,mid+1,j);
		merge(a,i,mid,j);
	}
}
private static void merge(int[] a, int low, int mid, int high) {
	// TODO Auto-generated method stub
	int i = low;
	int j = mid+1;
	int k =0;
	int[] tmp = new int[high-low+1]; //辅助数组
  while(i<=mid&&j<=high){
	  if(a[i]<a[j]){
		  tmp[k++] = a[i++];
	  }else{
		  tmp[k++] = a[j++];
	  }
  }
	  while(i<=mid){
		  tmp[k++] = a[i++];
	  }
	  while(j<=high){
		  tmp[k++] = a[j++];
	  }
  
  for(int x=0; x<tmp.length;x++){
	  a[low++] = tmp[x];
  }

}
}

### 归并排序的基本原理 归并排序是一种经典的排序算法,其核心思想是**分治法**。它通过将数组分成若干子序列,对每个子序列进行排序,然后再将它们合并为一个有序的序列。具体步骤包括: - **分解**:将待排序序列分成两个子序列。 - **解决**:递归地对两个子序列进行归并排序。 - **合并**:将两个有序的子序列合并成一个有序的序列。 归并排序具有稳定性和较好的时间复杂度,适用于大规模数据的排序。其时间复杂度为 $ O(N \log N) $,其中 $ N $ 是数据量。这是因为将数列分开成小数列一共要 $ \log N $ 步,每步都是一个合并有序数列的过程,时间复杂度为 $ O(N) $,因此总的时间复杂度为 $ O(N \log N) $。 ### Java 实现归并排序算法 以下是一个基于分治思想的 Java 实现示例: ```java public class MergeSort { // 主方法,用于启动归并排序 public static void mergeSort(int[] array) { if (array == null || array.length <= 1) { return; } mergeSort(array, 0, array.length - 1); } // 递归实现归并排序 private static void mergeSort(int[] array, int left, int right) { if (left >= right) { return; } int mid = (left + right) / 2; mergeSort(array, left, mid); // 对左半部分排序 mergeSort(array, mid + 1, right); // 对右半部分排序 merge(array, left, mid, right); // 合并两个有序部分 } // 合并两个子数组的方法 private static void merge(int[] array, int left, int mid, int right) { // 创建临时数组 int[] temp = new int[right - left + 1]; int i = left, j = mid + 1, k = 0; // 比较左右子数组元素,按顺序放入临时数组 while (i <= mid && j <= right) { if (array[i] <= array[j]) { temp[k++] = array[i++]; } else { temp[k++] = array[j++]; } } // 将剩余的左半部分元素复制到临时数组 while (i <= mid) { temp[k++] = array[i++]; } // 将剩余的右半部分元素复制到临时数组 while (j <= right) { temp[k++] = array[j++]; } // 将临时数组的元素复制回原数组 for (int p = 0; p < temp.length; p++) { array[left + p] = temp[p]; } } // 测试归并排序 public static void main(String[] args) { int[] data = {38, 27, 43, 3, 9, 82, 10}; System.out.println("排序前的数组:"); for (int num : data) { System.out.print(num + " "); } mergeSort(data); System.out.println("\n排序后的数组:"); for (int num : data) { System.out.print(num + " "); } } } ``` ### 归并排序的优化方法 归并排序在实现时可以进行一些优化,以进一步提高性能: - **小数组优化**:当子数组长度较小时,可以采用插入排序替代归并排序,因为插入排序在小规模数据上具有更低的常数因子。 - **避免额外空间拷贝**:可以通过交替使用主数组和辅助数组来减少数据拷贝的开销。 - **自然归并排序**:利用输入数据中已存在的有序段,减少分割步骤,提高效率。 ### 应用场景 归并排序由于其稳定的 $ O(N \log N) $ 时间复杂度,特别适用于: - **外部排序**:处理大规模数据,尤其是当数据存储在外部存储器(如硬盘)时。 - **链表排序**:归并排序适合链表结构,因为它不需要随机访问,而只需要顺序访问。 - **需要稳定排序的场景**:例如在数据库中对记录进行排序时,需要保持相同键值的原始顺序。 ### 优缺点分析 **优点**: - 时间复杂度稳定为 $ O(N \log N) $,适用于大规模数据。 - 是一种稳定排序算法,适合需要保持相同元素顺序的场景。 - 适用于链表结构的排序。 **缺点**: - 需要额外的存储空间,空间复杂度为 $ O(N) $。 - 对于小规模数据,效率不如插入排序等简单算法。 ### 归并排序的扩展 归并排序还可以扩展为**多路归并排序**,即每次将数组分成多个子序列进行排序,然后再合并。这种变体在处理分布式数据或外部排序时非常有用。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值