【精品文档】归并排序实验报告-范文模板 (13页)

合集下载

并行双调归并排序计算实验报告

并行双调归并排序计算实验报告

并行计算实验报告一,实验题目:实现Stone并行排序算法二,实验目的:熟悉Stone并行排序的思想,熟悉并行计算中各种进程间通信方式的使用三,实验原理输入:s 二X o, X i,...., X n_i,, n = 2m输出:非降有序序列beg infor s =1 to m do(1) mask(-1)(2) for k=1 to m-s doCirculate(S) end for(3) Mask(k)(4) for k = m-s+1 to m do(4.1) Circulate(S)(4.2) Shuffle(MASK)end forend forendCirculate(S)的功能:(1)将存储单元中的数据,按均匀洗牌方式送入比较器;(2)将MASK数组的前n/2个分量按均匀洗牌方式送入比较器;(3)根据MASK( i)=0,1或-1,确定比较器i的状态;(4)将结果的输出反馈回储存单元。

Shuffle(S)的功能:均匀洗牌一次Mask(j)的功能:计算MASK数组的各分量,给一个整数j生成一长度为n的数组如下:-1, -1,-1,-1,…-1,-1 如果j = -1Mask = 0, 1,0, 1 …-.0, 1 如果j<=m-10, 0, 0, 0 …-,0, 0 如果j = m原理图:<)O -------------------- o o7 7 I ------------------ 7 _ _7程序的具体实现没有将Circulated)的功能独立出来写成函数,而是放在了主函数中。

四,函数介绍getBit oni cseque nce(i nt n)获得长度为n的随机数列,并返回首地址mask(i nt a, int m)跟据a和m的值确定长度为2的m次个的数组,并返回首地址void competor(i nt mask, int *a, i nt *b)比较器根据mask的值调整a和b的次序void shuffle(i nt *d, int *ir, i nt n)将长度为n的数列d洗牌一次(按位循环左移一次),并将结果存在数组ir中在主函数中,0号进程作为主进程管理其他进程,把待比较的数对发给其他进程, 其他进程处理完后,将结果返回给0号进程,0号进程组合自己和其他进程的结果,得到一次排序的结果序列。

数据结构与算法实验报告2:插入排序及归并排序(递增策略)

数据结构与算法实验报告2:插入排序及归并排序(递增策略)

数据结构与算法实验报告2:插入排序及归并排序(递增策略)1. 实验介绍本实验旨在探索插入排序和归并排序这两种排序算法的实现过程和性能表现。

插入排序是一种简单的排序算法,它通过不断将元素插入已排序的序列中来完成排序。

归并排序是一种分治法排序算法,它将待排序的序列拆分成小的子序列,然后逐步合并这些子序列来完成排序。

2. 插入排序插入排序的思想是将数组分为已排序和未排序两部分,最初已排序部分只包含一个元素,然后逐个将未排序部分的元素插入到已排序部分的适当位置,以此达到排序的目的。

插入排序使用两个循环来实现,外循环遍历未排序部分的元素,内循环将元素插入已排序部分的合适位置。

3. 归并排序归并排序是一种分治法排序算法,它将待排序的序列拆分成小的子序列,然后逐步合并这些子序列来完成排序。

归并排序使用递归的方式将序列拆分成单个元素,然后不断合并这些单个元素来创建有序的序列。

4. 实验结果通过实验测试,插入排序和归并排序的性能如下所示:- 插入排序:- 时间复杂度:平均情况下为 O(n^2),最好情况下为 O(n),最坏情况下为 O(n^2)- 空间复杂度:O(1)- 稳定性:稳定排序- 归并排序:- 时间复杂度:平均情况下为 O(nlogn),最好情况下为O(nlogn),最坏情况下为 O(nlogn)- 空间复杂度:O(n)- 稳定性:稳定排序5. 结论插入排序和归并排序都是常见的排序算法,它们各有优势和适用场景。

插入排序适用于小规模的数据集,且对部分已排序的情况有更好的性能。

归并排序适用于大规模的数据集,其时间复杂度始终稳定,且不受输入数据的影响。

根据实际需求选择合适的算法可以提高代码的效率和性能。

算法分析与设计实验报告2: 快速排序及归并排序(分治策略)

