五十道编程小题目 --- 28 八大排序算法 java 之 07归并排序

最新推荐文章于 2024-08-27 00:08:39 发布
最新推荐文章于 2024-08-27 00:08:39 发布
阅读量1k 收藏 2
点赞数
分类专栏： 八大排序算法 五十道编程小算法 编程 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangnanwlw/article/details/52460119
版权


7. 归并排序（Merge Sort）


基本思想：

归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

归并排序示例：

 


合并方法：

设r[i…n]由两个有序子表r[i…m]和r[m+1…n]组成，两个子表长度分别为m+1-i 、n+1-m。

  1. j=m+1；k=i；i=i; //置两个子表的起始下标及辅助数组的起始下标
  2. 若i>m 或j>n，转⑷ //其中一个子表已合并完，比较选取结束
  3. //选取r[i]和r[j]较小的存入辅助数组rf
    如果r[i]<r[j]，rf[k]=r[i]； i++； k++； 转⑵
    否则，rf[k]=r[j]； j++； k++； 转⑵
  4. //将尚未处理完的子表中元素存入rf
    如果i<=m，将r[i…m]存入rf[k…n] //前一子表非空
    如果j<=n ,  将r[j…n] 存入rf[k…n] //后一子表非空
  5. 合并结束。
算法代码：（方法一，两个for循环） 
public class MergeSort2 {
	
	private static void mergeSort(int[] a) {
		double len = a.length;
		int time = (int)len >> 1; //相当于len/2 ，即归并的趟数

		for(int i=0; i<time; i++){
			int subLength = 1 << i; //相当于2的i次方 ，子序列的长度
			int subNum = (int) Math.ceil(len/((subLength+1)*(i+1))); //子序列数
			for(int j=0; j<subNum; j++){
				int a1_start = (int) (j*2*subLength< len ? j*2*subLength : len-1); //即下一组归并开始索引与上一组相差值
				int a2_start = (int) (a1_start+subLength < len ? a1_start+subLength : len-1);
				int a2_end = (int) ((a1_start+2*subLength-1) < len ? (a1_start+2*subLength-1): len-1); //防止最后一个越界
				
				merge(a, a1_start, a2_start, a2_end);
			}
			System.out.println("-------------归并排序后:-------------");
			print(a);
			System.out.println("************************************");
		}
			
			
	}
	
	//归并函数，传入的参数分别为：原数组，第一个字序列的开始索引，第二个字序列的开始索引，第二个字序列的结束索引
	private static void merge(int[] a, int a1_start, int a2_start, int a2_end){
		
		int len = a.length;
		int[] rf = new int[a2_end-a1_start+1]; 
				
		int i = a1_start, j = a2_start, k = 0;
		while( i<a2_start && j <= a2_end){
			if(a[i]<a[j]){
				rf[k] = a[i];
				i++;
				k++;
			}else{
				rf[k] = a[j];
				j++;
				k++;
			}
		}
		
		while(i<a2_start){
			rf[k] = a[i];
			k++;
			i++;
		}
		
		while(j <= a2_end){
			rf[k] = a[j];
			k++;
			j++;
		}
		
		//拷贝rf数组，到原数组  arraycopy(源数组，源数组开始索引，目标数组，目标数组开始索引，需要拷贝的长度);
		System.arraycopy(rf,0,a,a1_start,rf.length);
		
		print(a);
	}
	
	// 打印数组
		public static void print(int[] arr) {
			for (int i = 0; i < arr.length; i++) {
				System.out.print(arr[i] + " ");
			}
			System.out.println();
		}

		public static void main(String[] args) {

			int a[] = { 49, 38, 65, 97, 76, 13, 27};
			System.out.println("排序前  ： ");
			print(a);

			System.out.println("排序  ： ");
			mergeSort(a);
			print(a);
			
		}
}
输出结果： 
排序前  ： 
49 38 65 97 76 13 27 
排序  ： 
38 49 65 97 76 13 27 
38 49 65 97 76 13 27 
38 49 65 97 13 76 27 
38 49 65 97 13 76 27 
-------------归并排序后:-------------
38 49 65 97 13 76 27 
************************************
38 49 65 97 13 76 27 
38 49 65 97 13 27 76 
-------------归并排序后:-------------
38 49 65 97 13 27 76 
************************************
13 27 38 49 65 76 97 
-------------归并排序后:-------------
13 27 38 49 65 76 97 
************************************
13 27 38 49 65 76 97




