归并排序算法的原理及JAVA实现
归并排序是利用递归和分而治之的技术将数据序列划分成为越来越小的半子表，再对半子表排序，最后再用递归步骤将排好序的半子表合并成为越来越大的有序序列，归并排序包括两个步骤，分别为：
1）划分子表
2）合并半子表
首先我们来讨论归并算法，归并算法将一系列数据放到一个向量中，索引范围为[first,last],这个序列由两个排好序的子表构成，以索引终点（mid）为分界线，以下面一个序列为例
7，10，19，25，12，17，21，30，48
这样的一个序列中，分为两个子序列 7,10,19,25 和 12,17,21,30,48，如下图所示：
再使用归并算法的时候的步骤如下：
第一步：比较v[indexA]=7和v[indexB]=12,将较小的v[indexA]取出来放到临时向量tempArray中，然后indexA加1
第二步：比较v[indexA]=10和v[indexB]=12,将较小的10放到临时变量tempArray中，然后indexA++;
第三步：比较v[indexA]=19与v[indexB]=12，将较小的12存放到临时变量tempArray中，然后indexB++;
第四步到第七步：按照以上规则，进行比对和存储，得到如下结果：
最后一步：将子表b中剩余项添加到临时向量tempArray中
然后将临时变量中的值按照索引位置，拷贝回向量v中，就完成了对向量v 的归并排序
Java实现代码：
package com.sort.merge;
public class Merge {
/**
* 分治法,自顶向下，递归分割数组，最终归并
*/
public static void merge(int[] arr,int start,int end){
if(start int mid = (start+end)/2; merge(arr,start,mid);//递归地对arr[start...mid]排序 merge(arr,mid+1,end);//递归地对arr[mid+1...end]排序 doMerge(arr,start,mid,end);//组合，将两个有序区合并为一个有序区} } //组合，归并 public static void doMerge(int[] arr,int start,int mid,int end){ int tempIndex = start; int Index = start; int right = mid + 1; int temp[] = new int[arr.length]; //两个子序列比较，小的放入临时数组 while(start <= mid && right <= end){ if(arr[start] <= arr[right]){ temp[tempIndex++] = arr[start++]; }else{ temp[tempIndex++] = arr[right++]; } } //剩下的右边的元素加入临时数组 while(start <= mid){ temp[tempIndex++] = arr[start++]; } //剩下的右边的元素加入临时数组 while(right <= end){ temp[tempIndex++] = arr[right++]; } //复制临时数据temp[]中的数据到arr[]数组 while(Index < end){ arr[Index] = temp[Index++]; } } public static void main(String[] args) { // TODO Auto-generated method stub int arr[] = {2,4,6,8,1,3,5,9}; merge(arr,0,arr.length-1); for (int i = 0; i < arr.length; i++) { System.out.print(arr[i]); } } } 采用分治法进行自顶向下的算法设计，形式更为简洁。 （1）分治法的三个步骤 设归并排序的当前区间是R[low..high]，分治法的三个步骤是： ①分解：将当前区间一分为二，即求分裂点 ②求解：递归地对两个子区间R[low..mid]和R[mid+1..high]进行归并排序； ③组合：将已排序的两个子区间R[low..mid]和R[mid+1..high]归并为一个有序的区间R[low..high]。 递归的终结条件：子区间长度为1（一个记录自然有序）。 （2）具体算法 void MergeSortDC(SeqList R，int low，int high) {//用分治法对R[low..high]进行二路归并排序 int mid； if(low mid=(low+high)/2； //分解 MergeSortDC(R，low，mid); //递归地对R[low..mid]排序 MergeSortDC(R，mid+1，high)； //递归地对R[mid+1..high]排序 Merge(R，low，mid，high)； //组合，将两个有序区归并为一个有序区} }//MergeSortDC #include count++; }//满足条件，前移 if(count==0) break;//位置恰当，退出 } } }//insort插入排序函数 selsort(int a[30001]) { int i,j,temp; for(i=1;i<30000;i++) for(j=i+1;j<30001;j++) if(a[i]>a[j]) { temp=a[j]; a[j]=a[i]; a[i]=temp; } }//选择排序 bubsort(int a[30001]) { int i,j,temp; for(i=1;i<30001;i++) for(j=30000;j>i;j--) { if(a[j-1]>a[j]) { temp=a[j-1]; a[j-1]=a[j]; a[j]=temp; } } }//冒泡排序 int partition(int a[30001],int low,int high) import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List; import java.util.Random; public class GuiBing { public static void main(String[] args) throws Exception { int datalength=1000000; GuiBing gui=new GuiBing(); int[] array1=gui.createArray(datalength); int[] array2=gui.createArray(datalength); Thread.sleep(20000); long startTime = System.nanoTime();//纳秒精度 long begin_freeMemory=Runtime.getRuntime().freeMemory(); int[] final_array=gui.guibing(array1,array2); boolean result=gui.testResult(final_array); long end_freeMemory=Runtime.getRuntime().freeMemory(); System.out.println("result===="+result); long estimatedTime = System.nanoTime() - startTime; System.out.println("elapsed time(纳秒精 度):"+estimatedTime/100000000.0); System.out.println("allocated memory:"+(begin_freeMemory-end_freeMemory)/1000.0+" KB"); Thread.sleep(20000); } /** * 显示数组的内容 * @param array */ private static void dispalyData(int[] array) { for(int i=0;i java程序员必学的十种程序算法 算法1：快速排序算法 快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。 快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。 算法步骤： 1 从数列中挑出一个元素，称为“基准”（pivot）， 2 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。 3 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。 递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。 算法2：堆排序算法 堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。 堆排序的平均时间复杂度为Ο(nlogn) 。 算法步骤： 创建一个堆H[0..n-1] 把堆首（最大值）和堆尾互换 3. 把堆的尺寸缩小1，并调用shift_down(0),目的是把新的数组顶端数据调整到相应位置 4. 重复步骤2，直到堆的尺寸为1 算法3：归并排序 归并排序（Merge sort，台湾译作：合并排序）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。 算法步骤： 归并排序算法实现（迭代和递归）\递归实现归并排序的原理如下： 递归分割: 递归到达底部后排序返回: 最终实现排序： #include } while(i 冒泡排序法 1.public class SortArray_01 { 2. public static void main(String args[]) { 3. int[] array = { 14, 5, 86, 4, 12, 3, 21, 13, 11, 2, 55 }; // 创建一个初始化的一维数组array 4. System.out.println("未排序的数组:"); 5. for (int i = 0; i < array.length; i++) { // 遍历array数组中的元素 6. System.out.print(" " + array[i]); // 输出数组元素 7. if ((i + 1) % 5 == 0) // 每5个元素一行 8. System.out.println(); 9. } 10. int mid; // 定义一个中间变量， 起到临时存储数据的作用 11. for (int i = 0; i < array.length; i++) { // 执行冒 泡排序法 12. for (int j = i; j < array.length; j++) { 13. if (array[j] < array[i]) { 14. mid = array[i]; 15. array[i] = array[j]; 16. array[j] = mid; 17. } 18. } 19. } 20. System.out.println("\n使用冒泡法排序后的数组:"); 21. for (int i = 0; i < array.length; i++) { // 遍历排好序的array数组中的元素 22. System.out.print(" " + array[i]); // 输出数组元素 23. if ((i + 1) % 5 == 0) 24. System.out.println(); // 每5 个元素一行 25. } 26. } 27.} 数组递增排序 JAVA中在运用数组进行排序功能时，一般有四种方法：快速排序法、冒泡法、选择排序法、插入排序法。 快速排序法主要是运用了Arrays中的一个方法Arrays.sort（）实现。 冒泡法是运用遍历数组进行比较，通过不断的比较将最小值或者最大值一个一个的遍历出来。 选择排序法是将数组的第一个数据作为最大或者最小的值，然后通过比较循环，输出有序的数组。 插入排序是选择一个数组中的数据，通过不断的插入比较最后进行排序。下面我就将他们的实现方法一一详解供大家参考。 <1>利用Arrays带有的排序方法快速排序 import java.util.Arrays; publicclass Test2{ publicstaticvoid main(String[] args){ int[] a={5,4,2,4,9,1}; Arrays.sort(a); //进行排序 for(int i: a){ System.out.print(i); } } } <2>冒泡排序算法 publicstaticint[] bubbleSort(int[] args){//冒泡排序算法 for(int i=0;i 实验名称归并排序分治策略的设计与实现实验方案实验成绩实验日期实验室信息系统设计与仿真室I 实验操作 实验台号班级姓名实验结果 一、实验目的 1、熟悉分治法求解问题的抽象控制策略； 2、熟悉在顺序存储表示下求解分类问题的递归算法设计； 3、通过实例转换, 掌握分治法应用。 二、实验任务 ①从文件中读取数据信息； ②利用归并排序算法，进行排序； ③输出排序结果。 三、实验设计方案 1、结构体设计 用数组存放排序数据。 2、自定义函数设计 ①函数原型声明 int input(int A[]); //从文件读入待排序的数据 void merge(int A[],int low,int mid,int high); // 两个相邻有序数组的归并 void mergesort(int A[],int low,int high); // 归并排序 void input(int A[], int n); // 输出排序结果 ②两个相邻的有序子数组的合并 思路：从两个已排好序的子数组的首元素开始，依次比较大小，按从小到大的顺序存放在b[]数组中，然后转存到A[]数组中。 void merge(int A[],int low,int mid,int high) { int b[N]; int i,j,k = 0; int l = low; //已排序部分1的起始下标 int h = mid+1; //已排序部分2的起始下标 while(l <= mid && h <= high) //两个有序部分合并到b数组中 if(A[l] < A[h]) b[k++] = A[l++]; else Java程序员必知的8大排序本文主要详解了Java语言的8大排序的基本思想以及实例解读，详细请看下文8种排序之间的关系: 1，直接插入排序 （1）基本思想：在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排 好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数 也是排好顺序的。如此反复循环，直到全部排好顺序。 （2）实例 （3）用java实现 1.package com.njue; 2. 3.public class insertSort { 4.public insertSort(){ 5. inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17, 18,23,34,15,35,25,53,51}; 6.int temp=0; 7.for(int i=1;i 算法分析与设计实验报告第二次实验 对于归并排序，在之前的数据结构已经学过了，本来以为代码实现起来会比较 附录： 完整代码（分治法） #include { for(int last=i;last<=mid;last++) { B[k++]=A[last]; } } } void mergesort(int a[],int b[],int left,int right) //分治法实现归并排序，利用递归实现{ if(left 关于多路归并排序外部排序败者树技术积累2009-11-24 21:52:06 阅读453 评论0 字号：大中小 编程珠玑第一个case是有关一个技巧性解决外部排序问题的。问题很巧妙的解决了，但一开始提到的利用归并排序进行外部排序的算法仍值得仔细探究一下，毕竟本科时学的不是很深入。 先来看内部排序中最简单的2路归并排序算法。 算法核心操作是将一维数组中前后相邻的两个有序序列归并为一个有序序列，给定数组中序列界限i、m、n，用2个下标变量分别从i和j=m+1开始逐个往后处理，先比较，小的写到结果序列的当前遍历下标k中，相应下标自增继续比较直到某个序列的下标走到边界，再将另外一个序列的剩余元素拷贝到结果序列中。 算法可用递归或递推实现，从相邻的两两元素开始不断调用上面的核心操作组成较长有序序列直到完成整个序列。 算法进行一趟归并就得到一个局部有序的完整新序列，n个元素共需要log2n趟归并，每趟完成比较操作n次（1次得到序列的1个值），得到的新序列写到结果序列空间中，下一趟之前要先将结果序列复制一份到临时空间，下一趟归并在临时空间上进行。因此时间复杂度nlog2n，空间上除了原始序列空间n、结果序列空间n，还需要辅助临时空间n。 接下来看外部排序。外部排序指的是大文件的排序，即待排序的记录存储在外存储器上，待排序的文件无法一次装入内存，需要在内存和外部存储器之间进行多次数据交换，以达到排序整个文件的目的。外部排序最常用的算法是多路归并排序，即将原文件分解成多个能够一次性装入内存的部分，分别把每一部分调入内存完成排序。然后，对已经排序的子文件进行多路归并排序。 多路归并排序算法在常见数据结构书中都有涉及。从2路到多路（k路），增大k可以减少外存信息读写时间，但k个归并段中选取最小的记录需要比较k-1次，为得到u个记录的一个有序段共需要(u-1)(k-1)次，若归并趟数为s次，那么对n个记录的文件进行外排时，内部归并过程中进行的总的比较次数为s(n-1)(k-1)，也即(向上取整)(logkm)(k-1)(n-1)=(向上取整)(log2m/log2k)(k-1)(n-1)，而(k-1)/log2k随k增而增因此内部归并时间随k增长而增长了，抵消了外存读写减少的时间，这样做不行，由此引出了“败者树”tree of loser的使用。在内部归并过程中利用败者树将k个归并段中选取最小记录比较的次数降为(向上取整)(log2k)次使总比较次数为(向上取整)(log2m)(n-1)，与k无关。 败者树是完全二叉树，因此数据结构可以采用一维数组。其元素个数为k个叶子结点、k-1个比较结点、1个冠军结点共2k个。ls[0]为冠军结点，ls[1]--ls[k-1]为比较结点，ls[k]--ls[2k-1]为叶子结点（同时用另外一个指针索引b[0]--b[k-1]指向）。另外bk为一个附加的辅助空间，不属于败者树，初始化时存着MINKEY的值。 多路归并排序算法的过程大致为：首先将k个归并段中的首元素关键字依次存入 篇一：归并排序与快速排序实验报告 一、实验内容： 对二路归并排序和快速排序对于逆序的顺序数的排序时间复杂度比较。 二、所用算法的基本思想及复杂度分析： 1、归并排序 1）基本思想：运用分治法，其分治策略为： ①划分：将待排序列 r1,r2,……,rn划分为两个长度相等的子序列 r1,……,rn/2和rn/2+1,……,rn。 ②求解子问题：分别对这两个子序列进行排序，得到两个有序子序列。 ③合并：将这两个有序子序列合并成一个有序子序列。 2）复杂度分析： 二路归并排序的时间代价是o(nlog2n)。二路归并排序在合并过程中需要与原始记录序列同样数量的存储空间，因此其空间复杂性o(n)。 2、快速排序： 1）基本思想：运用分治法，其分治策略为： ①划分：选定一个记录作为轴值，以轴值为基准将整个序列划分为两个子序列 r1……ri-1和ri+1……rn，轴值的位置i在划分的过程中确定，并且前一个子序列中记录的值均小于或等于轴值，后一个子序列中记录的值均大于或等于轴值。 ②求解子问题：分别对划分后的每一个子序列递归处理。 ③合并：由于对子序列r1……ri-1和ri+1……rn的排序是就地进行的，所以合并不需要执行任何操作。 2）复杂度分析： 快速排序在平均时间复杂性是o(nlog2n)。最坏的情况下是o(n^2)。 三、源程序及注释： 1、归并排序 #include<iostream> #include<fstream> #include windows.h using namespace std; void merge(int r[],int r1[],int s,int m,int t ) } int mergesort(int r[],int r1[],int s,int t) { } void main() int i=s; int j=m+1; int k=s; while(i<=m&&j<=t) {} if(i<=m)while(i<=m) r1[k++]=r[i++];//第一个没处理完，进行收尾if(r[i]<=r[j])r1[k++]=r[i++];//取r[i]和r[j]中较小的放入r1[k]中else r1[k++]=r[j++]; else while(j<=t) r1[k++]=r[j++];//第二个没处理完，进行收尾for(int l=0;l<k;l++) { } r[l]=r1[l];//将合并完成后的r1[]序列送回r[]中if(s==t)r1[s]=r[s]; else{int m; m=(s+t)/2; mergesort(r,r1,s,m);//归并排序前半个子序列 mergesort(r,r1,m+1,t); //归并排序后半个子序列 merge(r1,r,s,m,t);//合并两个已排序的子序列 }return 0; int a[100000]; int a1[10000]; 归并排序算法的基本思想及算法实现示例 归并排序(Merge Sort)是利用"归并"技术来进行排序。归并是指将若干个已排序的子文件合并成一个有序的文件。 两路归并算法 1、算法基本思路 设两个有序的子文件(相当于输入堆)放在同一向量中相邻的位置上：R[low..m]，R[m+1..high]，先将它们合并到一个局部的暂存向量R1(相当于输出堆)中，待合并完成后将R1复制回R[low..high]中。 （1）合并过程 合并过程中，设置i，j和p三个指针，其初值分别指向这三个记录区的起始位置。合并时依次比较R[i]和R[j]的关键字，取关键字较小的记录复制到R1[p]中，然后将被复制记录的指针i或j加1，以及指向复制位置的指针p加1。 重复这一过程直至两个输入的子文件有一个已全部复制完毕(不妨称其为空)，此时将另一非空的子文件中剩余记录依次复制到R1中即可。 （2）动态申请R1 实现时，R1是动态申请的，因为申请的空间可能很大，故须加入申请空间是否成功的处理。 2、归并算法 void Merge(SeqList R，int low，int m，int high) {//将两个有序的子文件R[low..m)和R[m+1..high]归并成一个有序的 //子文件R[low..high] int i=low，j=m+1，p=0；//置初始值 RecType *R1；//R1是局部向量，若p定义为此类型指针速度更快 R1=(ReeType *)malloc((high-low+1)*sizeof(RecType))； if(! R1) //申请空间失败 Error("Insufficient memory available!")； while(i<=m&&j<=high) //两子文件非空时取其小者输出到R1[p]上 R1[p++]=(R[i].key<=R[j].key)?R[i++]：R[j++]； while(i<=m) //若第1个子文件非空，则复制剩余记录到R1中 R1[p++]=R[i++]； while(j<=high) //若第2个子文件非空，则复制剩余记录到R1中 R1[p++]=R[j++]； for(p=0，i=low；i<=high；p++，i++) R=R1[p]；//归并完成后将结果复制回R[low..high] } //Merge 归并排序 归并排序有两种实现方法：自底向上和自顶向下。 大连理工大学实验预习报告 学院（系）：电信专业：班级： 姓名：学号：组：___ 实验时间：实验室：实验台： 指导教师签字：成绩： 实验名称Merge sort 一、实验目的和要求 (一)、实验目的 Design the merge sort algorithm and implement it in C language 设计归并排序算法并于C语言实现。 (二)、实验要求 Requirements: 1) Analyze the time complexity of your algorithm 2) Submit the document explaining your algorithm as well as the source code. 要求： 1)分析算法的时间复杂度。 2) 提交的文档中说明你的算法和源代码。 二、实验原理 归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。 首先考虑下如何将将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可 解决了上面的合并有序数列问题，再来看归并排序，其的基本思路就是将数组分成二组A，B，如果这二组组内的数据都是有序的，那么就可以很方便的将这二组数据进行排序。如何让这二组组内数据有序了？ 可以将A，B组各自再分成二组。依次类推，当分出来的小组只有一个数据时，可以认为这个小组组内已经达到了有序，然后再合并相邻的二个小组就可以了。这样通过先递归的分解数列，再合并数列就完成了归并排序。 Java排序算法 1）分类： 1）插入排序（直接插入排序、希尔排序） 2）交换排序（冒泡排序、快速排序） 3）选择排序（直接选择排序、堆排序） 4）归并排序 5）分配排序（箱排序、基数排序） 所需辅助空间最多：归并排序 所需辅助空间最少：堆排序 平均速度最快：快速排序 不稳定：快速排序，希尔排序，堆排序。 1）选择排序算法的时候 1.数据的规模； 2.数据的类型； 3.数据已有的顺序 一般来说，当数据规模较小时，应选择直接插入排序或冒泡排序。任何排序算法在数据量小时基本体现不出来差距。考虑数据的类型，比如如果全部是正整数，那么考虑使用桶排序为最优。考虑数据已有顺序，快排是一种不稳定的排序（当然可以改进），对于大部分排好的数据，快排会浪费大量不必要的步骤。数据量极小，而起已经基本排好序，冒泡是最佳选择。我们说快排好，是指大量随机数据下，快排效果最理想。而不是所有情况。 3）总结： ——按平均的时间性能来分： 1）时间复杂度为O(nlogn)的方法有：快速排序、堆排序和归并排序，其中以快速排序为最好； 2）时间复杂度为O(n2)的有：直接插入排序、起泡排序和简单选择排序，其中以直接插入为最好，特别是对那些对关键字近似有序的记录序列尤为如此； 3）时间复杂度为O(n)的排序方法只有，基数排序。 当待排记录序列按关键字顺序有序时，直接插入排序和起泡排序能达到O(n)的时间复杂度;而对于快速排序而言，这是最不好的情况，此时的时间性能蜕化为O(n2)，因此是应该尽量避免的情况。简单选择排序、堆排序和归并排序的时间性能不随记录序列中关键字的分布而改变。 ——按平均的空间性能来分（指的是排序过程中所需的辅助空间大小）： 1）所有的简单排序方法(包括：直接插入、起泡和简单选择)和堆排序的空间复杂度为O(1)； 2）快速排序为O(log n )，为栈所需的辅助空间; 3）归并排序所需辅助空间最多，其空间复杂度为O(n ); 4）链式基数排序需附设队列首尾指针，则空间复杂度为O(rd )。 ——排序方法的稳定性能： 1）稳定的排序方法指的是，对于两个关键字相等的记录，它们在序列中的相对位置，在排序之前和经过排序之后，没有改变。 2）当对多关键字的记录序列进行LSD方法排序时，必须采用稳定的排序方法。 3）对于不稳定的排序方法，只要能举出一个实例说明即可。 4）快速排序，希尔排序和堆排序是不稳定的排序方法。 4）插入排序： 包括直接插入排序，希尔插入排序。 直接插入排序：将一个记录插入到已经排序好的有序表中。 1, sorted数组的第0个位置没有放数据。 package com.igo.util.file; import java.io.BufferedReader; import java.io.File; import java.io.FileReader; import java.util.HashSet; import java.util.List; import java.util.Set; import java.util.SortedSet; import java.util.TreeSet; import org.slf4j.Logger; /** * * 外部排序指的是大文件的排序，即待排序的记录存储在外存储器上，待排序的文件无法一次装入内存， * 需要在内存和外部存储器之间进行多次数据交换，以达到排序整个文件的目的。* 外部排序最常用的算法是多路归并排序，即将原文件分解成多个能够一次性装人内存的部分， * 分别把每一部分调入内存完成排序。然后，对已经排序的子文件进行归并排序。* @author ZhaoWeikai * Company: * 2010-12-23 下午02:25:00 */ public class MergeSort { private static final Logger log = org.slf4j.LoggerFactory.getLogger(MergeSort.class); /** 拆分大小, 单位:行*/ private static int SPLIT_SIZE = 100000; public static void main(String[] args) throws Exception { List 算法与数据结构实验报告 实验六 实验名称:归并排序问题 姓名：XXX 学号：xxxxxxxxxx 专业：软件工程 班级：x班 指导教师：xxx 日期: 2013年X月X日 一、实验目的 了解归并排序的排序思想，对于给定的关键字序列进行归并排序输出。二、实验内容与实验步骤 内容：设计二路归并算法。 问题描述如下：输入数据第1行有1整数k，表示需要排序的序列个数。以下k行，每行第一个整数m，表示待排序序列的长度，后面的m个整数表示待排序序列。将k个待排序序列的归并排序结果分k行输出。 步骤： 1将一维数组中前后相邻的两个有序序列归并为一个有序序列； 其算法为：void merge(dataList& L, dataList& L1,int left, int mid, int right){}； 2 对顺序表L作归并排序； 其算法为：void MergePass (dataList& L, dataList& L1, int len){}； 3 将SR[s..t]归并为排序为TR1[s..t]； 其算法为：void MergeSort (dataList& L){}； 4 调试数据，程序结束； 三、实验环境 操作系统winXP、开发平台:Microsoft Visual C++6.0 四、实验过程与分析 归并排序算法大大缩短了排序的时间复杂度，虽然程序代码复杂，但实现的基理相当简单。从运行结果可知，该程序达到了预期效果。 五、实验结论 测试数据：测试结果： 3 7 49 38 65 97 76 13 27 13 27 38 49 65 76 97 10 36 25 48 12 65 25 43 58 76 32 12 25 25 32 36 43 48 58 65 76 6 12 32 49 58 65 79 12 32 49 58 65 79 运行结果： Java数据结构和算法 第0讲综述 参考教材：Java数据结构和算法（第二版），[美] Robert lafore 1. 数据结构的特性 数据结构< 缺点 优点 数组插入快；如果知道下标，可以非常快地存取查找慢，删除慢，大小固定 有序数组比无序的数组查找快删除和插入慢，大小固定 提供后进先出方式的存取存取其他项很慢 < 栈 队列提供先进先出方式的存取存取其他项很慢 链表插入快，删除快— 查找慢 二叉树查找、插入、删除都快（如果树保持平衡）删除算法复杂 红-黑树查找、插入、删除都快；树总是平衡的算法复杂 算法复杂 2-3-4树` 查找、插入、删除都快；树总是平衡的；类 似的树对磁盘存储有用 哈希表如果关键字已知，则存储极快；插入快删除慢，如果不知道关键字则存 储很慢，对存储空间使用不充分堆插入、删除快；对大数据项的存取很快对其他数据项存取慢 对现实世界建模有些算法慢且复杂 》 图 2. 经典算法总结 查找算法：线性查找和二分查找 排序算法： 用表展示 ！ 第一讲数组 1.Java中数组的基础知识 1）创建数组 在Java中把数组当作对象来对待，因此在创建数组时必须使用new操作符： < 一旦创建数组，数组大小便不可改变。 2）访问数组数据项 3）数组的初始化 当创建数组之后，除非将特定的值赋给数组的数据项，否则它们一直是特殊的null对 等效于下面使用new来创建数组并初始化： | 2.面向对象编程方式 1）使用自定义的类封装数组 | # ! 子问题须与原始问题为同样的事，且更为简单； b. 不能无限制地调用本身，须有个出口，化简为非递归状况处理。 1.三角数字 该数列中的首项为1，第n项是由第n-1项加n后得到的。 1）使用循环查找第n项 #include tabg->r[k+t-i]=tabs->r[t]; else for(t=j; t<=v; t++) tabg->r[k+t-j]=tabs->r[t]; } void mergepass(table *tabs,table *tabg,int len) { int i,j,n; n=tabg->length=tabs->length; i=1; while(i<=n-2*len+1) { merge(tabs,tabg,i,i+len-1,i+2*len-1); i=i+2*len; } if(i+len-1 以下内容节选自Java私塾自编经典教材： 下面是Java实现的一些常见排序算法。 1：冒泡排序 对几个无序的数字进行排序，比较常用的方法是冒泡排序法。冒泡法排序是一个比较简单的排序方法，在待排序的数列基本有序的情况下排序速度较快。 基本思路：对未排序的各元素从头到尾依次比较相邻的两个元素是否逆序（与欲排顺序相反），若逆序就交换这两元素，经过第一轮比较排序后便可把最大（或最小）的元素排好，然后再用同样的方法把剩下的元素逐个进行比较，就得到了你所要的顺序。 可以看出如果有N个元素，那么一共要进行N-1轮比较，第I轮要进行N-I次比较。（如：有5个元素，则要进行5-1轮比较。第3轮则要进行5-3次比较） 示例如下： public class Test { public static void main(String[] args) { //需要排序的数组，目前是按照升序排列的 int a[] = new int[5]; a[0] = 3; a[1] = 4; a[2] = 1; a[3] = 5; a[4] = 2; //冒泡排序 for(int i=0;iC (++)内部排序汇总(快速排序&冒泡排序&堆排序&选择排序&插入排序&归并排序)
简单的归并排序算法例子
java程序员必知的十种程序算法
归并排序算法实现 (迭代和递归)
JAVA数组的排序方法实例
JAVA中运用数组的四种排序方法
归并排序分治策略的设计与实现
java中8大排序方法
分治算法实验(用分治法实现归并排序算法)
多路归并排序 外部排序算法
归并排序实验报告
归并排序算法的基本思想及算法实现示例
数据结构实验-归并排序算法
Java各种排序算法
大文件内容排序,多路归并排序算法
数据结构之归并排序
Java数据结构和算法笔记
数据结构8645归并排序(非递归算法)
Java实现的常见排序算法