算法分析与设计实验报告2: 快速排序及归并排序(分治策略)
四、实验代码
1、归并排序
#include<iostream>
#include<time.h>
#defineMAX100
usingnamespacestd;
voidmerge(intarray[],intp,intq,intr)
{
inti, k;
intbegin1, end1, begin2, end2;
}
quicksort(number,left, i - 1);
quicksort(number, j+1,right);
}
}
voidmain()
{
intnumber[MAX] = { 0 };
srand(time(NULL));
printf("排序前:");
for(inti = 0; i < MAX; i++)
}
for(i = 0; i < (r-p+ 1); i++)
{
array[p+ i] = temp[i];
}
delete[](temp);
}
voidmerge_sort(intdata[],intleft,intright)
{
if(left<right)
{
intmid = (left+right) / 2;
{
inti, j, s;
if(left<right)
{
s =number[(left+right) / 2];
i =left- 1;
j =right+ 1;
while(1)

算法分析与设计实验报告合并排序快速排序

算法分析与设计实验报告合并排序快速排序

算法分析与设计实验报告:合并排序与快速排序一、引言算法是计算机科学中非常重要的一部分,它涉及到解决问题的方法和步骤。

合并排序和快速排序是两种经典而常用的排序算法。

本文将对这两种排序算法进行分析和设计实验,通过对比它们的性能和效率,以期得出最优算法。

二、合并排序合并排序是一种分治算法,它将原始数组不断分解为更小的数组,直到最后细分为单个元素。

然后,再将这些单个元素两两合并,形成一个有序数组。

合并排序的核心操作是合并两个有序的数组。

1. 算法步骤(1)将原始数组分解为更小的子数组,直到每个子数组只有一个元素;(2)两两合并相邻的子数组,同时进行排序,生成新的有序数组;(3)重复步骤(2),直到生成最终的有序数组。

2. 算法性能合并排序的最优时间复杂度为O(nlogn),其中n为待排序数组的长度。

无论最好情况还是最坏情况,合并排序的复杂度都相同。

合并排序需要额外的存储空间来存储临时数组,所以空间复杂度为O(n)。

三、快速排序快速排序也是一种分治算法,它将原始数组根据一个主元(pivot)分成两个子数组,一个子数组的元素都小于主元,另一个子数组的元素都大于主元。

然后,递归地对这两个子数组进行排序,最后得到有序数组。

快速排序的核心操作是划分。

1. 算法步骤(1)选择一个主元(pivot),可以是随机选择或者固定选择第一个元素;(2)将原始数组根据主元划分为两个子数组,一个子数组的元素都小于主元,另一个子数组的元素都大于主元;(3)递归地对这两个子数组进行快速排序;(4)重复步骤(2)和(3),直到每个子数组只有一个元素,即得到最终的有序数组。

2. 算法性能快速排序的平均时间复杂度为O(nlogn),其中n为待排序数组的长度。

最坏情况下,当每次选择的主元都是最小或最大元素时,时间复杂度为O(n^2)。

快速排序是原地排序,不需要额外的存储空间,所以空间复杂度为O(1)。

四、实验设计为了验证合并排序和快速排序的性能和效率,我们设计以下实验:1. 实验目的:比较合并排序和快速排序的时间复杂度和空间复杂度。

归并排序实验报告

归并排序实验报告

一、实验目的(1)理解分治法的思想。

(2)掌握用分治法解决问题二、实验内容(1)仔细阅读备选实验的题目,选择一个(可选多个)作为此次实验题目,设计的程序要满足正确性,代码中有关键的注释,书写格式清晰,简洁易懂,效率较高,利用C++的模板,设计的程序通用性好,适合各种合理输入,并能对不合理输入做出正确的提示。

(2)归并排序★问题描述目前的网上拍卖系统会显示很多待拍卖的物品,通常这些系统具有按照某个关键字对打出的广告进行排序列出的功能,并且能够按照用户输入的某个关键字进行过虑,找到某些特定的物品。

★编程任务定义一个Advertisement类,该类中至少包含该物品的数量,名称,联系人e-mail,最好有开拍时间及关闭时间,根据用户输入的关键字比如名称,mail,时间等,利用非递归的归并排序对所有的广告进行排序,并列出所有排好序的广告。

★数据输入由文件input.txt提供输入的所有广告信息。

程序中由用户输入要排序的关键字。

★结果输出程序运行结束时,排好序的广告输出到文件output.txt中,并为每个广告添加序号。

输入文件示例输出文件示例input.txt output.txtCoat(物品名称) 3(数量)a@Skirt5b@Cap7c@Bag 1Bag12a@2Cap7c@3Coat(物品名称)12a@Title(用户输入按照title 排序)3(数量)a@ 4Skirt5b@三、实验环境操作系统Windows 7调试软件VC++6.0上机地点综合楼211四、问题分析(1)分析要解决的问题,给出你的思路,可以借助图表等辅助表达。

答:归并操作的工作原理如下:●申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列●设定两个指针,最初位置分别为两个已经排序序列的起始位置●比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置●重复步骤3直到某一指针达到序列尾●将另一序列剩下的所有元素直接复制到合并序列尾(2)分析利用你的想法解决该问题可能会有怎样的时空复杂度。

分治法实现归并排序算法算法设计与分析实验报告(word文档良心出品)

分治法实现归并排序算法算法设计与分析实验报告(word文档良心出品)

算法设计与分析实验报告实验名称分治法实现归并排序算法评分实验日期年月日指导教师姓名专业班级学号一.实验要求1.了解用分治法求解的问题:当要求解一个输入规模为n,且n的取值相当大的问题时,如果问题可以分成k个不同子集合,得到k个不同的可独立求解的子问题,其中1<k≤n,而且子问题与原问题性质相同,原问题的解可由这些子问题的解合并得出。

那末,对于这类问题分治法是十分有效的。

2.掌握分治法的一般控制流程。

DanC(p,q)global n,A[1:n]; integer m,p,q; // 1≤p≤q≤nif Small(p,q) then return G(p,q);else m=Divide(p,q); // p≤m<qreturn Combine(DanC(p,m),DanC(m+1,q));endifend DanC3.实现典型的分治算法的编程与上机实验,验证算法的时间复杂性函数。

二.实验内容1.编程实现归并排序算法,程序中加入比较次数的计数功能,输出排序结果和比较次数。

2.输入10组相同的数据,验证排序结果和完成排序的比较次数。

3.与复杂性函数所计算的比较次数比较。

4.用表格列出比较结果。

5.给出文字分析。

三.程序算法1. 归并排序算法procedure MERGESORT(low,high)//A(low;high)是一个全程数组,它含有high-low+1≥0个待排序的元素//integer low,high;if low<high;then mid←, //求这个集合的分割点//call MERGESORT(low,mid) //将一个子集合排序//call MERGESORT(mid+1,high) //将另一个子集合排序call MERGE(low,mid,high) //归并两个已排序的子集合// endifend MERGESORT归并两个已排序的集合procedure MERGE(low,mid,high)//A(low:high)是一个全程数组////辅助数组B(low;high)//integer h,i,j,k;h←low;i←low;j←mid+1;while h≤mid and j≤high do //当两个集合都没取尽时// if A(h)≤A(j) then B(i) ←A(h);h←h+1else B(i) ←A(j);j←j+1endifi←i+1repeatif h>mid thenfor k←j to high do //处理剩余的元素//B(i) ←A(k);i←i+1repeatelse for k←h to mid doB(i) ←A(k);i←i+1repeatendif将已归并的集合复制到Aend MERGE2. 快速排序算法QuickSort(p,q)//将数组A[1:n]中的元素A[p], A[p+1], , A[q]按不降次序排列,并假定A[n+1]是一个确定的、且大于A[1:n]中所有的数。

归并排序法实验报告

归并排序法实验报告

一、实验目的1. 理解归并排序的基本思想和原理。

2. 掌握归并排序的实现方法。

3. 分析归并排序算法的时间复杂度。

4. 学会使用归并排序解决实际问题。

二、实验内容1. 归并排序的基本思想归并排序是一种基于分治策略的排序算法,其基本思想是将待排序的序列分成若干个子序列,分别对每个子序列进行排序,然后将排序好的子序列合并成一个有序序列。

具体步骤如下:(1)将待排序的序列分成两个子序列,分别进行排序;(2)将排序好的两个子序列合并成一个有序序列;(3)递归地对合并后的序列进行步骤(1)和(2)的操作,直到整个序列有序。

2. 归并排序的实现方法归并排序算法主要分为两个步骤:归并和合并。

(1)归并:将序列分为两个子序列,对每个子序列进行归并排序;(2)合并:将排序好的两个子序列合并成一个有序序列。

以下是归并排序的Python代码实现:```pythondef merge_sort(arr):if len(arr) <= 1:return arrmid = len(arr) // 2left = merge_sort(arr[:mid])right = merge_sort(arr[mid:])return merge(left, right)def merge(left, right):merged = []i = j = 0while i < len(left) and j < len(right):if left[i] < right[j]:merged.append(left[i])i += 1else:merged.append(right[j])j += 1merged.extend(left[i:])merged.extend(right[j:])return merged```3. 归并排序的时间复杂度分析归并排序算法的时间复杂度主要由归并操作和递归调用决定。

对于长度为n的序列,归并排序需要进行n-1次归并操作,每次归并操作需要比较n/2次,因此总的比较次数为(n/2) (n-1) = n^2/2。

排序算法实验报告

排序算法实验报告

算法分析实验报告实验时间:2013.9.30姓名:杜茂鹏班级:计科1101学号:0909101605一.实验内容1.归并排序2.快速排序3.分治法找最大最小值二.实验目的1.巩固分治法的思路:分治法的思想是,将一个难以直接解决的大问题,分割成一些规模较小的相同的问题,以便各个击破,分而治之。

如果原问题可以分割成k个子问题,1<k<=n,且这些子问题都可解,并可利用这些子问题求解出原问题的解,那么这种分治法就是可行的。

分治法往往是原问题的较小规模,这为使用递归技术提供了方便。

在这种情况下,反复应用分之手段,可以使子问题与原问题类型一致而其规模却不断缩小,最终使子问题缩小到很容易求出其解。

由此自然导致的递归算法。

分治与递归像一对孪生兄弟,经常同时应用在算法设计之中,并由此产生许多高效算法。

2.了解快速排序、归并排序、找最大最小值的内涵,区别普通排序方式和利用分治法的排序方式的差别。

三.程序设计思路1.快速排序:选择一个值作为key,经过比较将小于key 的交换到它前面,将大于key的交换到它后面;接下来对key 前面的和后面的分别进行排序,qsort(S,low,high),利用分治法将其分解成最小的问题个体,通过比较将其排好序,即为顺序的数组。

2.归并排序:m=(low+high)/2,利用mergesort(S,low,m,L)、mergesort(S,m+1,high,L)分治成最小的个体,之后进行排序,将排好的序列放到L中,递归地逐渐复原原问题,当所有的都排好序便可。

3.找最大最小值:利用分治法分成两部分,在这两部分中找到最大、最小值,进而进行比较,从而得到。

在程序运行过程中,实际上试讲问题分成最小的部分,分别找出最大最小,通过比较找出上层的最大最小值,进而找出全部的最大最小值。

四.运行结果1.归并排序2.快速排序3.分治法找最大最小值五.程序源代码//分治法归并排序#include <stdio.h>#include <stdlib.h>int n=0;void merge(int number[],int first,int last,int mid) {int number_temp[10]={0};int i=first,j=mid+1,k;for(k=0;k<=last-first;k++){if (i==mid+1){number_temp[k]=number[j++];n++;continue;}if (j==last+1){number_temp[k]=number[i++];n++;continue;}if (number[i]<number[j]){number_temp[k]=number[i++];n++;}else {number_temp[k]=number[j++];n++;}}for (i=first,j=0;i<=last;i++,j++)number[i] = number_temp[j];}void merge_sort(int number[],int first,int last) {int mid=0;if(first<last){mid=(first+last)/2;n++;merge_sort(number,first,mid);merge_sort(number,mid+1,last);merge(number,first,last,mid);}}int main(){printf(" 归并排序\n");int i;printf("产生的随机数为:\n");int number[10]={0};for(i=0;i<10;i++){number[i]=rand()%100;printf("%-5.2d",number[i]);}printf("\n");merge_sort(number,0,9);printf("排序后的顺序为:\n");for(i=0;i<10;i++)printf("%-5.2d",number[i]);printf("\n比较的次数为:%d\n\n\n",n);}//------------------快速排序----------------#include<stdio.h>#include<stdlib.h>int n=0;int partion(int L[],int low,int high){int a;a=L[low];while(low<high){while(low<high&&L[high]>=a){high--;n++;}L[low]=L[high];n++;while(low<high&&L[low]<=a){low++;n++;}L[high]=L[low];n++;}L[low]=a;return low;}void quicksort(int L[],int low,int high){int b;if(low<high){b=partion(L,low,high);quicksort(L,low,b-1);quicksort(L,b+1,high);}}int main(){printf(" 快速排序\n");int i;printf("产生的随机数为:\n");int L[10]={0};for(i=0;i<10;i++){L[i]=rand()%100;printf("%d ",L[i]);}printf("\n");quicksort(L,0,9);printf("排序后的顺序为:\n");for(i=0;i<10;i++)printf("%d ",L[i]);printf("\n比较的次数为:%d\n\n\n",n);}//分治法找最大最小值#include <stdio.h>#include <stdlib.h>#include <limits.h>#include <time.h>void PartionGet(int a,int b,int *meter,int *max,int *min){int i;if(b-a <= 1){if(meter[a] > meter[b]){if(meter[a] > *max)*max = meter[a];if(meter[b] < *min)*min = meter[b];}else{if(meter[b] > *max)*max = meter[b];if(meter[a] < *min)*min = meter[a];}return ;}i = a + (b-a)/2;PartionGet(a,i,meter,max,min);PartionGet(i+1,b,meter,max,min);}int main(){int i,meter[10];int max = INT_MIN;int min = INT_MAX;printf(" 找最大值最小值:\n\n"); printf("产生的随机数为:\n\n");srand(time(0));for(i = 0; i <10; i ++){meter[i] = rand()%100;if(!((i+1)%10))printf("%-6d\n",meter[i]);elseprintf("%-6d",meter[i]);}PartionGet(0,9,meter,&max,&min);printf("\nMax : %d\nMin : %d\n",max,min);system("pause");return 0;}六.实验心得实验主要考查学生运用分治法来解决相关问题,通过此次上机实验动手操作加深了我对分治法的理解。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

本文部分内容来自网络整理,本司不为其真实性负责,如有异议或侵权请及时联系,本司将立即删除!== 本文为word格式,下载后可方便编辑和修改! ==归并排序实验报告篇一:归并排序与快速排序实验报告一、实验内容:对二路归并排序和快速排序对于逆序的顺序数的排序时间复杂度比较。

二、所用算法的基本思想及复杂度分析: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];int n,i;int b[3]= {1000,3000,5000};//产生3个数组。

for(int j=0; j<3; j++){n=b[j];for(i=1; i<=n; i++)a[i]=n;LARGE_INTEGER BegainTime ;LARGE_INTEGER EndTime ;LARGE_INTEGER Frequency;QueryPerformanceFrequency(&Frequency);QueryPerformanceCount er(&BegainTime) ;int c=MergeSort(a,a1,0,n-1); QueryPerformanceCounter(&EndTime); cout << "数据个数为"<<n<<"时归并排序的时间为(单位:s):" <<(double)( EndTime1.QuadPart -BegainTime1.QuadPart )/ Frequency1.QuadPart <<endl;}}2、快速排序#include<iostream>#include<fstream>#include "windows.h"using namespace std;int Partition (int data[],int first,int end){int i,j;} while(i<j) { } return i; while(i<j&&data[i]<=data[j])j--;//从左侧扫描 if(i<j) {} while(i<j&&data[i]<=data[j])i++;//从右侧扫描 if(i<j) {} int temp1; temp1=data[i]; data[i]=data[j]; data[j]=temp1; //将较小的放到后面 j--; int temp; temp=data[i]; data[i]=data[j];data[j]=temp;//将较小的放到前面 i++;int quicksort(int c[],int first,int end){int i; if(first<end) { i=Partition(c,first,end);//对c[hs]到c[ht]进行一次划分} } quicksort(c,i+1,end);//递归处理右区间 return 0;void main(){int a[100000],n,i;int b[3]= {1000,3000,5000};//3个数据范围for(int j=0; j<3; j++){n=b[j];for(i=1; i<=n; i++) a[i]=n;LARGE_INTEGER BegainTime ;LARGE_INTEGER EndTime;LARGE_INTEGER Frequency ;QueryPerformanceFrequency(&Frequency);QueryPerformanceCoun ter(&BegainTime) ;int c= quicksort(a,0,n); QueryPerformanceCounter(&EndTime); cout << "数据个数为"<<n<<"时快速排序的时间为(单位:s):" <<(double)( EndTime.QuadPart - BegainTime.QuadPart )/ Frequency.QuadPart <<endl;}}四、运行输出结果:归并排序篇二:算法分析与设计实验报告-合并排序、快速排序实验报告实验一合并排序、快速排序一.实验目的(1)学习合并排序和快速排序算法的思想,掌握原理。

(2)运用合并排序和快速排序算法的思想进行编程实现,以加深理解。

二.实验内容(1)输入几个整数,运用合并排序的思想进行编程实现,输出正确的排序结果。

(2)输入10个整数,运用快速排序的思想进行编程实现,输出正确的排序结果三.实验代码(1)合并排序源代码如下:#include <iomanip.h>//调用setw#include <iostream.h> //将b[0]至b[right-left+1]拷贝到a[left]至a[right] template <class T>void Copy(T a[],T b[],int left,int right){ int size=right-left+1;for(int i=0;i<size;i++){a[left++]=b[i];}} //合并有序数组a[left:i],a[i+1:right]到b,得到新的有序数组btemplate <class T>void Merge(T a[],T b[],int left,int i,int right){ int a1cout=left,//指向第一个数组开头a1end=i,//指向第一个数组结尾a2cout=i+1,//指向第二个数组开头a2end=right,//指向第二个数组结尾bcout=0;//指向b中的元素for(int j=0;j<right-left+1;j++)//执行right-left+1次循环{ if(a1cout>a1end){b[bcout++]=a[a2cout++];continue; } //如果第一个数组结束,拷贝第二个数组的元素到bif(a2cout>a2end){b[bcout++]=a[a1cout++];continue; } //如果第二个数组结束,拷贝第一个数组的元素到bif(a[a1cout]<a[a2cout]){ b[bcout++]=a[a1cout++];continue; } //如果两个数组都没结束,比较元素大小,把较小的放入belse{ b[bcout++]=a[a2cout++];continue;} } } //对数组a[left:right]进行合并排序 template <class T>void MergeSort(T a[],int left,int right){ T *b=newint[right-left+1];if(left<right){int i=(left+right)/2;//取中点MergeSort(a,left,i);//左半边进行合并排序 MergeSort(a,i+1,right);//右半边进行合并排序 Merge(a,b,left,i,right);//左右合并到b中Copy(a,b,left,right);//从b拷贝回来}}int main(){ int n;cout<<"请输入您将要排序的数目:"; cin>>n; int *a=new int[n]; cout<<"请输入相应的数字:";for(int i=0;i<n;i++){ cin>>a[i]; }MergeSort( a, 0, n-1); cout<<"排序结果:";for(int j=0;j<n;j++){ cout<<setw(5)<<a[j]; }cout<<endl;return 1;}(2)快速排序源代码如下:#include <iostream.h>#define MAX 10int QuickSort(int a[],int l,int r){int pivot; //枢轴int i=l;int j=r;int tmp;pivot=a[(l+r)/2];//取数组中间的数为枢轴 do {while (a[i]<pivot) i++; //i右移while (a[j]>pivot) j--;// j左移if (i<=j){tmp=a[i];a[i]=a[j];a[j]=tmp; //交换a[i]和a[j] i++;j--;}} while(i<=j);if (l<j) QuickSort(a,l,j);if (i<r) QuickSort(a,i,r);return 1;}int main(){int array[MAX];int i;cout<<"请输入"<<MAX<<" 个整数:"; for (i=0;i<MAX;i++)cin>>array[i];QuickSort(array,0,MAX-1); cout<<"快速排序后:"<<endl; for (i=0;i<MAX;i++)cout<<array[i]<<" "; cout<<endl;return 0;}四.实验结果五.总结与思考篇三:合并、快速排序实验报告合并、快速排序一.实验目的:1. 理解算法设计的基本步骤及各部的主要内容、基本要求;2. 加深对分治设计方法基本思想的理解,并利用其解决现实生活中的问题;3. 通过本次试验初步掌握将算法转化为计算机上机程序的方法。

相关文档
最新文档