归并的迭代算法(方法二)


1 个元素的表总是有序的。所以对n 个元素的待排序列，每个元素可看成1 个有序子表。对子表两两合并生成n/2个子表，所得子表除最后一个子表长度可能为1 外，其余子表长度均为2。再进行两两合并，直到生成n 个元素按关键码有序的表。

public class MergeSort {

	// private static long sum = 0;
    /**
     * <pre>
     * 二路归并
     * 原理：将两个有序表合并和一个有序表
     * </pre>
     * 
     * @param a
     * @param s
     * 第一个有序表的起始下标
     * @param m
     * 第二个有序表的起始下标
     * @param t
     * 第二个有序表的结束小标
     * 
     */
    private static void merge(int[] a, int s, int m, int t) {
        int[] tmp = new int[t - s + 1];
        int i = s, j = m, k = 0;
        while (i < m && j <= t) {
            if (a[i] <= a[j]) {
                tmp[k] = a[i];
                k++;
                i++;
            } else {
                tmp[k] = a[j];
                j++;
                k++;
            }
        }
        while (i < m) {
            tmp[k] = a[i];
            i++;
            k++;
        }
        while (j <= t) {
            tmp[k] = a[j];
            j++;
            k++;
        }
        System.arraycopy(tmp, 0, a, s, tmp.length);
        print(a);
        
    }
    /**
     * 
     * @param a
     * @param s
     * @param len
     * 每次归并的有序集合的长度
     */
    public static void mergeSort(int[] a, int s, int len) {
        int size = a.length;
        int mid = size / (len << 1);  // size/(len*2)
        int c = size & ((len << 1) - 1); // 判断数组长度奇偶数
        // -------归并到只剩一个有序集合的时候结束算法-------//
        if (mid == 0)
            return;
        // ------进行一趟归并排序-------//
        for (int i = 0; i < mid; ++i) {
            s = i * 2 * len;
            merge(a, s, s + len, (len << 1) + s - 1);
        }
        // -------将剩下的数和倒数一个有序集合归并-------//
        if (c != 0)
            merge(a, size - c - 2 * len, size - c, size - 1);
        // -------递归执行下一趟归并排序------//
        mergeSort(a, 0, 2 * len);
    }
    
    public static void main(String[] args) {
        int[] a = new int[] {49, 38, 65, 97, 76, 13, 27 };
        mergeSort(a, 0, 1);
        for (int i = 0; i < a.length; ++i) {
            System.out.print(a[i] + " ");
        }
    }
    
 // 打印数组
 	public static void print(int[] arr) {
 		for (int i = 0; i < arr.length; i++) {
 			System.out.print(arr[i] + " ");
 		}
 		System.out.println();
 	}
	
}

输出结果： 

38 49 65 97 76 13 27 
38 49 65 97 76 13 27 
38 49 65 97 13 76 27 
38 49 65 97 13 27 76 
38 49 65 97 13 27 76 
13 27 38 49 65 76 97 
13 27 38 49 65 76 97

7. 归并排序（Merge Sort）


基本思想：

归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

归并排序示例：

 


合并方法：

设r[i…n]由两个有序子表r[i…m]和r[m+1…n]组成，两个子表长度分别为m+1-i 、n+1-m。

  1. j=m+1；k=i；i=i; //置两个子表的起始下标及辅助数组的起始下标
  2. 若i>m 或j>n，转⑷ //其中一个子表已合并完，比较选取结束
  3. //选取r[i]和r[j]较小的存入辅助数组rf
    如果r[i]<r[j]，rf[k]=r[i]； i++； k++； 转⑵
    否则，rf[k]=r[j]； j++； k++； 转⑵
  4. //将尚未处理完的子表中元素存入rf
    如果i<=m，将r[i…m]存入rf[k…n] //前一子表非空
    如果j<=n ,  将r[j…n] 存入rf[k…n] //后一子表非空
  5. 合并结束。
算法代码：（方法一，两个for循环） 

public class MergeSort2 {
	
