内部排序算法比较课程设计报告种基本排序
数据结构-第十章-内部排序
0
1
2
3
4
5
6
7
8
i=5
MAXINT 49 2 3
MAXINT 49 6 3 MAXINT 49 6 3 MAXINT 49 6 8
38 1
38 1 38 1 38 1
65 97 5 0
65 5 65 5 65 5 97 0 97 0 97 0
76 4
76 4 76 4 76 4
13
27
49
i=6
最坏情况下,待排记录按关键字非递增有序 排列（逆序）时，第 i 趟时第 i＋1 个对象 必须与前面 i 个对象都做排序码比较, 并且 每做1次比较就要做1次数据移动。总比较 次 数 为 (n+2)(n-1)/2 次 ， 总 移 动 次 数 为 (n+4)(n-1)/2。 在平均情况下的排序码比较次数和对象移 动次数约为 n2/4。因此，直接插入排序的 时间复杂度为 O(n2)。 直接插入排序是一种稳定的排序方法。
折半插入排序 (Binary Insertsort)
基本思想 既然每个要插入记录之前的纪录 已经按关键字有序排列，在查找插入位 臵时就没有必要逐个关键字比较，可以 使用折半查找来实现。由此进行的插入 排序称之为折半插入排序。
折半插入排序的算法
void BInsertSort (SqList &L){ for (i=2;i<=L.length;++i){ L.r[0]=L.r[i]; low=1;high=i-1; //查找范围由1到i-1 while(low<=high){ m=(low+high)/2; if LT(L.r[0].key,L.r[m].key) high=m-1; else low=m+1; }//while 折半查找 for (j=i-1;j>=high+1;--j) L.r[j+1]=L.r[j]; //折半查找结束后high+1位臵即为插入位臵 L.r[high+1]=L.r[0]; }//for }//BInsertSort
数据结构课程设计—内部排序算法比较
数据结构课程设计—内部排序算法比较在计算机科学领域中，数据的排序是一项非常基础且重要的操作。
内部排序算法作为其中的关键部分，对于提高程序的运行效率和数据处理能力起着至关重要的作用。
本次课程设计将对几种常见的内部排序算法进行比较和分析，包括冒泡排序、插入排序、选择排序、快速排序和归并排序。
冒泡排序是一种简单直观的排序算法。
它通过重复地走访要排序的数列，一次比较两个数据元素，如果顺序不对则进行交换，并一直重复这样的走访操作，直到没有要交换的数据元素为止。
这种算法的优点是易于理解和实现，但其效率较低，在处理大规模数据时性能不佳。
因为它在最坏情况下的时间复杂度为 O(n²)，平均时间复杂度也为O(n²)。
插入排序的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入，直到整个序列有序。
插入排序在数据量较小时表现较好，其平均时间复杂度和最坏情况时间复杂度也都是 O(n²)，但在某些情况下，它的性能可能会优于冒泡排序。
选择排序则是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。
以此类推，直到全部待排序的数据元素排完。
选择排序的时间复杂度同样为O(n²)，但它在某些情况下的交换操作次数可能会少于冒泡排序和插入排序。
快速排序是一种分治的排序算法。
它首先选择一个基准元素，将数列分成两部分，一部分的元素都比基准小，另一部分的元素都比基准大，然后对这两部分分别进行快速排序。
快速排序在平均情况下的时间复杂度为 O(nlogn)，最坏情况下的时间复杂度为 O(n²)。
然而，在实际应用中，快速排序通常表现出色，是一种非常高效的排序算法。
归并排序也是一种分治算法，它将待排序序列分成若干个子序列，每个子序列有序，然后将子序列合并成一个有序序列。
第10章-内部排序PPT课件
-
算法效率
时间复杂度
待排序记录按关键字从小到大排列(正序)
n
比较次数: 1 n 1 i2
移动次数: 0
待排序记录按关键字从大到小排列(逆序)
比较次数:
n i (n2)(n1)
i2
2
移动次数:
n
(n4)(n1)
(i1)
i2
2
待排序记录随机，取平均值
比较次数: n 2
4
移动次数: n 2
4
总的时间复杂度:T(n)=O(n2)
空间复杂度：S(n)=O(1)
-
3. 折半插入排序
排序过程：用折半查找方法确定插入位置。 举例：
i=1: (38) (49) 38 65 97 76 13 27 49
5 R’={5}
R={10,2}
2 R’={2,5}
R={2}
10 R’={2,5,10}
R={ }
2 R’={2,2,5,10}
-
2. 直接插入排序
排序过程：整个排序过程为n-1趟插入
将序列中第1个记录看成是一个有序子序列 从第2个记录开始，逐个进行插入，直至整个序列有序
R1 R2 …… Rn
内部排序适用于记录个数不很多的小文件； 外部排序则适用于记录个数太多，不能一次 将其全部放入内存的大文件
排序依据策略
插入排序：直接插入排序, 折半插入排序, 希尔排序 交换排序：冒泡排序, 快速排序 选择排序：简单选择排序, 堆排序 归并排序：2-路归并排序 基数排序
数据结构课程设计实践报告
数据结构实验报告本文是范文，仅供参考写作，禁止抄袭本文内容上传提交，违者取消写作资格，成绩不合格！实验名称：排序算法比较提交文档学生姓名：提交文档学生学号：同组成员名单：指导教师姓名：排序算法比较一、实验目的和要求1、设计目的1．掌握各种排序的基本思想。
2．掌握各种排序方法的算法实现。
3．掌握各种排序方法的优劣分析及花费的时间的计算。
4．掌握各种排序方法所适应的不同场合。
2、设计内容和要求利用随机函数产生30000个随机整数，利用插入排序、起泡排序、选择排序、快速排序、堆排序、归并排序等排序方法进行排序，并统计每一种排序上机所花费的时间二、运行环境（软、硬件环境）软件环境：Vc6.0编程软件运行平台： Win32硬件：普通个人pc机三、算法设计的思想1、冒泡排序：bubbleSort()基本思想: 设待排序的文件为r[1..n]第1趟(遍)：从r[1]开始,依次比较两个相邻记录的关键字r[i].key和r[i+1].key,若r[i].key>r[i+1].key，则交换记录r[i]和r[i+1]的位置；否则,不交换。
(i=1,2,...n-1)第1趟之后,n个关键字中最大的记录移到了r[n]的位置上。
第2趟：从r[1]开始,依次比较两个相邻记录的关键字r[i].key和r[i+1].key,若r[i].key>r[i+1].key，则交换记录r[i]和r[i+1]的位置；否则,不交换。
(i=1,2,...n-2)第2趟之后,前n-1个关键字中最大的记录移到了r[n-1]的位置上，作完n-1趟,或者不需再交换记录时为止。
2、选择排序：selSort()每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
选择排序不像冒泡排序算法那样先并不急于调换位置，第一轮（k=1）先从array[k]开始逐个检查，看哪个数最小就记下该数所在的位置于minlIndex中，等一轮扫描完毕，如果找到比array[k-1]更小的元素，则把array[minlIndex]和a[k-1]对调，这时array[k]到最后一个元素中最小的元素就换到了array[k-1]的位置。
各种内排序算法的实验心得
各种内排序算法的实验心得
1. 冒泡排序
冒泡排序是一种简单的排序算法，但它的时间复杂度为O(n^2)，在处理大量数据时效率很低。
在实验过程中，我发现当数据量较小时，冒泡排序的效率其实还是不错的，但一旦数据量增加，它的效率就明显下降了。
2. 插入排序
插入排序的时间复杂度也是O(n^2)，类似于冒泡排序。
但是插入排序比冒泡排序更快，因为它每次只需要比较一个元素。
在实验中，我发现当数据量比较小且有序时，插入排序的效率非常高，但如果数据量较大且随机分布，效率就会明显下降。
3. 选择排序
选择排序同样是时间复杂度为O(n^2)的算法，但是它比冒泡排序和插入排序都要快。
在实验中，我发现当数据量很大时，选择排序的效率比较稳定，但是当数据量比较小时，它的效率反而不如插入排序。
4. 快速排序
快速排序是一种常用的排序算法，它的时间复杂度为O(nlogn)，比冒泡、插入和选择排序都要快。
在实验中，我发现当数据量比较大时，快速排序的效率非常高，但是当数据量比较小时，它的效率反而不如插入排序和选择排序。
5. 归并排序
归并排序与快速排序的时间复杂度相同，都是O(nlogn)。
但是归并排序比快速排序更稳定，因为它的最坏时间复杂度是O(nlogn)。
在实验中，我发现当数据量比较大时，归并排序的效率非常高，而且在处理大量数据时表现优异。
6. 基数排序
基数排序是一种特殊的排序算法，它适用于数据量较大且每个元素长度相同的情况。
在实验中，我发现基数排序的效率非常高，尤其是对于大量数据的排序。
但需要注意的是，基数排序无法处理字符串等非数字类型的数据。
各种排序算法的课程设计
各种排序算法的课程设计一、课程目标知识目标：1. 让学生掌握排序算法的基本概念，了解不同排序算法的优缺点及应用场景。
2. 使学生能够理解和掌握冒泡排序、选择排序、插入排序等基本排序算法的原理和实现方法。
3. 帮助学生理解排序算法的时间复杂度和空间复杂度，并能够分析不同算法的效率。
技能目标：1. 培养学生运用编程语言实现排序算法的能力，提高编程实践操作技能。
2. 培养学生通过分析问题，选择合适的排序算法解决实际问题的能力。
情感态度价值观目标：1. 激发学生对计算机科学和算法的兴趣，培养主动探究和自主学习的精神。
2. 培养学生面对问题时的耐心和细心，提高解决问题的信心和团队合作意识。
3. 使学生认识到排序算法在生活中的广泛应用，体会算法对人类社会的贡献。
课程性质分析：本课程为计算机科学相关学科，旨在让学生掌握排序算法的基本原理和实现方法，提高编程实践能力。
学生特点分析：学生处于年级中段，具有一定的编程基础和逻辑思维能力，对新鲜事物充满好奇心，但学习耐心和自律性有待提高。
教学要求：1. 注重理论与实践相结合，提高学生的实际操作能力。
2. 通过案例分析，引导学生主动思考，提高问题解决能力。
3. 创设互动、轻松的学习氛围，关注学生个体差异，激发学习兴趣。
二、教学内容1. 排序算法基本概念：介绍排序的定义、排序算法的稳定性、内排序与外排序的分类。
2. 冒泡排序：讲解冒泡排序的原理、实现步骤，分析其时间复杂度和空间复杂度。
3. 选择排序：介绍选择排序的原理、实现步骤，分析其时间复杂度和空间复杂度。
4. 插入排序：讲解插入排序的原理、实现步骤，分析其时间复杂度和空间复杂度。
5. 排序算法比较：对比冒泡排序、选择排序和插入排序的优缺点，探讨在不同场景下如何选择合适的排序算法。
6. 教学案例：结合实际案例，让学生动手实践排序算法，提高编程能力。
7. 排序算法拓展：简要介绍其他常用排序算法（如快速排序、归并排序等）的原理和应用。
用Java实现常见的8种内部排序算法
⽤Java实现常见的8种内部排序算法⼀、插⼊类排序插⼊类排序就是在⼀个有序的序列中，插⼊⼀个新的关键字。
从⽽达到新的有序序列。
插⼊排序⼀般有直接插⼊排序、折半插⼊排序和希尔排序。
1. 插⼊排序1.1 直接插⼊排序/*** 直接⽐较，将⼤元素向后移来移动数组*/public static void InsertSort(int[] A) {for(int i = 1; i < A.length; i++) {int temp = A[i]; //temp ⽤于存储元素，防⽌后⾯移动数组被前⼀个元素覆盖int j;for(j = i; j > 0 && temp < A[j-1]; j--) { //如果 temp ⽐前⼀个元素⼩，则移动数组A[j] = A[j-1];}A[j] = temp; //如果 temp ⽐前⼀个元素⼤，遍历下⼀个元素}}/*** 这⾥是通过类似于冒泡交换的⽅式来找到插⼊元素的最佳位置。
⽽传统的是直接⽐较，移动数组元素并最后找到合适的位置*/public static void InsertSort2(int[] A) { //A[] 是给定的待排数组for(int i = 0; i < A.length - 1; i++) { //遍历数组for(int j = i + 1; j > 0; j--) { //在有序的序列中插⼊新的关键字if(A[j] < A[j-1]) { //这⾥直接使⽤交换来移动元素int temp = A[j];A[j] = A[j-1];A[j-1] = temp;}}}}/*** 时间复杂度：两个 for 循环 O(n^2)* 空间复杂度：占⽤⼀个数组⼤⼩，属于常量，所以是 O(1)*/1.2 折半插⼊排序/** 从直接插⼊排序的主要流程是：1.遍历数组确定新关键字 2.在有序序列中寻找插⼊关键字的位置* 考虑到数组线性表的特性，采⽤⼆分法可以快速寻找到插⼊关键字的位置，提⾼整体排序时间*/public static void BInsertSort(int[] A) {for(int i = 1; i < A.length; i++) {int temp = A[i];//⼆分法查找int low = 0;int high = i - 1;int mid;while(low <= high) {mid = (high + low)/2;if (A[mid] > temp) {high = mid - 1;} else {low = mid + 1;}}//向后移动插⼊关键字位置后的元素for(int j = i - 1; j >= high + 1; j--) {A[j + 1] = A[j];}//将元素插⼊到寻找到的位置A[high + 1] = temp;}}2. 希尔排序希尔排序⼜称缩⼩增量排序，其本质还是插⼊排序，只不过是将待排序列按某种规则分成⼏个⼦序列，然后如同前⾯的插⼊排序⼀般对这些⼦序列进⾏排序。
算法21--内部排序--归并排序
实现这种递归调用的关键是为过程建立递归调用工作栈。通 常，在一个过程中调用另一过程时，系统需在运行被调用过 程之前先完成3件事:
（1）将所有实参指针，返回地址等信息传递给被调用过程； （2）为被调用过程的局部变量分配存储区； （3）将控制转移到被调用过程的入口。 在从被调用过程返回调用过程时，系统也相应地要完成3件事： （1）保存被调用过程的计算结果； （2）释放分配给被调用过程的数据区； （3）依照被凋用过程保存的返回地址将控制转移到调用过程.
实际的意义：可以把一个长度为n 的无序序列看成 是 n 个长度为 1 的有序子序列 ，首先做两两归 并，得到 n/2 个长度为 2 的子序列；再做两两 归并，…，如此重复，直到最后得到一个长度为 n
的有序序列。
归并排序
初始序列
[49] [38] [65] [97 [76] [13] [27]
第一步 第二步
T(1)=1 T(n)=kT(n/m)+f(n)
2019/10/20
归并排序时间复杂性分析
• 合并趟数： log2n • 每趟进行比较的代价 n • 总的代价为 T(n) = O ( nlog2n ) • 在一般情况下：
c
n=1
T(n) =
T( n/2 ) + T( n/2 ) + cn n>1
优缺点：Ω的这个定义的优点是与O的定义对称，缺点 是当 f(N) 对自然数的不同无穷子集有不同的表达式， 且有不同的阶时，未能很好地刻画出 f(N)的下界。
2019/10/20
f(n) cg(n)
n0
n
2019/10/20
代入法解递归方程
方法的关键步骤在于预先对解答作出推测，然后用 数学归纳法证明推测的正确性。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
合肥学院计算机科学与技术系课程设计报告2017〜2018 学年第一学期课程课程设计名称学生姓名学号数据结构与算法内部排序算法比较操彦1504012027指导教师2017 年9 月1、问题分析和任务定义各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶，或大概执行时间，存在一定的却缺陷。
我们将通过随机的数据比较各算法的关键字比较次数和关键字移动次数，以取得直观感受。
所设计的程序应能够将产生的随机数据同时用不同的内部排序算法排序，并列出关键字比较次数与移动次数，方便比较。
待排序表的表长不少于100，为方便起见，我们令表长等于100，用5组随机的数据排序的结果作比较。
2、数据结构的选择和概要设计一.可能排序表的抽象数据类型定义:ADT OrderableList {数据对象：D=個€ IntegerSet , i=1 , 2, ........... , n, n>0}数据关系：R1= { 已:| 丘:—L,机| € D,i=2, n}基本操作：Ini tList (n)操作结果：构造一个长度为n,元素值依次为1, 2, ....... , n的有序表。
Ran domizeList(d,is In verseOrder)操作结果：首先根据islnverseOrder 为True或False，将表置为逆序或正序，然后将表进行d (0< d< 8)级随机打乱。
d为0时表不打乱，d越大，打乱程度越高。
RecallList ()操作结果：恢复最后一次用Ran domizeList随机大乱的可排序表。
ListLe ngth ()操作结果：返回可排序的长度。
ListEmpty ()操作结果：若可排序表为空表，则返回True，否则返回False。
BubbleSort (&c, &s)操作结果：进行冒泡排序，返回关键字比较次数c和移动次数s。
InsertSort (&c, &s)操作结果：进行插入排序，返回关键字比较次数c和移动次数S。
SelectSort (&c, &s)操作结果：进行选择排序，返回关键字比较次数c和移动次数S。
Quicksort ( &c, &s)操作结果：进行快速排序，返回关键字比较次数c和移动次数S。
ShellSort ( &c, &s)操作结果：进行希尔排序，返回关键字比较次数c和移动次数S。
HeapSort ( &c，&s)操作结果：进行堆排序，返回关键字比较次数c和移动次数s。
ListTraveres ( visit() )操作结果：依次对L中的每个元素调用函数visit ()。
} ADT OrderableList二.概要设计：1.冒泡排序：冒泡排序的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。
即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。
然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。
至此第一趟结束，将最大的数放到了最后。
在第二趟：仍从第一对数开始比较（因为可能由于第 2 个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。
如此下去，重复以上过程，直至最终完成排序。
2.直接插入排序：直接插入排序是一种最简单的排序方法，它的基本操作是将一个记录插入到已牌号序的有序表中，从而得到一个新的、记录数增1的有序表。
3.简单选择排序：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环。
4.希尔排序：希尔排序又称“缩小增量排序”，它也是一种属插入排序类的方法，但在时间效率上较前述集中排序方法有较大的改进。
它的基本思想是：先将整个待排序记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行一次直接插入排序。
5.堆排序：由二叉堆的定义可知，堆顶元素（即二叉堆的根节点）一定为堆中的最大值或最小值，因此如果我们输出堆顶元素后，将剩余的元素再调整为二叉堆，继而再次输出堆顶元素，再将剩余的元素调整为二叉堆，反复执行该过程，这样便可输出一个有序序列，这个过程我们就叫做堆排序。
般所用到的是2-路归并排序，即将含有n个元素的序列看成是n个有序的子序列，每个子序列的长度为1,而后两两合并，得到n/2个长度为2或1的有序子序列，再进行两两合并。
直到最后由两个有序的子序列合并成为一个长度为n的有序序列。
2-路归并的核心操作是将一维数组中前后相邻的两个有序序列归并为一个有序序列。
7.快速排序：快速排序的基本实现思想就是将当前待排序列分成两个部分、一个值。
一个值：就是选定出一个值作为被比较的元素。
两个部分：所有比该被选定元素大的部分都去该元素的右边，所有比被选定元素小的部分都去该元素的左边。
这样我们就确定了该元素在这个待排序列中的位置，其实也就是我们已经将这个元素“排好了”。
3、详细设计和编码1.冒泡排序：void gen sort(i nt b[],i nt n){int i,j;i nt s=0,t=0;for(i=0;i< n-1;i++){for(j=i+1;j <n ;j++){t++;if(b[i]>b[j]){int temp=b[i];b[i]=b[j];b[j]=temp;s+=3;}}} cout<<"移动次数="<<s<<","<<"比较次数="<<t<<endl;2.直接插入排序：void insertsort(sqlist b,int n){int i,j;int s=0,t=0;for(i=2;i<n;i++){b[0]=b[i];s++;j=i-1;t++;while(b[0].key<b[j].key){b[j+1]=b[j];j--;s++;t++;}b[j+1]=b[0];s++;}cout<<" 移动次数="<<s<<","<<" 比较次数="<<t<<endl; }3.简单选择排序：void gentsort(int b[],int n){int i,j,k;int s=0,t=0;for(i=0;i<n-1;i++){k=i;for(j=i+1;j<n;j++){t++;if(b[k]>b[j]){k=j;}}if(k!=i){int temp=b[k];b[k]=b[i];b[i]=temp;s+=3;}}cout<<" 移动次数="<<s<<","<<" 比较次数="<<t<<endl; }4.希尔排序：void shellsort(sqlist b,int n){int i,j,gap;rec x;int s=0,t=0;gap=n/2;while(gap>0) {for(i=gap+1;i<n;i++)li-T'g a p 八 whi-euvo)宀H +if(bm.keyvbu+gapLkey)宀xubEbullbu+gapkb u +g a p ll x li-s-a p 八S +U 3 八 e -s e li-o 八 gapugapQ)}C O U A A-<轻資蒲 H -A A W A A ---A A -民超資蒲 H -A A A A e n d r5・1^"voidsift(sq=sfrjnfsjnfm)宀in二recxx*-srf o r 〒2*s A um j f 2)S ++a A m QO QO (E •keyA r 1?二• key))++"q ++if (一(x.keyAE.key))break 八二 s H r s s 丄 P++}r[s]=x;p++;}void heapsort(sqlist &r,int m){int i;rec w;for(i=m/2;i>0;--i)sift(r,i,m);for(i=m;i>1;--i){w=r[i];r[i]=r[1];r[1]=w;p+=3;sift(r,1,i-1);}}void sorting(sqlist &r,int t){BeforeSort();heapsort(r,t);display(p,q);}void init(int a[]){// 随机生成N 个整数并int i; srand ( ( unsigned int ) time ( NULL ) );for(i=0;i<N;i++)a[i]=rand()%99+1;6. 归并排序：#include <stdio.h>void cutTwo(int sourceArr[],int *tempArr[],int start,int end);void merge(int sourceArr[],int *tempArr[],int start,int mid,int end);int main(int argc, char *argv[]){int a[8]={50, 10, 20, 30, 70, 40, 80, 60};int *b[8]={};int i;cutTwo(a,b,0,8);for(i=0;i<8;i++){printf("%d ",a[i]);}return 0;}/*归并排序算法：*/void merge(int sourceArr[],int *tempArr[],int start,int mid,int end){ // 当前我们有一个源数组，我们在比较时将这个源数组一分为二进行比较归并排序/*start 指向左边部分的开始位置，mid+1 指向右边部分的开始位置，我们还需要一个k 的下标，用于存储我们交换过来的数组到临时数组tempArr[]*/int i=start; // 定义一个i 下标，用于表示左边部分开始的位置下标int j=mid+1; // 定义一个j 下标，用于表示右边部分开始的位置下标int k=0;/*因为我们在比较时是不断的比较，直到一个子序列到达最后，所以我们应该用while 循环来做，结束条件：无非就是左边序列到头了或者是右边序列到头了，即：i<=mid&&j<=end 只有在这两个条件都成立的条件下说明两个子序列都没有到头*/while(i<=mid&&j<=end){ // 当i=mid+1 或者j=end+1 时说明子序列中有一个到头了，则跳出循环if(sourceArr[i]<=sourceArr[j]){ // 表示当前i 比较小，那么我们就将小的值赋给ktempArr[k]=sourceArr[i];k=k+1;i=i+1;}else{tempArr[k]=sourceArr[j];k=k+1;j=j+1;}/*不能将k,i,j 的加1操作放在if else 判断的外面，因为我们在进行比较的时候，只是将下标所指的数字小的放在左边，将下标所指的数字大的不动，因为我们小的下标加 1 后还要和刚才下标所指的数字再次进行比较，如果放在外面，那么我们的比较的对象不对了(因为的大的数字的下标加 1 了，前面的一个数字没有进行比较)*/}/*当有一个子序列到头以后，我们就要将剩余没到头的子序列的剩余元素放到k 的右边，因为剩余的肯定是已经有序的，且肯定比已经到头的子序列的全部元素都要大的。