实验9 排序算法实验
排序算法设计实验报告
一、实验目的1. 理解排序算法的基本原理和常用算法。
2. 通过编程实现几种常见的排序算法。
3. 分析不同排序算法的性能，比较其优缺点。
4. 培养编程能力和算法思维能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.73. 开发工具：PyCharm三、实验内容1. 算法选择：冒泡排序、选择排序、插入排序、快速排序、归并排序2. 实现排序算法3. 分析算法性能4. 比较不同排序算法的优缺点四、实验步骤1. 设计排序算法（1）冒泡排序冒泡排序是一种简单的排序算法，其基本思想是通过比较相邻元素的值，将较大的元素向后移动，较小的元素向前移动，直到整个序列有序。
（2）选择排序选择排序的基本思想是遍历整个序列，在未排序的序列中找到最小（大）元素，将其与序列的第一个元素交换，然后继续在剩余未排序的序列中找到最小（大）元素，重复此过程，直到整个序列有序。
（3）插入排序插入排序的基本思想是将未排序的序列中的元素插入到已排序的序列中，直到整个序列有序。
（4）快速排序快速排序是一种高效的排序算法，其基本思想是选取一个基准值，将序列分为两部分，一部分小于基准值，另一部分大于基准值，然后递归地对这两部分进行快速排序。
（5）归并排序归并排序是一种分治策略的排序算法，其基本思想是将序列划分为两个子序列，分别对这两个子序列进行排序，然后将排序好的子序列合并为一个有序序列。
2. 编写排序算法代码```pythondef bubble_sort(arr):n = len(arr)for i in range(n):for j in range(0, n-i-1):if arr[j] > arr[j+1]:arr[j], arr[j+1] = arr[j+1], arr[j]def selection_sort(arr):n = len(arr)for i in range(n):min_idx = ifor j in range(i+1, n):if arr[min_idx] > arr[j]:min_idx = jarr[i], arr[min_idx] = arr[min_idx], arr[i]def insertion_sort(arr):n = len(arr)for i in range(1, n):key = arr[i]j = i-1while j >= 0 and key < arr[j]:arr[j+1] = arr[j]j -= 1arr[j+1] = keydef quick_sort(arr):if len(arr) <= 1:return arrpivot = arr[len(arr) // 2]left = [x for x in arr if x < pivot]middle = [x for x in arr if x == pivot]right = [x for x in arr if x > pivot]return quick_sort(left) + middle + quick_sort(right) def 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):result = []i = j = 0while i < len(left) and j < len(right):if left[i] < right[j]:result.append(left[i])i += 1else:result.append(right[j])j += 1result.extend(left[i:])result.extend(right[j:])return result```3. 分析算法性能（1）冒泡排序冒泡排序的时间复杂度为O(n^2)，空间复杂度为O(1)。
排序算法堆栈实验报告
一、实验目的1. 理解堆栈的基本原理和操作。
2. 掌握堆栈在排序算法中的应用。
3. 比较和分析不同排序算法的性能。
二、实验内容本次实验主要围绕堆栈在排序算法中的应用展开，包括以下内容：1. 使用堆栈实现冒泡排序。
2. 使用堆栈实现快速排序。
3. 使用堆栈实现归并排序。
4. 对比分析三种排序算法的性能。
三、实验原理堆栈是一种后进先出（LIFO）的数据结构，主要操作包括入栈（push）、出栈（pop）和查看栈顶元素（peek）。
在排序算法中，堆栈可以用来存储元素，实现排序过程中元素的临时存放和恢复。
四、实验步骤1. 冒泡排序（1）将待排序的元素入栈。
（2）依次出栈两个元素，比较它们的值，如果顺序错误，则将它们重新入栈，并交换位置。
（3）重复步骤（2），直到所有元素排序完成。
2. 快速排序（1）选择一个枢轴元素。
（2）将小于枢轴的元素入左子栈，大于枢轴的元素入右子栈。
（3）递归地对左子栈和右子栈进行快速排序。
3. 归并排序（1）将待排序的元素分成若干个大小为1的子序列。
（2）两两合并子序列，生成大小为2的序列。
（3）重复步骤（2），直到所有子序列合并成一个有序序列。
五、实验结果与分析1. 冒泡排序冒泡排序的时间复杂度为O(n^2)，空间复杂度为O(1)。
由于堆栈的使用，冒泡排序的执行时间略有增加，但总体性能影响不大。
2. 快速排序快速排序的平均时间复杂度为O(nlogn)，最坏情况下的时间复杂度为O(n^2)。
堆栈的使用提高了快速排序的常数因子，但整体性能仍然优于冒泡排序。
3. 归并排序归并排序的时间复杂度和空间复杂度均为O(nlogn)。
由于堆栈的使用，归并排序的常数因子有所增加，但整体性能依然保持较高水平。
六、实验结论1. 堆栈在排序算法中可以有效地实现元素的临时存放和恢复，提高排序效率。
2. 在不同排序算法中，堆栈的应用效果有所不同。
冒泡排序和快速排序的性能受堆栈影响较小，而归并排序的性能受堆栈影响较大。
算法课设实验报告(3篇)
第1篇一、实验背景与目的随着计算机技术的飞速发展，算法在计算机科学中扮演着至关重要的角色。
为了加深对算法设计与分析的理解，提高实际应用能力，本实验课程设计旨在通过实际操作，让学生掌握算法设计与分析的基本方法，学会运用所学知识解决实际问题。
二、实验内容与步骤本次实验共分为三个部分，分别为排序算法、贪心算法和动态规划算法的设计与实现。
1. 排序算法（1）实验目的：熟悉常见的排序算法，理解其原理，比较其优缺点，并实现至少三种排序算法。
（2）实验内容：- 实现冒泡排序、快速排序和归并排序三种算法。
- 对每种算法进行时间复杂度和空间复杂度的分析。
- 编写测试程序，对算法进行性能测试，比较不同算法的优劣。
（3）实验步骤：- 分析冒泡排序、快速排序和归并排序的原理。
- 编写三种排序算法的代码。
- 分析代码的时间复杂度和空间复杂度。
- 编写测试程序，生成随机测试数据，测试三种算法的性能。
- 比较三种算法的运行时间和内存占用。
2. 贪心算法（1）实验目的：理解贪心算法的基本思想，掌握贪心算法的解题步骤，并实现一个贪心算法问题。
（2）实验内容：- 实现一个贪心算法问题，如活动选择问题。
- 分析贪心算法的正确性，并证明其最优性。
（3）实验步骤：- 分析活动选择问题的贪心策略。
- 编写贪心算法的代码。
- 分析贪心算法的正确性，并证明其最优性。
- 编写测试程序，验证贪心算法的正确性。
3. 动态规划算法（1）实验目的：理解动态规划算法的基本思想，掌握动态规划算法的解题步骤，并实现一个动态规划算法问题。
（2）实验内容：- 实现一个动态规划算法问题，如背包问题。
- 分析动态规划算法的正确性，并证明其最优性。
（3）实验步骤：- 分析背包问题的动态规划策略。
- 编写动态规划算法的代码。
- 分析动态规划算法的正确性，并证明其最优性。
- 编写测试程序，验证动态规划算法的正确性。
三、实验结果与分析1. 排序算法实验结果：- 冒泡排序：时间复杂度O(n^2)，空间复杂度O(1)。
排序基本算法实验报告
一、实验目的1. 掌握排序算法的基本原理和实现方法。
2. 熟悉常用排序算法的时间复杂度和空间复杂度。
3. 能够根据实际问题选择合适的排序算法。
4. 提高编程能力和问题解决能力。
二、实验内容1. 实现并比较以下排序算法：冒泡排序、插入排序、选择排序、快速排序、归并排序、堆排序。
2. 对不同数据规模和不同数据分布的序列进行排序，分析排序算法的性能。
3. 使用C++编程语言实现排序算法。
三、实验步骤1. 冒泡排序：将相邻元素进行比较，如果顺序错误则交换，直到序列有序。
2. 插入排序：将未排序的元素插入到已排序的序列中，直到序列有序。
3. 选择排序：每次从剩余未排序的元素中选取最小（或最大）的元素，放到已排序序列的末尾。
4. 快速排序：选择一个枢纽元素，将序列分为两部分，一部分比枢纽小，另一部分比枢纽大，递归地对两部分进行排序。
5. 归并排序：将序列分为两半，分别对两半进行排序，然后将两半合并为一个有序序列。
6. 堆排序：将序列构建成一个最大堆，然后依次取出堆顶元素，最后序列有序。
四、实验结果与分析1. 冒泡排序、插入排序和选择排序的时间复杂度均为O(n^2)，空间复杂度为O(1)。
这些算法适用于小规模数据或基本有序的数据。
2. 快速排序的时间复杂度平均为O(nlogn)，最坏情况下为O(n^2)，空间复杂度为O(logn)。
快速排序适用于大规模数据。
3. 归并排序的时间复杂度和空间复杂度均为O(nlogn)，适用于大规模数据。
4. 堆排序的时间复杂度和空间复杂度均为O(nlogn)，适用于大规模数据。
五、实验结论1. 根据不同数据规模和不同数据分布，选择合适的排序算法。
2. 冒泡排序、插入排序和选择排序适用于小规模数据或基本有序的数据。
3. 快速排序、归并排序和堆排序适用于大规模数据。
4. 通过实验，加深了对排序算法的理解，提高了编程能力和问题解决能力。
六、实验总结本次实验通过对排序算法的学习和实现，掌握了常用排序算法的基本原理和实现方法，分析了各种排序算法的性能，提高了编程能力和问题解决能力。
排序的实验报告
排序的实验报告排序的实验报告引言：排序是计算机科学中常见的问题之一。
在实际应用中，我们经常需要对一组数据进行排序，以便更好地理解和分析数据。
本实验旨在比较不同排序算法的效率和性能，以及探讨它们在不同数据集上的表现。
实验设计：为了进行排序算法的比较，我们选择了五种常见的排序算法，分别是冒泡排序、选择排序、插入排序、快速排序和归并排序。
我们使用Python编程语言实现了这些算法，并在同一台计算机上运行它们以确保公平比较。
实验步骤：1. 数据集的准备我们选择了三种不同规模的数据集：小规模（100个元素）、中规模（1000个元素）和大规模（10000个元素）。
这些数据集包含了随机生成的整数。
2. 算法实现我们按照上述算法的描述，使用Python编程语言实现了这些排序算法。
为了确保准确性和效率，我们在实现过程中进行了多次测试和调试。
3. 实验运行我们分别对小规模、中规模和大规模的数据集运行这些排序算法，并记录下每个算法的运行时间。
实验结果：1. 小规模数据集排序结果对于小规模的数据集，所有的排序算法都能够在很短的时间内完成排序。
然而，快速排序和归并排序的运行时间明显短于冒泡排序、选择排序和插入排序。
2. 中规模数据集排序结果随着数据规模的增加，冒泡排序、选择排序和插入排序的运行时间显著增加，而快速排序和归并排序的运行时间仍然较短。
特别是在中规模数据集上，快速排序和归并排序的效率明显高于其他算法。
3. 大规模数据集排序结果在大规模数据集上，冒泡排序、选择排序和插入排序的运行时间急剧增加，而快速排序和归并排序的运行时间仍然保持在可接受的范围内。
这进一步证明了快速排序和归并排序的高效性。
讨论：通过对不同规模数据集的排序实验，我们可以得出以下结论：1. 快速排序和归并排序是最有效的排序算法，它们的运行时间相对较短。
2. 冒泡排序、选择排序和插入排序在小规模数据集上表现良好，但在大规模数据集上效率较低。
3. 对于特定的应用场景，选择合适的排序算法非常重要。
排序算法综合实验
排序算法综合实验一、实验目的通过上机来体验和掌握课本的有关基本知识，加深对排序算法的认识二、实验要求1．实现基本排序方法：直接插入、希尔、直接选择、冒泡、快速、堆、二路归并；2．每种基本排序方法尽量给出多种实现（包括改进）；3．给出实验结果：（1）随机生成若干个随机数进行排序（如n＝104，2＊104，105，…等），记录每个排序的时间耗费、比较次数、移动次数。
（2）分别给出正序和反序的初始序列进行排序，检验算法对初始序列的敏感程度。
（3）给出实验结果、原因分析、结论等。
（4）所有实验结果汇集成一张表。
三、几种排序算法1、直接插入排序1.1原理在排序过程中，每次都将无序区中第1条记录插入到有序区中适当位置，使其仍保持有序。
初始时，取第1条记录为有序区，其他记录为无序区。
随着排序过程的进行，有序区不断扩大，无序区不断缩小。
最终无序区为空，有序区包含了全部记录，排序结束。
1.2算法1.2.1带监视哨void InsertSort(list R,int n){int i,j;for(i=0;i<=n;i++){ //依次插入R[2],R[3],...,R[n]if(CPP,R[i].key>=R[i-1].key) continue; // R[i]大于有序区最后一个记录，不需要插入MPP,R[0]=R[i]; //R[0]是监视哨j=i-1;do{ //查找R[i]的插入位置MPP,R[j+1]=R[j];j--; //记录后移，继续向前搜索}while(CPP,R[0].key<R[j].key); //省略了条件j>=1MPP,R[j+1]=R[0]; // 插入R[i]}}1.2.2无监视哨void InsertSort2(list R,int n){ //直接插入排序，无监视哨int i,j;rectype x; //x为辅助量for(i=2;i<=n;i++){ //进行n-1次插入for(CPP,R[i].key>=R[i-1].key) continue;MPP,x=R[i]; //待排记录暂存到xj=i-1;do{ //顺序比较和移动MPP,R[j+1]=R[j];j--;} while(j>=1 && (CPP,x.key<R[j].key));MPP,R[j+1]=x; //插入R[i]}}1.2.3改进：在查找插入位置时采用二分查找，即二分插入排序void InsertSort3(list R,int n){int i,j,low,high,mid;for(i=2;i<=n;i++){ //依次插入R[2],R[3],...,R[n]if(CPP,R[i].key>=R[i-1].key) continue; //R[i]大于有序区最后一个记录，不需插入MPP,R[0]=R[i];low=1;high=i-1;while(low<=high){ //查找R[i]的插入位置mid=(low+high)/2;if(CPP,R[0].key<R[mid].key) high=mid-1;else low=mid+1;}for(j=i-1;j>=high+1;j--)MPP,R[j+1]=R[j]; //记录后移MPP,R[high+1]=R[0];}}2、希尔排序2.1原理将数据表分成若干组，所有相隔为某个“增量”的记录为一组，在各组内进行直接插入排序；初始时增量d1较大，分组较多（每组的记录数少），以后增量逐渐减少，分组减少（每组的记录数增多），直到最后增量为1（d1>d2>...>d t=1），所有记录为同一组，再整体进行一次直接插入排序。
算法排序上机实验报告
算法排序上机实验报告排序算法是计算机科学中非常重要的一种算法，它能够对一组数据进行有序排列，方便后续的数据查找和处理。
在本次实验中，我们主要学习了五种不同的排序算法，并分别对它们进行了测试和分析。
这五种算法分别是冒泡排序、插入排序、选择排序、快速排序和归并排序。
首先，我们来看冒泡排序算法。
冒泡排序算法的核心思想是通过相邻元素的比较和交换，每次将最大的元素沉到序列的末尾。
在实验中，我们首先随机生成了一个包含100个不重复整数的数组，并使用冒泡排序算法对其进行排序。
实验结果表明，冒泡排序的时间复杂度为O(n^2)，其中n代表数组的长度。
这是因为冒泡排序需要进行n-1趟比较和交换，每趟比较都需要遍历整个序列。
其次，我们来看插入排序算法。
插入排序算法的核心思想是将待排序的元素逐个插入已排序的序列中。
在实验中，我们同样使用了包含100个不重复整数的数组，并使用插入排序算法对其进行排序。
实验结果表明，插入排序的时间复杂度为O(n^2)，其中n代表数组的长度。
插入排序的最好情况下，即数组已经完全有序时，时间复杂度可以降低为O(n)。
接下来，我们来看选择排序算法。
选择排序算法的核心思想是每一趟都从待排序的序列中选择最小（或最大）的元素，然后将其放到已排序的序列的末尾。
在实验中，我们同样使用了包含100个不重复整数的数组，并使用选择排序算法对其进行排序。
实验结果表明，选择排序的时间复杂度为O(n^2)，其中n代表数组的长度。
选择排序的优势是每一趟只需要进行一次交换，所以在某些情况下比冒泡排序更快。
然后，我们来看快速排序算法。
快速排序算法的核心思想是通过一趟排序将待排序的序列分割成独立的两部分，其中一部分的所有元素都比另一部分的元素小。
然后再对这两部分分别进行排序，重复以上过程，直到整个序列有序。
在实验中，我们同样使用了包含100个不重复整数的数组，并使用快速排序算法对其进行排序。
实验结果表明，快速排序的时间复杂度为O(nlogn)，其中n代表数组的长度。
排序算法实训报告
一、实验目的通过本次实训，掌握常用的排序算法，包括直接插入排序、冒泡排序、选择排序、希尔排序等，并了解其基本原理、实现方法以及优缺点。
通过实际编程，加深对排序算法的理解，提高编程能力。
二、实验环境1. 开发工具：Visual Studio 20222. 编程语言：C++3. 操作系统：Windows 10三、实验内容本次实训主要涉及以下排序算法：1. 直接插入排序2. 冒泡排序3. 选择排序4. 希尔排序四、实验过程1. 直接插入排序（1）原理：将无序序列中的元素逐个插入到已有序序列的合适位置，直到整个序列有序。
（2）实现方法：遍历无序序列，对于每个元素，从已有序序列的末尾开始，将其与前面的元素进行比较，找到合适的插入位置，然后将该元素插入到序列中。
（3）代码实现：```cppvoid insertionSort(int arr[], int n) {int i, j, key;for (i = 1; i < n; i++) {key = arr[i];j = i - 1;while (j >= 0 && arr[j] > key) {arr[j + 1] = arr[j];j = j - 1;}arr[j + 1] = key;}}```2. 冒泡排序（1）原理：通过相邻元素的比较和交换，将序列中的元素按从小到大（或从大到小）的顺序排列。
（2）实现方法：遍历序列，比较相邻元素，如果顺序错误，则交换它们的位置。
重复此过程，直到整个序列有序。
（3）代码实现：```cppvoid bubbleSort(int arr[], int n) {int i, j, temp;for (i = 0; i < n - 1; i++) {for (j = 0; j < n - i - 1; j++) {if (arr[j] > arr[j + 1]) {temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}}```3. 选择排序（1）原理：每次从无序序列中选出最小（或最大）的元素，放到已有序序列的末尾。
排序的应用实验报告
排序的应用实验报告实验题目：排序的应用实验一、实验目的：1. 了解排序算法的基本原理和应用场景；2. 掌握常见的排序算法的实现方法；3. 熟悉排序算法的时间复杂度分析；4. 在实际应用中灵活运用排序算法。
二、实验原理：排序是将一组数据按照某个规则进行重新排列的过程，常见的排序算法有冒泡排序、选择排序、插入排序、归并排序、快速排序、堆排序等。
每种排序算法有其特点和适用场景，掌握不同排序算法的实现方法和时间复杂度对于实际应用非常重要。
三、实验内容及步骤：1. 冒泡排序实验：a) 随机生成一组整数数据；b) 利用冒泡排序算法对数据进行排序；c) 输出排序结果，并统计排序过程中的比较次数和交换次数。
2. 选择排序实验：a) 随机生成一组整数数据；b) 利用选择排序算法对数据进行排序；c) 输出排序结果，并统计排序过程中的比较次数和交换次数。
3. 插入排序实验：a) 随机生成一组整数数据；b) 利用插入排序算法对数据进行排序；c) 输出排序结果，并统计排序过程中的比较次数和移动次数。
4. 归并排序实验：a) 随机生成一组整数数据；b) 利用归并排序算法对数据进行排序；c) 输出排序结果。
5. 快速排序实验：a) 随机生成一组整数数据；b) 利用快速排序算法对数据进行排序；c) 输出排序结果。
四、实验结果及分析：1. 冒泡排序实验结果：随机生成的一组整数数据为：[5, 3, 8, 2, 6]排序过程中的比较次数为：10排序过程中的交换次数为：4排序结果为：[2, 3, 5, 6, 8]2. 选择排序实验结果：随机生成的一组整数数据为：[5, 3, 8, 2, 6] 排序过程中的比较次数为：10排序过程中的交换次数为：4排序结果为：[2, 3, 5, 6, 8]3. 插入排序实验结果：随机生成的一组整数数据为：[5, 3, 8, 2, 6] 排序过程中的比较次数为：10排序过程中的移动次数为：7排序结果为：[2, 3, 5, 6, 8]4. 归并排序实验结果：随机生成的一组整数数据为：[5, 3, 8, 2, 6] 排序结果为：[2, 3, 5, 6, 8]5. 快速排序实验结果：随机生成的一组整数数据为：[5, 3, 8, 2, 6]排序结果为：[2, 3, 5, 6, 8]五、实验总结：通过本次实验，我对常见的排序算法有了更深入的了解。
排序算法设计实验报告总结
排序算法设计实验报告总结1. 引言排序算法是计算机科学中最基础的算法之一，它的作用是将一组数据按照特定的顺序进行排列。
在现实生活中，我们经常需要对一些数据进行排序，比如学生成绩的排名、图书按照标题首字母进行排序等等。
因此，了解不同的排序算法的性能特点以及如何选择合适的排序算法对于解决实际问题非常重要。
本次实验旨在设计和实现几种经典的排序算法，并对其进行比较和总结。
2. 实验方法本次实验设计了四种排序算法，分别为冒泡排序、插入排序、选择排序和快速排序。
实验采用Python语言进行实现，并通过编写测试函数对算法进行验证。
测试函数会生成一定数量的随机数，并对这些随机数进行排序，统计算法的执行时间和比较次数，最后将结果进行记录和分析。
3. 测试结果及分析3.1 冒泡排序冒泡排序是一种简单且常用的排序算法，其基本思想是从待排序的数据中依次比较相邻的两个元素，如果它们的顺序不符合要求，则交换它们的位置。
经过多轮的比较和交换，最小值会逐渐冒泡到前面。
测试结果显示，冒泡排序在排序1000个随机数时，平均执行时间为0.981秒，比较次数为499500次。
从执行时间和比较次数来看，冒泡排序的性能较差，对于大规模数据的排序不适用。
3.2 插入排序插入排序是一种简单但有效的排序算法，其基本思想是将一个待排序的元素插入到已排序的子数组中的正确位置。
通过不断将元素插入到正确的位置，最终得到排序好的数组。
测试结果显示，插入排序在排序1000个随机数时，平均执行时间为0.892秒，比较次数为249500次。
插入排序的性能较好，因为其内层循环的比较次数与待排序数组的有序程度相关，对于近乎有序的数组排序效果更好。
3.3 选择排序选择排序是一种简单但低效的排序算法，其基本思想是在待排序的数组中选择最小的元素，将其放到已排序数组的末尾。
通过多次选择和交换操作，最终得到排序好的数组。
测试结果显示，选择排序在排序1000个随机数时，平均执行时间为4.512秒，比较次数为499500次。
排序实验报告
实验五排序实验目的: 掌握几种排序的思想及算法问题分析：(一)直接插入排序1. 排序思想将待排序的记录Ri，插入到已排好序的记录表R1, R2 ,…., Ri-1中，得到一个新的、记录数增加1的有序表。
直到所有的记录都插入完为止。
设待排序的记录顺序存放在数组R[1…n]中，在排序的某一时刻，将记录序列分成两部分：◆R[1…i-1]：已排好序的有序部分；◆R[i…n]：未排好序的无序部分。
显然，在刚开始排序时，R[1]是已经排好序的。
2 . 算法实现void straight_insert_sort(Sqlist R){ int i, j ;for (i=2; i<=n; i++){ R[0]=R[i]; j=i-1; /*设置哨兵*/while( LT(R[0].key, R[j].key) ){ R[j+1]=R[j];j--;} /* 查找插入位置*/R[j+1]=R[0]; /* 插入到相应位置*/}}（二）希尔排序1. 排序思想①先取一个正整数d1(d1<n)作为第一个增量，将全部n个记录分成d1组，把所有相隔d1的记录放在一组中，即对于每个k(k=1, 2, … d1)，R[k], R[d1+k], R[2d1+k] , …分在同一组中，在各组内进行直接插入排序。
这样一次分组和排序过程称为一趟希尔排序；②取新的增量d2<d1，重复①的分组和排序操作；直至所取的增量di=1为止，即所有记录放进一个组中排序为止。
2. 算法实现先给出一趟希尔排序的算法，类似直接插入排序。
void shell_pass(Sqlist R, int d)/* 对顺序表L进行一趟希尔排序, 增量为d */{ int j, k ;for (j=d+1; j<=n; j++){ R[0]=R[j] ; /* 设置监视哨兵*/k=j-d ;while (k>0&<(R[0].key, R[k].key) ){ R[k+d]=R[k] ; k=k-d ; }R[k+d]=R[0] ;}}然后在根据增量数组dk进行希尔排序。
排序_算法应用实验报告
一、实验目的本次实验旨在让学生掌握常用的排序算法，理解其原理和实现方法，并通过实际编程练习，提高算法应用能力。
实验内容主要包括：实现几种常见的排序算法，分析其性能特点，并在实际应用中进行比较。
二、实验内容1. 实现以下排序算法：（1）冒泡排序（2）选择排序（3）插入排序（4）快速排序（5）归并排序2. 对每种排序算法进行分析，包括时间复杂度、空间复杂度和稳定性。
3. 编写一个程序，对一组随机生成的数据使用上述排序算法进行排序，并记录每种算法的执行时间。
4. 分析实验结果，总结不同排序算法的性能特点。
三、实验步骤1. 实现冒泡排序、选择排序、插入排序、快速排序和归并排序算法。
2. 编写一个函数，用于生成随机数据。
3. 编写一个函数，用于测试每种排序算法的执行时间。
4. 对每种排序算法进行分析，包括时间复杂度、空间复杂度和稳定性。
5. 运行程序，记录每种算法的执行时间。
6. 分析实验结果，总结不同排序算法的性能特点。
四、实验结果与分析1. 冒泡排序冒泡排序是一种简单的排序算法，基本思想是：比较相邻的元素，如果它们的顺序错误就把它们交换过来。
重复这个过程，直到没有再需要交换的元素为止。
时间复杂度：O(n^2)空间复杂度：O(1)稳定性：稳定2. 选择排序选择排序是一种简单直观的排序算法，它的工作原理是：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
以此类推，直到所有元素均排序完毕。
时间复杂度：O(n^2)空间复杂度：O(1)稳定性：不稳定3. 插入排序插入排序是一种简单直观的排序算法，它的工作原理是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增加1的有序表。
时间复杂度：O(n^2)空间复杂度：O(1)稳定性：稳定4. 快速排序快速排序是一种分而治之的排序算法，它将大问题分解为小问题来解决。
基本思想是：从数组中选取一个元素作为基准（pivot），将数组分为两个子数组，一个子数组的所有元素都比基准小，另一个子数组的所有元素都比基准大。
排序算法比较实验报告
信息学部算法分析上机报告学号0901********姓名陈龙_________ 扌旨导老师秦明_________ 时间2011.11.1~11.23上机实验题目实验1 比较归并排序和快速排序的区别。
实验2 利用贪心算法对背包问题进行求解算法设计思路归并排序：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列，设定两个指针，最初位置分别为两个已经排序序列的起始位置，比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置，重复步骤直到某一指针达到序列尾，将另一序列剩下的所有元素直接复制到合并序列尾。
快速排序：设置两个变量I、J,排序开始的时候：1=0, J=N-1;以第一个数组元素作为关键数据，赋值给key,即key=A[0]；从J开始向前搜索，即由后开始向前搜索（J=J-1），找到第一个小于key的值A[J]，并与key交换；从I开始向后搜索，即由前开始向后搜索（I=I+1），找到第一个大于key的A[I]，与key交换；重复第3、4、5 步，直到I=J；（3,4 步是在程序中没找到时候j=j-1 ，i=i+1 ，直至找到为止。
找到并交换的时候i，j指针位置不变。
另外当i=j这过程一定正好是i+或j-完成的最后另循环结束。
）背包问题：用子问题定义状态：即f[i][v] 表示前i 件物品恰放入一个容量为v 的背包可以获得的最大价值。
则其状态转移方程便是：f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]+w[i]} 。
可以压缩空间，f[v]=max{f[v],f[v-c[i]]+w[i]}三. 源程序归并排序#include<stdio.h> #include<stdlib.h># define N 50 int b[N],a[N]; int n,i;void Merge (int low, int mid,int high) // {int i; int l=low,h=mid+1,k=l;while ((l<=mid) && (h<=high)) // {if (a[l]<=a[h]) b[k++]=a[l++];else b[k++]=a[h++];} if(l>mid) while (h<=high) b[k++]=a[h++];// else while(l<=mid) b[k++]=a[l++]; for(i=0;i<=high;i++) // a[i]=b[i];}int Merge2 (int l,int h) //{for (i=0;i<n;i++) printf("%d ",a[i]);printf("\n");int m; if (l<h){ m=(l+h)/2; Merge2(l, m); Merge2(m+1,h); Merge ( l,m,h);} return a[i];}合并部分合并转储剩余部分将b 数组转储到a 分类void main(){printf(" 请输入您要排序的数组大小(不超过 50)： ");while (scanf("%d",&n)!=EOF){for (i=0;i<n;i++)scanf("%d",&a[i]); Merge2(0,n-1); for (i=0;i<n-1;i++)printf("%d ",a[i]); printf("%d\n",a[n-1]);}}temp=list[i+1]; list[++i]=list[j-1]; list[--j]=temp;快速排序#include "stdio.h" #include "stdlib.h" # define N 50 int a[N]; int i,n;void Quick(int list[ ], int left, int right) //lfet{int s; int i, j; int temp; for (i=0;i<n;i++)printf("%d ",a[i]); printf("\n"); if(left < right) //{s = list[left]; i = left-1; j = right + 1; while(i+1!=j){if(list[i+1]<=s)i++; else if(list[j-1]>s)j--; else为数组最左端 , right 如果没有查询完所有数组， 为数组最右端则继续递归}{} list[left] = list[i]; list[i] = s;Quick(list, left, i - 1); //Quick(list, i + 1, right); // }}void main(){printf(" 请输入您要排序的数组大小(不超过while(scanf("%d",&n)!=EOF){for (i=0;i<n;i++) scanf("%d",&a[i]);Quick(a,0,n-1);for (i=0;i<n-1;i++) printf("%d ",a[i]);printf("%d\n",a[n-1]);}}背包问题#include <stdio.h>#include <stdlib.h> #define N 3 struct Thing{int num ;int price;int weight;float aver;};void swap(int *i,int *j){int temp;temp = *i;*: 一*i = *j;*j = temp;}int main()int M;int i,j,k=0,NUM = 1;对左边递归对右边递归50)：");struct Thing *p = (struct Thing *)malloc(N*sizeof(struct Thing));printf(" 请输入背包能承受的重量："); scanf("%d",&M);printf("\n");for(i=0;i<N;++i){// printf(" 请输入物品序列号(请从1 开始顺序加1):");// scanf("%d",&p[i].num);p[i].num = NUM++;printf(”请输入％d号物品的价值：",p[i].num);scanf("%d",&p[i].price);printf(" 请输入％d号物品的重量:",p[i].num); scanf("%d",&p[i].weight);p[i].aver = ((float)p[i].price / (float)p[i].weight);}for(i = 0;i<N-1;i++){for(j = i+1;j<N;j++){if(p[i].aver<p[j].aver){swap(&p[i].num,&p[j].num); swap(&p[i].price,&p[j].price);swap(&p[i].weight,&p[j].weight);}}}printf("\n");printf(" 按照物品单位重量的价值从大到小排序为：\n");for(i = 0;i<N;i++){printf(" 事件序列号：%d ",p[i].num);printf(" 物品价值%d ",p[i].price);printf(" 物品重量%d ",p[i].weight);printf("\n");}printf("\n");printf("\n");while(1){if(M > p[k].weight){printf(" 先装入％d号码的物品％d的重量,\n",p[k].num,p[k].weight); M = M -p[k].weight;k++;}elsebreak;}printf(”再装入％4号的物品％d的重量\n",p[k].num,M);printf("\n");printf("\n");free(p);return 0;}三.实验结果归并排序*C: \DocuMents and Sett ings\Ad>inist rat or\桌面l算法l算法l算i£\Debug\归并-睛输入您要输入的数组大小〔不超过讯）：石122353424332541223534243325412235342433254122353424332541223534243325412235342433254122353424332541223534243325412235342433254122353424332541223534243325412235342324354123243 54 235 :342快速排序背包问题 -品品品 物物物3 2 13位...按3 4 5 62 6炸.勺.炸.勺.炸.勺. 1■- ■- - 1■- ■- - 1■- ■- - 1■- ■- - 1■- ■- - 1品,,□-83品品品-2 量量量加36物物物品 重重重删品的的的物 勺.勺.勺.卯：.马.马.马.灯. 託弘黑的量量量--3- ---3----3--_ _-s -品品品号•■菲 物物物馨I H J -—--I H J- L b00码码码6817 口¥¥万33521I先先先先先先先菁五.实验心得通过实验可以知道，若数据比较无序，快排快，若数据中部分有序，归并快。
排序实验报告的结果总结(3篇)
第1篇一、实验背景随着计算机科学和信息技术的发展，排序算法在数据处理的领域中扮演着至关重要的角色。
本实验旨在通过对比几种常见的排序算法，分析它们的性能差异，为实际应用中选择合适的排序算法提供参考。
二、实验目的1. 熟悉几种常见排序算法的基本原理和实现方法。
2. 分析不同排序算法的时间复杂度和空间复杂度。
3. 比较不同排序算法在不同数据规模下的性能差异。
4. 为实际应用提供选择排序算法的依据。
三、实验方法1. 选择实验数据：随机生成一组包含10000个整数的数组，分别用于测试不同排序算法的性能。
2. 实现排序算法：分别实现冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序等常见排序算法。
3. 性能测试：分别对每组实验数据进行排序，记录每种排序算法的运行时间。
4. 数据分析：对比不同排序算法的时间复杂度和空间复杂度，分析其性能差异。
四、实验结果1. 冒泡排序冒泡排序的时间复杂度为O(n^2)，空间复杂度为O(1)。
在测试数据规模为10000时，冒泡排序的运行时间为234.5秒。
2. 选择排序选择排序的时间复杂度为O(n^2)，空间复杂度为O(1)。
在测试数据规模为10000时，选择排序的运行时间为237.1秒。
3. 插入排序插入排序的时间复杂度为O(n^2)，空间复杂度为O(1)。
在测试数据规模为10000时，插入排序的运行时间为239.8秒。
4. 快速排序快速排序的平均时间复杂度为O(nlogn)，空间复杂度为O(logn)。
在测试数据规模为10000时，快速排序的运行时间为18.5秒。
5. 归并排序归并排序的时间复杂度为O(nlogn)，空间复杂度为O(n)。
在测试数据规模为10000时，归并排序的运行时间为20.3秒。
6. 堆排序堆排序的时间复杂度为O(nlogn)，空间复杂度为O(1)。
在测试数据规模为10000时，堆排序的运行时间为19.7秒。
五、结果分析1. 时间复杂度方面：快速排序、归并排序和堆排序的平均时间复杂度均为O(nlogn)，优于冒泡排序、选择排序和插入排序的O(n^2)时间复杂度。
重排九宫实验报告
重排九宫实验报告重排九宫算法实验报告1实验⽬的运⽤搜索算法重排九宫使之从初始状态到底⽬标状态，并求解最短路径。
2 实验内容⽤三种不同的搜索算法实现重排九宫。
本实验⽤的⽅法分别是：A*算法、有界深度优先搜索和⼴度优先搜索。
3 实验原理启发式搜索是在搜索中加⼊了与问题有关的启发性信息，⽤以指导搜索朝着最有希望的⽅向前进，加速问题的求解过程并找到最优解。
A*算法是⼀种启发式搜索。
⼴度优先搜索按照“先扩展出的节点先被考察”的原则进⾏搜索。
深度优先搜索按照“后扩展出的节点先被考察”的原则进⾏搜索。
有界深度优先搜索的原则与深度优先搜索相同，但是它规定了深度限界，使搜索不得⽆限制地向纵深⽅向发展。
4解存在算法如下图所⽰：判断是否有解的算法如下：public class Method {public static boolean Parity(int a[]){boolean parity=true;for(int i=0;iint k=i;for(int j=i+1;jif(a[k]>a[j]){k=j;}}if(k!=i){int temp;temp=a[i];}}return parity;}public static boolean isSolutionExist(int src[],int dest[],int s[][],int d[][]){ int row1=0,row2=0,clumn1=0,clumn2=0; boolean flag1,flag2;for(int i=0;i<3;i++){for(int j=0;j<3;j++){if(s[i][j]==0){row1=i;clumn1=j;}if(d[i][j]==0){row2=i;clumn2=j;}}}if((row1-row2+clumn1-clumn2)%2==0){flag1=true;}else{flag1=false;}if(Parity(src)==Parity(dest)){flag2=true;}else{flag2=false;}if(flag1==flag2){return true;}else{return false;}节点数据结构private static class Node{int data[][]; //状态int row; //0所在⾏int clumn; //0所在列Node parent; //⽗亲节点Node(int data[][],Node parent,int row,int clumn){ this.data=data;this.parent=parent;this.row=row;this.clumn=clumn;}}运⾏截图1.初始化状态2.初始状态随机3.初始和⽬标状态都为随机6有界深度优先搜索节点数据结构private static class Node{boolean flag=false;int depth=-1;int data[][];int row;int clumn;Node parent;Node(int data[][],Node parent,int row,int clumn,int depth){ this.data=data; this.parent=parent;this.row=row;this.clumn=clumn;this.depth=depth;}运⾏截图1.7 A*算法节点数据结构private static class Node{int value; //估价函数的值int diff=0; //当前节点到⽬标节点的最⼩代价int depth=-1; //初始节点到当前节点的代价int data[][];int row;int clumn;Node parent;Node(int data[][],Node parent,int row,int clumn,int depth,int diff){ this.data=data; this.parent=parent;this.row=row;this.clumn=clumn;this.depth=depth;this.diff=diff;this.value=depth+diff;}}7 A*算法运⾏截图。
排序算法演示实验报告
排序算法演示实验报告一、实验目的本次实验旨在深入了解和比较常见的排序算法，包括冒泡排序、插入排序、选择排序、快速排序和归并排序。
通过实际的代码实现和性能分析，掌握不同排序算法的工作原理、时间复杂度和空间复杂度，以及它们在不同数据规模下的性能表现。
二、实验环境本次实验使用的编程语言为 Python 38，开发环境为 PyCharm。
实验所使用的计算机配置为：Intel Core i5 处理器，8GB 内存，Windows10 操作系统。
三、实验原理（一）冒泡排序（Bubble Sort）冒泡排序是一种简单的排序算法。
它重复地走访要排序的数列，一次比较两个数据元素，如果顺序不对则进行交换，并一直重复这样的走访操作，直到没有要交换的数据元素为止。
（二）插入排序（Insertion Sort）插入排序的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入，直到整个数组有序。
（三）选择排序（Selection Sort）首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
以此类推，直到所有元素均排序完毕。
（四）快速排序（Quick Sort）通过选择一个基准元素，将数组分为小于基准和大于基准两部分，然后对这两部分分别进行快速排序，从而实现整个数组的排序。
（五）归并排序（Merge Sort）归并排序是建立在归并操作上的一种有效、稳定的排序算法，该算法是采用分治法(Divide and Conquer）的一个非常典型的应用。
将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。
四、实验步骤（一）算法实现1、冒泡排序｀｀｀pythondef bubble_sort(arr)：n ＝ len(arr)for i in range(n)：for j in range(0, n i 1)：if arrj ＞ arrj ＋ 1 ：arrj, arrj ＋ 1 ＝ arrj ＋ 1, arrj ｀｀｀2、插入排序｀｀｀pythondef insertion_sort(arr)：for i in range(1, len(arr)）：key ＝ arrij ＝ i 1while j ＞＝ 0 and key ＜ arrj ：arrj ＋ 1 ＝ arrjj ＝ 1arrj ＋ 1 ＝ key｀｀｀3、选择排序｀｀｀pythondef selection_sort(arr)：for i in range(len(arr)）：min_idx ＝ ifor j in range(i ＋ 1, len(arr)）：if arrj ＜ arrmin_idx:min_idx ＝ jarri, arrmin_idx ＝ arrmin_idx, arri ｀｀｀4、快速排序｀｀｀pythondef partition(arr, low, high)：i ＝（low 1)pivot ＝ arrhighfor j in range(low, high)：if arrj ＜＝ pivot:i ＝ i ＋ 1arri, arrj ＝ arrj, arriarri ＋ 1, arrhigh ＝ arrhigh, arri ＋ 1 return （i ＋ 1)def quick_sort(arr, low, high)：if low ＜ high:pi ＝ partition(arr, low, high)quick_sort(arr, low, pi 1)quick_sort(arr, pi ＋ 1, high)｀｀｀5、归并排序｀｀｀pythondef merge(arr, l, m, r)：n1 ＝ m l ＋ 1n2 ＝ r mL ＝ 0 （n1)R ＝ 0 （n2)for i in range(0, n1)：Li ＝ arrl ＋ ifor j in range(0, n2)：Rj ＝ arrm ＋ 1 ＋ ji ＝ 0j ＝ 0k ＝ lwhile i ＜ n1 and j ＜ n2: if Li ＜＝ Rj:arrk ＝ Lii ＋＝ 1else:arrk ＝ Rjj ＋＝ 1k ＋＝ 1while i ＜ n1:arrk ＝ Lii ＋＝ 1k ＋＝ 1while j ＜ n2:arrk ＝ Rjj ＋＝ 1k ＋＝ 1def merge_sort(arr, l, r)：if l ＜ r:m ＝ l ＋（r l) ／／ 2merge_sort(arr, l, m)merge_sort(arr, m ＋ 1, r)merge(arr, l, m, r)｀｀｀（二）性能测试为了比较不同排序算法的性能，我们生成了不同规模的随机整数数组，并分别使用上述排序算法对其进行排序，记录每种算法的运行时间。
排序算法实验报告
排序算法实验报告排序算法实验报告引言：排序算法是计算机科学中非常重要的一部分，它能够将一组无序的数据按照特定的规则进行排列，使得数据更易于查找和处理。
本次实验旨在比较不同排序算法的性能和效率，并分析它们在不同数据规模下的表现。
一、实验背景排序算法是计算机科学中的经典问题之一，其应用广泛，包括数据库管理、搜索引擎、图像处理等领域。
在实际应用中，我们常常需要对大量数据进行排序，因此选择一种高效的排序算法对于提高程序的运行效率至关重要。
二、实验目的本次实验的主要目的是比较不同排序算法的性能和效率，并找出最适合不同数据规模的排序算法。
通过实验，我们可以了解不同排序算法的原理和特点，进一步理解算法的设计思想和时间复杂度。
三、实验方法1. 实验环境本次实验使用的是一台配置较高的个人计算机，操作系统为Windows 10，处理器为Intel Core i7，内存为8GB。
2. 实验数据为了比较不同排序算法的性能，我们选择了不同规模的随机整数数组作为实验数据，包括1000个元素、10000个元素和100000个元素。
3. 实验步骤我们选取了常见的几种排序算法进行实验，包括冒泡排序、选择排序、插入排序、希尔排序、归并排序和快速排序。
具体实验步骤如下：（1）生成随机整数数组；（2）使用不同的排序算法对数组进行排序；（3）记录每种排序算法的运行时间；（4）比较不同排序算法的性能和效率。
四、实验结果与分析在实验中，我们记录了每种排序算法的运行时间，并进行了对比分析。
下面是实验结果的总结：1. 数据规模为1000个元素时，各排序算法的运行时间如下：冒泡排序：2.3ms选择排序：1.9ms插入排序：1.6ms希尔排序：0.9ms归并排序：0.6ms快速排序：0.5ms2. 数据规模为10000个元素时，各排序算法的运行时间如下：冒泡排序：240ms选择排序：190ms插入排序：160ms希尔排序：90ms归并排序：60ms快速排序：50ms3. 数据规模为100000个元素时，各排序算法的运行时间如下：冒泡排序：23900ms选择排序：19000ms插入排序：16000ms希尔排序：9000ms归并排序：6000ms快速排序：5000ms通过对比分析，我们可以得出以下结论：（1）在不同数据规模下，归并排序和快速排序的性能表现最好，运行时间最短；（2）冒泡排序和选择排序的性能最差，运行时间最长；（3）随着数据规模的增大，各排序算法的运行时间呈指数级增长。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验报告九排序算法实验班级：姓名：学号：专业：一、实验目的：1、掌握内部排序方法的策略和排序过程。
2、掌握插入排序、选择排序、快速排序、归并排序算法。
二、实验内容：1、存储结构类定义与实现：自定义如下：package Ex8;import .apache.xpath.internal.SourceTree;/*** Created by 74062 on 2017/6/6.*/public class SortUtil {public static void main(String[] args) {int[] array1 = {5,3,8,9,1,7};int[] array2 = {7,3,8,1,4,7};int[] array3 = {10,4,6,3,8,7};int[] array4 = {81,49,19,38,97,76,13,19};insertSort(array1);show(array1);System.out.println();quickSort(array2);show(array2);System.out.println();mergeSort(array3);heapSort(array4);}public static void insertSort(int[] keys){for(int i=1;i<keys.length;i++){for(int j = i-1;j>=0;j--){if(keys[j]>keys[j+1]){int temp = keys[j];keys[j] = keys[j+1];keys[j+1] = temp;}elsebreak;}}}public static void heapSort(int[] keys){heapSort(keys,true);}//堆排序public static void heapSort(int[] keys,boolean minheap){ for(int i=keys.length/2-1;i>=0;i--)sift(keys,i,keys.length-1,minheap);for(int i=keys.length-1;i>0;i--){swap(keys,0,i);sift(keys,0,i-1,minheap);}}private static void sift(int[] keys,int parent,int end,boolean minheap){System.out.print("sift "+parent+".."+end+" ");int i = parent;int child=2*parent+1;int value=keys[parent];while(child<=end){if(child<end&&(minheap?keys[child]>keys[child+1]:keys[child]<keys[ch ild+1]))child++;if(minheap?value>keys[child]:value<keys[child]){keys[parent]=keys[child];parent=child;child=2*parent+1;}else break;}keys[parent] = value;show(keys);}public static void quickSort(int[] keys){quickSort(keys,0,keys.length-1);}private static void quickSort(int[] keys, int begin, int end){if(begin>=0&&begin<keys.length&&end>0&&end<keys.length&&begin<end){ int i = begin;int j = end;int vot = keys[i];while (i!=j){while (i<j&&keys[j]>=vot)j--;if(i<j)keys[i++] = keys[j];while (i<j&&keys[i]<=vot)i++;if(i<j)keys[j--] = keys[i];}keys[i] = vot;System.out.println(begin+".."+end+", vot="+vot+" ");quickSort(keys,begin,j-1);quickSort(keys,i+1,end);}}private static void merge(int[] X, int[] Y, int begin1, int begin2, int n){int i = begin1,j = begin2, k = begin1;while (i<begin1+n&&j<begin2+n&&j<X.length){if(X[i]<X[j])Y[k++] = X[i++];elseY[k++] = X[j++];}while (i<begin1+n&&i<X.length)Y[k++] = X[i++];while (j<begin2+n&&j<X.length)Y[k++] = X[j++];}private static void mergepass(int[] X, int[] Y, int n){ System.out.println("子序列长度n="+n+" ");for(int i=0;i<X.length;i+=2*n){merge(X,Y,i,i+n,n);}show(Y);System.out.println();}public static void mergeSort(int[] X){int[] Y = new int[X.length];int n=1;while (n<X.length){mergepass(X,Y,n);n*=2;if(n<X.length){mergepass(Y,X,n);n*=2;}}}public static void show(int[] keys){for(int i=0;i<keys.length;i++){System.out.print(keys[i]+" ");}System.out.println();}private static void swap(int[] keys, int i, int j){ int temp = keys[i];keys[i] = keys[j];keys[j] = temp;}}2、插入排序算法：public static void insertSort(int[] keys){for(int i=1;i<keys.length;i++){for(int j = i-1;j>=0;j--){if(keys[j]>keys[j+1]){int temp = keys[j];keys[j] = keys[j+1];keys[j+1] = temp;}elsebreak;}}}测试结果粘贴如下：3、选择排序中的堆排序算法：//堆排序public static void heapSort(int[] keys){heapSort(keys,true);}public static void heapSort(int[] keys,boolean minheap){ for(int i=keys.length/2-1;i>=0;i--)sift(keys,i,keys.length-1,minheap);for(int i=keys.length-1;i>0;i--){swap(keys,0,i);sift(keys,0,i-1,minheap);}}private static void sift(int[] keys,int parent,int end,boolean minheap){ System.out.print("sift "+parent+".."+end+" ");int child=2*parent+1;int value=keys[parent];while(child<=end){if(child<end&&(minheap?keys[child]>keys[child+1]:keys[child]<keys[ch ild+1]))child++;if(minheap?value>keys[child]:value<keys[child]){keys[parent]=keys[child];parent=child;child=2*parent+1;}else break;}keys[parent] = value;show(keys);}测试结果粘贴如下：4、快速排序算法//快速排序public static void quickSort(int[] keys){quickSort(keys,0,keys.length-1);}private static void quickSort(int[] keys, int begin, int end){if(begin>=0&&begin<keys.length&&end>0&&end<keys.length&&begin<end){ int i = begin;int j = end;int vot = keys[i];while (i!=j){while (i<j&&keys[j]>=vot)j--;if(i<j)keys[i++] = keys[j];while (i<j&&keys[i]<=vot)i++;if(i<j)keys[j--] = keys[i];}keys[i] = vot;System.out.println(begin+".."+end+", vot="+vot+" ");quickSort(keys,begin,j-1);quickSort(keys,i+1,end);}}测试结果粘贴如下：5、归并排序算法：6、//归并排序private static void merge(int[] X, int[] Y, int begin1, int begin2, int n){int i = begin1,j = begin2, k = begin1;while (i<begin1+n&&j<begin2+n&&j<X.length){if(X[i]<X[j])Y[k++] = X[i++];elseY[k++] = X[j++];}while (i<begin1+n&&i<X.length)Y[k++] = X[i++];while (j<begin2+n&&j<X.length)Y[k++] = X[j++];}private static void mergepass(int[] X, int[] Y, int n){System.out.println("子序列长度n="+n+" ");for(int i=0;i<X.length;i+=2*n){merge(X,Y,i,i+n,n);}show(Y);System.out.println();}public static void mergeSort(int[] X){int[] Y = new int[X.length];int n=1;while (n<X.length){mergepass(X,Y,n);n*=2;if(n<X.length){mergepass(Y,X,n);n*=2;}}}测试结果粘贴如下：三、实验心得（含上机中所遇问题的解决办法，所使用到的编程技巧、创新点及编程的心得）。