	private static void mergeSort(int[] a) {
		double len = a.length;
		int time = (int)len >> 1; //相当于len/2 ，即归并的趟数

		for(int i=0; i<time; i++){
			int subLength = 1 << i; //相当于2的i次方 ，子序列的长度
			int subNum = (int) Math.ceil(len/((subLength+1)*(i+1))); //子序列数
			for(int j=0; j<subNum; j++){
				int a1_start = (int) (j*2*subLength< len ? j*2*subLength : len-1); //即下一组归并开始索引与上一组相差值
				int a2_start = (int) (a1_start+subLength < len ? a1_start+subLength : len-1);
				int a2_end = (int) ((a1_start+2*subLength-1) < len ? (a1_start+2*subLength-1): len-1); //防止最后一个越界
				
				merge(a, a1_start, a2_start, a2_end);
			}
			System.out.println("-------------归并排序后:-------------");
			print(a);
			System.out.println("************************************");
		}
			
			
	}
	
	//归并函数，传入的参数分别为：原数组，第一个字序列的开始索引，第二个字序列的开始索引，第二个字序列的结束索引
	private static void merge(int[] a, int a1_start, int a2_start, int a2_end){
		
		int len = a.length;
		int[] rf = new int[a2_end-a1_start+1]; 
				
		int i = a1_start, j = a2_start, k = 0;
		while( i<a2_start && j <= a2_end){
			if(a[i]<a[j]){
				rf[k] = a[i];
				i++;
				k++;
			}else{
				rf[k] = a[j];
				j++;
				k++;
			}
		}
		
		while(i<a2_start){
			rf[k] = a[i];
			k++;
			i++;
		}
		
		while(j <= a2_end){
			rf[k] = a[j];
			k++;
			j++;
		}
		
		//拷贝rf数组，到原数组  arraycopy(源数组，源数组开始索引，目标数组，目标数组开始索引，需要拷贝的长度);
		System.arraycopy(rf,0,a,a1_start,rf.length);
		
		print(a);
	}
	
	// 打印数组
		public static void print(int[] arr) {
			for (int i = 0; i < arr.length; i++) {
				System.out.print(arr[i] + " ");
			}
			System.out.println();
		}

		public static void main(String[] args) {

			int a[] = { 49, 38, 65, 97, 76, 13, 27};
			System.out.println("排序前  ： ");
			print(a);

			System.out.println("排序  ： ");
			mergeSort(a);
			print(a);
			
		}
}
输出结果： 
排序前  ： 
49 38 65 97 76 13 27 
排序  ： 
38 49 65 97 76 13 27 
38 49 65 97 76 13 27 
38 49 65 97 13 76 27 
38 49 65 97 13 76 27 
-------------归并排序后:-------------
38 49 65 97 13 76 27 
************************************
38 49 65 97 13 76 27 
38 49 65 97 13 27 76 
-------------归并排序后:-------------
38 49 65 97 13 27 76 
************************************
13 27 38 49 65 76 97 
-------------归并排序后:-------------
13 27 38 49 65 76 97 
************************************
13 27 38 49 65 76 97




归并的迭代算法(方法二)


1 个元素的表总是有序的。所以对n 个元素的待排序列，每个元素可看成1 个有序子表。对子表两两合并生成n/2个子表，所得子表除最后一个子表长度可能为1 外，其余子表长度均为2。再进行两两合并，直到生成n 个元素按关键码有序的表。

public class MergeSort {

	// private static long sum = 0;
    /**
     * <pre>
     * 二路归并
     * 原理：将两个有序表合并和一个有序表
     * </pre>
     * 
     * @param a
     * @param s
     * 第一个有序表的起始下标
     * @param m
     * 第二个有序表的起始下标
     * @param t
     * 第二个有序表的结束小标
     * 
     */
    private static void merge(int[] a, int s, int m, int t) {
        int[] tmp = new int[t - s + 1];
        int i = s, j = m, k = 0;
        while (i < m && j <= t) {
            if (a[i] <= a[j]) {
                tmp[k] = a[i];
                k++;
                i++;
            } else {
                tmp[k] = a[j];
                j++;
                k++;
            }
        }
        while (i < m) {
            tmp[k] = a[i];
            i++;
            k++;
        }
        while (j <= t) {
            tmp[k] = a[j];
            j++;
            k++;
        }
        System.arraycopy(tmp, 0, a, s, tmp.length);
        print(a);
        
    }
    /**
     * 
     * @param a
     * @param s
     * @param len
     * 每次归并的有序集合的长度
     */
    public static void mergeSort(int[] a, int s, int len) {
        int size = a.length;
        int mid = size / (len << 1);  // size/(len*2)
        int c = size & ((len << 1) - 1); // 判断数组长度奇偶数
        // -------归并到只剩一个有序集合的时候结束算法-------//
        if (mid == 0)
            return;
        // ------进行一趟归并排序-------//
        for (int i = 0; i < mid; ++i) {
            s = i * 2 * len;
            merge(a, s, s + len, (len << 1) + s - 1);
        }
        // -------将剩下的数和倒数一个有序集合归并-------//
        if (c != 0)
            merge(a, size - c - 2 * len, size - c, size - 1);
        // -------递归执行下一趟归并排序------//
        mergeSort(a, 0, 2 * len);
    }
    
    public static void main(String[] args) {
        int[] a = new int[] {49, 38, 65, 97, 76, 13, 27 };
        mergeSort(a, 0, 1);
        for (int i = 0; i < a.length; ++i) {
            System.out.print(a[i] + " ");
        }
    }
    
 // 打印数组
 	public static void print(int[] arr) {
 		for (int i = 0; i < arr.length; i++) {
 			System.out.print(arr[i] + " ");
 		}
 		System.out.println();
 	}
	
}

输出结果： 

38 49 65 97 76 13 27 
38 49 65 97 76 13 27 
38 49 65 97 13 76 27 
38 49 65 97 13 27 76 
38 49 65 97 13 27 76 
13 27 38 49 65 76 97 
13 27 38 49 65 76 97

秋夫人
关注
专栏目录
归并排序（手写）
loi_王振东
08-06 569
题目： 给定你一个长度为 n 的整数数列。 请你使用归并排序对这个数列按照从小到大进行排序。 并将排好序的数列按顺序输出。 输入格式： 输入共两行，第一行包含整数 n。 第二行包含 n 个整数（所有整数均在 1∼109 范围内），表示整个数列。 输出格式： 输出共一行，包含 n 个整数，表示排好序的数列。 数据范围 1 ≤ n≤ 100000 输入样例： 5 3 1 2 4 5 输出样例： 1 2 3 4 5 #include<bits/stdc++.h> using namespace std
归并排序练习题
weixin_64565994的博客
12-06 1013
归并排序的题目总结
归并排序与其例题
最新发布
admin_zbn的博客
08-27 742
归并排序的基本流程是递归地将数组分成两半，分别对这两半进行排序，然后将它们合并成一个有序数组。该代码实现了归并排序的这一过程，通过分割、排序和合并三个主要步骤来完成数组的排序。那上面的代码就是归并排序的模板，和快速排序一样要理解与记忆，当涉及到归并排序时，就可以用这个模板。三、实战例题给定一个长度为 n的整数数列，请你计算数列中的逆序对的数量。逆序对的定义如下：对于数列的第 i 个和第 j个元素，如果满足 i<j 且 a[i]>a[j]，则其为一个逆序对；否则不是。
归并排序（模板题）
matafeiyanll的博客
06-25 386
归并排序（模板题） 给定你一个长度为n的整数数列。 请你使用归并排序对这个数列按照从小到大进行排序。 并将排好序的数列按顺序输出。 输入格式 输入共两行，第一行包含整数 n。 第二行包含 n 个整数（所有整数均在1~109 范围内），表示整个数列。 输出格式 输出共一行，包含 n 个整数，表示排好序的数列。 数据范围 1≤n≤100000 输入样例： 5 3 1 2 4 5 输出样例： 1 2 3 4 5 代码模板 void merge_sort(int q[], int l, int r) {
算法练习——归并排序
weixin_30751947的博客
08-07 133
归并排序的基本思路利用分治方法解决。 分治模式的每一层递归都有三个思路： 分解原问题为若干子问题，这些子问题是原问题的规模较小的实例。解决这些子问题，递归地求解各子问题。然而，若子问题的规模足够小，则直接求解．合并这些子问题的解成原问题的解。 归并排序算法完全遵循分治模式。直观上其操作如下：分解：分解待排序的拧个元素的序列成各具n/2个元素的两个子序列。解决：使用归并排序递归地排序...
归并排序和一些例题
weixin_46272350的博客
01-24 1722
归并排序的原理并不是很复杂，他的意思是说，将一个数组从中间分解成左右两个部分，然后对左右两部分分别排序，将排序后的结果再进行合并。 我们先来讨论经典的递归实现方法。 归并排序的递归实现可以总结为：左边排好序+右边排好序+merge让总体有序 这个问题最大的困难就是如何进行合并merge,我们通过画递归树可以知道，最后一定是一个元素和一个元素进行的merge,那么这个merge的过程还需要涉及到对这两个元素进行比较，那么如何去实现呢？ 这里我们采用双指针法和辅助数组的方式，首先创建一个辅助数组，左右两
用Java实现基础数据结构，排序算法、经典算法以及leetcode刷题记录-Java-下载.zip
09-15
在本压缩包“用Java实现基础数据结构，排序算法、经典算法以及leetcode刷题记录-Java-下载.zip”中，包含的是一个Java编程项目，主要目的是通过代码实践来理解和掌握数据结构、排序算法以及经典的计算机算法。...
java-classical-algorithm.zip_40_Java编程题_java算法
09-23
排序算法可能包括经典的冒泡排序、选择排序、插入排序，以及更高效的快速排序、归并排序和堆排序。搜索算法则可能包含线性搜索、二分搜索，以及图和树结构中的深度优先搜索（DFS）和广度优先搜索（BFS）。 其次，...
interview-algorithms-java:面试准备的算法问题，java版本
06-25
- **分治**：将大问题分解为小问题，如快速排序、归并排序、大整数乘法等。 4. **动态规划**： - **背包问题、最长公共子序列、最长递增子序列**：通过构建状态转移矩阵解决优化问题，避免重复计算。 5. **图论*...
b数源码java-BookCode:程序员代码面试指南：IT名企算法与数据结构题目最优解（第2版）书上
05-20
- **分治法**：将大问题分解为小问题，如快速排序、归并排序。 在实际的面试中，你可能会遇到的问题可能涵盖这些数据结构和算法的使用场景，比如如何在给定的数组中寻找两个数使得它们的和等于特定的目标值（两数...
algo-java:算法面试 Java 解决方案
06-26
LeetCode是一个在线平台，它提供了大量的编程题目，涵盖数据结构和算法的各个领域，对于Java程序员来说，理解和掌握这些题目能够提升他们在实际工作中解决问题的能力。 Java是一种广泛使用的面向对象的编程语言，以...
编程练习题（2）- 插入排序、快速排序、归并排序
dongbo4061的专栏
11-22 376
注：参考KhanAcademy。 续(1)题目3：希尔排序、堆排序后面再补上。冒泡排序就不写了。 给一组整数，按照升序排序，使用选择排序，冒泡排序，插入排序或者任何 O(n2) 的排序算法。 插入排序(Insertion Sort) (用插纸牌来理解很容易，每来一张新的牌，要插入到原来已经排好序的牌中。对于数组而言，中间插入一个新的元素，则右边本来的元素需要往右移...
归并排序及练习题
yw_2022的博客
07-08 755
归并排序
排序问题——归并/快速/堆排序问题
庄小焱
02-15 596
博文主要介绍归并算法的原理和相关练习题目。
【算法题】归并排序
xiaxzhou的博客
06-02 443
void Merge(int* array, int left, int mid, int right) { int len_l = mid - left+1; int len_r = right - mid; int * array_l = new int[len_l]; int * array_r = new int[len_r]; for (auto i
一道归并排序题的解析
HuangQinJian
12-17 3051
设有字母序列{Q,D,F,X,A,P,N,B,Y,M,C,W}，请写出按二路归并方法对该序列进行一趟扫描后的结果为 （）。
归并排序题
QinHebtu的博客
10-08 257
原题：Ultra-QuickSort 题目内容： 在这个问题中，你需要分析特别的算法。这个算法通过对一个包含n个元素的进行操作，一直交换相邻的两个序列的元素直到整个序列呈升序排列。对于输入序列9 1 0 5 4 ,Ultra-QuickSort最终得到的输出为0 1 4 5 9 .你的任务就是来计算出Ultra-QuickSort 至少需要多少swap操作来最终达到对一个给定的输入序列排好序的目标。 输入格式: 输入包括多组测试数据。每组测试数据以一行包括一个单独的整数n开始（n<500,000,是输
编程练习：归并排序
shuizhonglinsname的专栏
06-03 616
#include #include /*assert()*/ #include /*malloc()*/ #include /*memmove(), memset()*/ void Merge(int a[], int r[], int b, int m, int e) { int j, k; for( j = m+1,k = b; k <= e; ++k ) { if(
掌握java算法源码，提升编程能力
2. 排序算法，如快速排序、归并排序、堆排序、冒泡排序、插入排序等，这些是基本算法能力的重要体现。 3. 搜索算法，包括线性搜索、二分搜索等。 4. 动态规划、贪心算法、分治算法、回溯算法等高级算法。 5. 字符串...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值