数据结构实验四题目一排序实验报告
数据结构排序实验报告
数据结构排序实验报告数据结构排序实验报告引言：数据结构是计算机科学中的重要概念之一，它涉及到数据的组织、存储和操作方式。
排序是数据结构中的基本操作之一，它可以将一组无序的数据按照特定的规则进行排列，从而方便后续的查找和处理。
本实验旨在通过对不同排序算法的实验比较，探讨它们的性能差异和适用场景。
一、实验目的本实验的主要目的是通过实际操作，深入理解不同排序算法的原理和实现方式，并通过对比它们的性能差异，选取合适的排序算法用于不同场景中。
二、实验环境和工具实验环境：Windows 10 操作系统开发工具：Visual Studio 2019编程语言：C++三、实验过程1. 实验准备在开始实验之前，我们需要先准备一组待排序的数据。
为了保证实验的公正性，我们选择了一组包含10000个随机整数的数据集。
这些数据将被用于对比各种排序算法的性能。
2. 实验步骤我们选择了常见的五种排序算法进行实验比较，分别是冒泡排序、选择排序、插入排序、快速排序和归并排序。
- 冒泡排序：该算法通过不断比较相邻元素的大小，将较大的元素逐渐“冒泡”到数组的末尾。
实现时，我们使用了双重循环来遍历整个数组，并通过交换元素的方式进行排序。
- 选择排序：该算法通过不断选择数组中的最小元素，并将其放置在已排序部分的末尾。
实现时，我们使用了双重循环来遍历整个数组，并通过交换元素的方式进行排序。
- 插入排序：该算法将数组分为已排序和未排序两部分，然后逐个将未排序部分的元素插入到已排序部分的合适位置。
实现时，我们使用了循环和条件判断来找到插入位置，并通过移动元素的方式进行排序。
- 快速排序：该算法通过选取一个基准元素，将数组分为两个子数组，并对子数组进行递归排序。
实现时，我们使用了递归和分治的思想，将数组不断划分为更小的子数组进行排序。
- 归并排序：该算法通过将数组递归地划分为更小的子数组，并将子数组进行合并排序。
实现时，我们使用了递归和分治的思想，将数组不断划分为更小的子数组进行排序，然后再将子数组合并起来。
数据结构实验报告-排序
本章共8道实验题目。
一、直接插入排序1. 定义顺序表的存储结构2. 初始化顺序表为空表3. 输入10个元素创建含有10个元素的顺序表4. 输出顺序表5. 对顺序表进行直接插入排序（InsertSort）6. 输出排序后的顺序表例如：11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序:#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;//此处定义直接插入排序函数int a[20];int main(){int InsertSort;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort(a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}二、折半插入排序1. 定义顺序表的存储结构2. 初始化顺序表为空表3. 输入10个元素创建含有10个元素的顺序表4. 输出顺序表5. 对顺序表进行折半插入排序（BInsertSort）6. 输出排序后的顺序表例如：11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序：#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;//此处定义折半插入排序函数int a[20];int main(){int BInsertSort ;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort(a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}三、希尔排序1. 定义顺序表的存储结构2. 初始化顺序表为空表3. 输入10个元素创建含有10个元素的顺序表4. 输出顺序表5. 对顺序表进行希尔排序（ShellSort）6. 输出排序后的顺序表例如：11 938 669 507 117 261 708 343 300 602 11 938 669 507 117 261 708 343 300 602 11 117 261 300 343 507 602 669 708 938 程序：#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;int a[20];int main(){int ShellSort;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort(a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}四、冒泡排序1.定义顺序表的存储结构2.初始化顺序表为空表3.输入10个元素创建含有10个元素的顺序表4.输出顺序表5.对顺序表进行冒泡排序（BubbleSort）6.输出排序后的顺序表例如：11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序：#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;int a[20];int main(){int BubbleSort;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort(a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}五、快速排序1.定义顺序表的存储结构2.初始化顺序表为空表3.输入10个元素创建含有10个元素的顺序表4.输出顺序表5.对顺序表进行快速排序（QuickSort）6.输出排序后的顺序表例如：11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序：#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;int a[20];int main(){int QuickSort;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort (a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}六、简单选择排序1.定义顺序表的存储结构2.初始化顺序表为空表3.输入10个元素创建含有10个元素的顺序表4.输出顺序表5.对顺序表进行简单选择排序（SelectSort）6.输出排序后的顺序表例如：11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 602 11 117 261 300 343 507 602 669 708 938 程序：#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;int a[20];int main(){int SelectSort;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort(a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}七、堆排序1.定义顺序表的存储结构2.初始化顺序表为空表3.输入10个元素创建含有10个元素的顺序表4.输出顺序表5.对顺序表进行堆排序（HeapSort）6.输出排序后的顺序表例如：11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序：#include <iostream>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;Status InitList(SqList &L){L.length=0;return 0;}Status CreateList(SqList &L,int n){if(!L.r||n<1||n>MAXSIZE) return ERROR;//cout<<"\n请输入"<<n<<"个元素（用空格隔开）：";for(int i=1;i<=n;i++)cin>>L.r[i].key;L.length=n;return OK;}void ListTraverse(SqList L){//cout<<"L=(";for(int i=1;i<=L.length;i++)cout<<L.r[i].key<<' ';//if(L.length) cout<<'\b';//cout<<")";cout<<endl;}void HeapSort(SqList &L){int value = 0;for(int i = 0;i<L.length;i++)for(int j = 0;j<L.length-i;j++){if(L.r[j].key>L.r[j+1].key){value = L.r[j].key;L.r[j].key= L.r[j+1].key;L.r[j+1].key = value;}}int main(){SqList L;InitList(L);CreateList(L,10);ListTraverse(L);HeapSort(L);ListTraverse(L);return 0;}八、归并排序1.定义顺序表的存储结构2.初始化顺序表为空表3.输入10个元素创建含有10个元素的顺序表4.输出顺序表5.对顺序表进行二路归并排序（MergeSort）6.输出排序后的顺序表例如：11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序：#include <iostream>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef structKeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;Status InitList(SqList &L){L.length=0;return 0;}Status CreateList(SqList &L,int n){if(!L.r||n<1||n>MAXSIZE) return ERROR;//cout<<"\n请输入"<<n<<"个元素（用空格隔开）：";for(int i=1;i<=n;i++)cin>>L.r[i].key;L.length=n;return OK;}void ListTraverse(SqList L){//cout<<"L=(";for(int i=1;i<=L.length;i++)cout<<L.r[i].key<<' ';//if(L.length) cout<<'\b';//cout<<")";cout<<endl;}void MSort(){}void Merge(){}void MergeSort(SqList &L){int value = 0;for(int i = 0;i<L.length;i++)for(int j = 0;j<L.length-i;j++){if(L.r[j].key>L.r[j+1].key){value = L.r[j].key;L.r[j].key= L.r[j+1].key;L.r[j+1].key = value;}}}int main(){SqList L;InitList(L);CreateList(L,10);ListTraverse(L);MergeSort(L);ListTraverse(L);return 0;}。
数据结构实验报告-排序
数据结构实验报告-排序一、实验目的本实验旨在探究不同的排序算法在处理大数据量时的效率和性能表现，并对比它们的优缺点。
二、实验内容本次实验共选择了三种常见的排序算法：冒泡排序、快速排序和归并排序。
三个算法将在同一组随机生成的数据集上进行排序，并记录其性能指标，包括排序时间和所占用的内存空间。
三、实验步骤1. 数据的生成在实验开始前，首先生成一组随机数据作为排序的输入。
定义一个具有大数据量的数组，并随机生成一组在指定范围内的整数，用于后续排序算法的比较。
2. 冒泡排序冒泡排序是一种简单直观的排序算法。
其基本思想是从待排序的数据序列中逐个比较相邻元素的大小，并依次交换，从而将最大（或最小）的元素冒泡到序列的末尾。
重复该过程直到所有数据排序完成。
3. 快速排序快速排序是一种分治策略的排序算法，效率较高。
它将待排序的序列划分成两个子序列，其中一个子序列的所有元素都小于等于另一个子序列的所有元素。
然后对两个子序列分别递归地进行快速排序。
4. 归并排序归并排序是一种稳定的排序算法，使用分治策略将序列拆分成较小的子序列，然后递归地对子序列进行排序，最后再将子序列合并成有序的输出序列。
归并排序相对于其他算法的优势在于其稳定性和对大数据量的高效处理。
四、实验结果经过多次实验，我们得到了以下结果：1. 冒泡排序在数据量较小时，冒泡排序表现良好，但随着数据规模的增大，其性能明显下降。
排序时间随数据量的增长呈平方级别增加。
2. 快速排序相比冒泡排序，快速排序在大数据量下的表现更佳。
它的排序时间线性增长，且具有较低的内存占用。
3. 归并排序归并排序在各种数据规模下都有较好的表现。
它的排序时间与数据量呈对数级别增长，且对内存的使用相对较高。
五、实验分析根据实验结果，我们可以得出以下结论：1. 冒泡排序适用于数据较小的排序任务，但面对大数据量时表现较差，不推荐用于处理大规模数据。
2. 快速排序是一种高效的排序算法，适用于各种数据规模。
数据结构排序实验报告
数据结构排序实验报告1. 引言数据结构是计算机科学中的重要概念，它涉及组织和管理数据的方式。
排序算法是数据结构中的重要部分，它可以将一组无序的数据按照一定的规则进行重新排列，以便更容易进行搜索和查找。
在本实验中，我们将对不同的排序算法进行研究和实验，并对其性能进行评估。
2. 实验目的本实验旨在通过比较不同排序算法的性能，深入了解各算法的特点，从而选择最适合特定场景的排序算法。
3. 实验方法本实验使用C++编程语言实现了以下排序算法：冒泡排序、选择排序、插入排序、快速排序和归并排序。
为了评估这些算法的性能，我们设计了一组实验来测试它们在不同数据规模下的排序时间。
4. 实验过程4.1 数据生成首先，我们生成了一组随机的整数数据作为排序的输入。
数据规模从小到大递增，以便观察不同算法在不同规模下的性能差异。
4.2 排序算法实现接下来，我们根据实验要求，使用C++编程语言实现了冒泡排序、选择排序、插入排序、快速排序和归并排序。
每个算法被实现为一个独立的函数，并按照实验顺序被调用。
4.3 性能评估我们使用计时器函数来测量每个排序算法的执行时间。
在测试过程中，我们多次运行每个算法，取平均值以减小误差。
5. 实验结果我们将在不同数据规模下运行每个排序算法，并记录它们的执行时间。
下表展示了我们的实验结果：数据规模（n）冒泡排序选择排序插入排序快速排序归并排序1000 2ms 3ms 1ms 1ms 1ms5000 20ms 15ms 10ms 3ms 5ms10000 85ms 60ms 30ms 5ms 10ms50000 2150ms 1500ms 700ms 10ms 15ms从上表我们可以观察到，随着数据规模的增加，冒泡排序和选择排序的执行时间呈指数级增长，而插入排序、快速排序和归并排序的执行时间则相对较稳定。
此外，当数据规模较大时，快速排序和归并排序的性能远优于其他排序算法。
6. 实验结论根据实验结果，我们可以得出以下结论：- 冒泡排序和选择排序是简单但效率较低的排序算法，仅适用于较小规模的数据排序。
数据结构排序实验报告
数据结构排序实验报告数据结构排序实验报告实验目的：通过实践，掌握常见的数据结构排序算法的原理与实现方法，比较不同算法的时间复杂度与空间复杂度，并分析其优缺点。
实验环境：编程语言：Python运行平台：Windows 10实验内容：1. 插入排序 (Insertion Sort)2. 冒泡排序 (Bubble Sort)3. 快速排序 (Quick Sort)4. 选择排序 (Selection Sort)5. 归并排序 (Merge Sort)6. 堆排序 (Heap Sort)实验步骤：1. 实现各种排序算法的函数，并验证其正确性。
2. 构建不同规模的随机数数组作为输入数据。
3. 使用time库测量每种算法在不同规模数据下的运行时间。
4. 绘制时间复杂度与输入规模的关系图。
5. 对比分析各种算法的时间复杂度和空间复杂度。
实验结果：1. 插入排序的时间复杂度为O(n^2)，空间复杂度为O(1)。
2. 冒泡排序的时间复杂度为O(n^2)，空间复杂度为O(1)。
3. 快速排序的时间复杂度为O(nlogn)，空间复杂度为O(logn)。
4. 选择排序的时间复杂度为O(n^2)，空间复杂度为O(1)。
5. 归并排序的时间复杂度为O(nlogn)，空间复杂度为O(n)。
6. 堆排序的时间复杂度为O(nlogn)，空间复杂度为O(1)。
实验结论：1. 在小规模数据排序时，插入排序和冒泡排序由于其简单性和稳定性可以采用。
2. 在大规模数据排序时，快速排序、归并排序和堆排序由于其较低的时间复杂度可以采用。
3. 选择排序由于其时间复杂度较高，不适合用于大规模数据排序。
4. 归并排序由于其需要额外的空间存储中间结果，空间复杂度较高。
5. 快速排序由于其递归调用栈的使用，时间复杂度虽然较低，但空间复杂度较高。
综上所述，选择排序、插入排序和冒泡排序适用于小规模数据排序，而归并排序、快速排序和堆排序适用于大规模数据排序。
《数据结构》实验报告——排序
《数据结构》实验报告排序实验题目：输入十个数，从插入排序，快速排序，选择排序三类算法中各选一种编程实现。
实验所使用的数据结构内容及编程思路：1.插入排序：直接插入排序的基本操作是，将一个记录到已排好序的有序表中，从而得到一个新的，记录增一得有序表。
一般情况下，第i趟直接插入排序的操作为：在含有i-1个记录的有序子序列r［1..i-1］中插入一个记录r［i］后，变成含有i个记录的有序子序列r［1..i］；并且，和顺序查找类似，为了在查找插入位置的过程中避免数组下标出界，在r［0］处设置哨兵。
在自i-1起往前搜索的过程中，可以同时后移记录。
整个排序过程为进行n-1趟插入，即：先将序列中的第一个记录看成是一个有序的子序列，然后从第2个记录起逐个进行插入，直至整个序列变成按关键字非递减有序序列为止。
2.快速排序：基本思想是，通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
假设待排序的序列为{L.r[s]，L.r[s+1],…L.r[t]},首先任意选取一个记录(通常可选第一个记录L.r[s])作为枢轴（或支点）（pivot），然后按下述原则重新排列其余记录：将所有关键字较它小的记录都安置在它的位置之前，将所有关键字较大的记录都安置在它的位置之后。
由此可以该“枢轴”记录最后所罗的位置i作为界线，将序列{L.r[s]，…，L.r[t]}分割成两个子序列{L.r[i+1],L.[i+2],…,L.r[t]}。
这个过程称为一趟快速排序，或一次划分。
一趟快速排序的具体做法是：附设两个指针low和high，他们的初值分别为low和high，设枢轴记录的关键字为pivotkey，则首先从high所指位置起向前搜索找到第一个关键字小于pivotkey的记录和枢轴记录互相交换，然后从low所指位置起向后搜索，找到第一个关键字大于pivotkey的记录和枢轴记录互相交换，重复这两不直至low=high为止。
数据结构实验报告-排序
本章共8道实验题目。
一、直接插入排序1. 定义顺序表的存储结构2. 初始化顺序表为空表3. 输入10个元素创建含有10个元素的顺序表4. 输出顺序表5. 对顺序表进行直接插入排序（InsertSort）6. 输出排序后的顺序表例如：11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序:#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;//此处定义直接插入排序函数int a[20];int main(){int InsertSort;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort(a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}二、折半插入排序1. 定义顺序表的存储结构2. 初始化顺序表为空表3. 输入10个元素创建含有10个元素的顺序表4. 输出顺序表5. 对顺序表进行折半插入排序（BInsertSort）6. 输出排序后的顺序表例如：11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序：#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;//此处定义折半插入排序函数int a[20];int main(){int BInsertSort ;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort(a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}三、希尔排序1. 定义顺序表的存储结构2. 初始化顺序表为空表3. 输入10个元素创建含有10个元素的顺序表4. 输出顺序表5. 对顺序表进行希尔排序（ShellSort）6. 输出排序后的顺序表例如：11 938 669 507 117 261 708 343 300 602 11 938 669 507 117 261 708 343 300 602 11 117 261 300 343 507 602 669 708 938 程序：#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;int a[20];int main(){int ShellSort;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort(a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}四、冒泡排序1.定义顺序表的存储结构2.初始化顺序表为空表3.输入10个元素创建含有10个元素的顺序表4.输出顺序表5.对顺序表进行冒泡排序（BubbleSort）6.输出排序后的顺序表例如：11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序：#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;int a[20];int main(){int BubbleSort;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort(a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}五、快速排序1.定义顺序表的存储结构2.初始化顺序表为空表3.输入10个元素创建含有10个元素的顺序表4.输出顺序表5.对顺序表进行快速排序（QuickSort）6.输出排序后的顺序表例如：11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序：#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;int a[20];int main(){int QuickSort;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort (a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}六、简单选择排序1.定义顺序表的存储结构2.初始化顺序表为空表3.输入10个元素创建含有10个元素的顺序表4.输出顺序表5.对顺序表进行简单选择排序（SelectSort）6.输出排序后的顺序表例如：11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 602 11 117 261 300 343 507 602 669 708 938 程序：#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;int a[20];int main(){int SelectSort;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort(a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}七、堆排序1.定义顺序表的存储结构2.初始化顺序表为空表3.输入10个元素创建含有10个元素的顺序表4.输出顺序表5.对顺序表进行堆排序（HeapSort）6.输出排序后的顺序表例如：11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序：#include <iostream>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;Status InitList(SqList &L){L.length=0;return 0;}Status CreateList(SqList &L,int n){if(!L.r||n<1||n>MAXSIZE) return ERROR;//cout<<"\n请输入"<<n<<"个元素（用空格隔开）：";for(int i=1;i<=n;i++)cin>>L.r[i].key;L.length=n;return OK;}void ListTraverse(SqList L){//cout<<"L=(";for(int i=1;i<=L.length;i++)cout<<L.r[i].key<<' ';//if(L.length) cout<<'\b';//cout<<")";cout<<endl;}void HeapSort(SqList &L){int value = 0;for(int i = 0;i<L.length;i++)for(int j = 0;j<L.length-i;j++){if(L.r[j].key>L.r[j+1].key){value = L.r[j].key;L.r[j].key= L.r[j+1].key;L.r[j+1].key = value;}}int main(){SqList L;InitList(L);CreateList(L,10);ListTraverse(L);HeapSort(L);ListTraverse(L);return 0;}八、归并排序1.定义顺序表的存储结构2.初始化顺序表为空表3.输入10个元素创建含有10个元素的顺序表4.输出顺序表5.对顺序表进行二路归并排序（MergeSort）6.输出排序后的顺序表例如：11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序：#include <iostream>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef structKeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;Status InitList(SqList &L){L.length=0;return 0;}Status CreateList(SqList &L,int n){if(!L.r||n<1||n>MAXSIZE) return ERROR;//cout<<"\n请输入"<<n<<"个元素（用空格隔开）：";for(int i=1;i<=n;i++)cin>>L.r[i].key;L.length=n;return OK;}void ListTraverse(SqList L){//cout<<"L=(";for(int i=1;i<=L.length;i++)cout<<L.r[i].key<<' ';//if(L.length) cout<<'\b';//cout<<")";cout<<endl;}void MSort(){}void Merge(){}void MergeSort(SqList &L){int value = 0;for(int i = 0;i<L.length;i++)for(int j = 0;j<L.length-i;j++){if(L.r[j].key>L.r[j+1].key){value = L.r[j].key;L.r[j].key= L.r[j+1].key;L.r[j+1].key = value;}}}int main(){SqList L;InitList(L);CreateList(L,10);ListTraverse(L);MergeSort(L);ListTraverse(L);return 0;}。
北邮数据结构实验报告-排序
北邮数据结构实验报告-排序北邮数据结构实验报告-排序一、实验目的本实验旨在掌握常见的排序算法，包括冒泡排序、插入排序、选择排序、快速排序、归并排序等，并通过实际编程实现对数字序列的排序。
二、实验内容1.冒泡排序冒泡排序是一种简单的排序算法，其基本思想是依次比较相邻的两个元素，并按照从小到大或从大到小的顺序交换。
具体步骤如下：- 从待排序序列的第一个元素开始，依次比较相邻的两个元素；- 如果前面的元素大于后面的元素，则交换这两个元素的位置；- 重复上述步骤，直到整个序列有序。
2.插入排序插入排序是一种简单且直观的排序算法，其基本思想是将待排序序列分为已排序和未排序两部分，每次从未排序部分中选择一个元素插入到已排序部分的合适位置。
具体步骤如下：- 从待排序序列中选择一个元素作为已排序部分的第一个元素；- 依次将未排序部分的元素插入到已排序部分的合适位置，使得已排序部分保持有序；- 重复上述步骤，直到整个序列有序。
3.选择排序选择排序是一种简单且直观的排序算法，其基本思想是每次选择未排序部分中的最小（或最大）元素，并将其放在已排序部分的末尾。
具体步骤如下：- 在未排序部分中选择最小（或最大）的元素；- 将选择的最小（或最大）元素与未排序部分的第一个元素交换位置；- 重复上述步骤，直到整个序列有序。
4.快速排序快速排序是一种高效的排序算法，其基本思想是通过一趟排序将待排序序列分割成两部分，其中一部分的元素都比另一部分的元素小。
具体步骤如下：- 选择一个枢轴元素（一般选择第一个元素）；- 将待排序序列中小于枢轴元素的元素放在枢轴元素的左侧，大于枢轴元素的元素放在枢轴元素的右侧；- 对枢轴元素左右两侧的子序列分别进行递归快速排序；- 重复上述步骤，直到整个序列有序。
5.归并排序归并排序是一种高效的排序算法，其基本思想是将待排序序列划分成足够小的子序列，然后对这些子序列进行两两合并，最终形成有序的序列。
具体步骤如下：- 将待排序序列递归地划分成足够小的子序列；- 对每个子序列进行归并排序；- 合并相邻的子序列，直到整个序列有序。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构实验报告实验名称：实验四——排序学生：XX班级：班序号：学号：日期：1．实验要求实验目的：通过选择实验容中的两个题目之一，学习、实现、对比、各种排序的算法，掌握各种排序算法的优劣，以及各种算法使用的情况。
题目1：使用简单数组实现下面各种排序算法，并进行比较。
排序算法如下：1、插入排序；2、希尔排序；3、冒泡排序；4、快速排序；5、简单选择排序；6、堆排序；7、归并排序；8、基数排序（选作）；9、其他。
具体要求如下：1、测试数据分成三类：正序、逆序、随机数据。
2、对于这三类数据，比较上述排序算法中关键字的比较次数和移动次数（其中关键字交换记为3次移动）。
3、对于这三类数据，比较上述排序算法中不同算法的执行时间，精确到微妙。
4、对2和3的结果进行分析，验证上述各种算法的时间复杂度。
5、编写main（）函数测试各种排序算法的正确性。
2. 程序分析2.1 存储结构存储结构：数组2.2 关键算法分析一、关键算法：1、插入排序a、取排序的第二个数据与前一个比较b、若比前一个小，则赋值给哨兵c、从后向前比较，将其插入在比其小的元素后d、循环排序2、希尔排序a、将数组分成两份b、将第一份数组的元素与哨兵比较c、若其大与哨兵，其值赋给哨兵d、哨兵与第二份数组元素比较，将较大的值赋给第二份数组e、循环进行数组拆分3、对数据进行编码a、取数组元素与下一个元素比较b、若比下一个元素大，则与其交换c、后移，重复d、改变总元素值，并重复上述代码4、快速排序a、选取标准值b、比较高低指针指向元素，若指针保持前后顺序，且后指针元素大于标准值，后指针前移，重新比较c、否则后面元素赋给前面元素d、若后指针元素小于标准值，前指针后移，重新比较e、否则前面元素赋给后面元素5、简单选择排序a、从数组中选择出最小元素b、若不为当前元素，则交换c、后移将当前元素设为下一个元素6、堆排序a、生成小顶堆b、将堆的根节点移至数组的最后c、去掉已做过根节点的元素继续生成小顶堆d、数组倒置7、归并排序a、将数组每次以1/2拆分，直到为最小单位b、小相邻单位数组比较重排合成新的单位c、循环直至完成排序二、代码详细分析：1、插入排序关键代码：①取排序的第二个数据与前一个比较：if(r[i]<r[i-1])②若比前一个小，则赋值给哨兵：r[0]=r[i];③从后向前比较，将其插入在比其小的元素后：for(j=i-1;r[0]<r[j];j--){r[j+1]=r[j];a++;} r[j+1]=r[0];④循环排序2、希尔排序关键代码：①将数组分成两份：d=n/2②将第一份数组的元素与哨兵比较：for(int i=d+1;i<=n;i++)③若其大与哨兵，其值赋给哨兵：if(r[0]<r[i-d]){ r[0]=r[i];}④哨兵与第二份数组元素比较，将较大的值赋给第二份数组：for(j=i-d;j>0&&r[0]<r[j];j=j-d) {r[j+d]=r[j]; }⑤循环进行数组拆分：for(int;d>=1;d=d/2)3、冒泡排序关键代码：①取数组元素与下一个元素比较： for(int i=1;i<bound;i++)if(r[i]>r[i+1])②若比下一个元素大，则与其交换： r[0]=r[i]; r[i]=r[i+1]; r[i+1]=r[0];③后移，重复：for(int i=1;i<bound;i++)④改变总元素值，并重复上述代码：int bound=pos;4、快速排序关键代码：①选取标准值：r[0]=r[i]②比较高低指针指向元素，若指针保持前后顺序，且后指针元素大于标准值，后指针前移，重新比较：while(i<j&&r[j]>=flag) {j--;}③否则后面元素赋给前面元素：r[i]=r[j];④若后指针元素小于标准值，前指针后移，重新比较：while(i<j&&r[i]<=flag){i++;}⑤否则前面元素赋给后面元素：r[j]=r[i];5、简单选择排序关键代码：①从数组中选择出最小元素： for(int j=i+1;j<=n;j++)②{if(r[j]<r[index]) index=j; }③若不为当前元素，则交换：if(index!=i) {r[0]=r[i]; r[i]=r[index];r[index]=r[0];}④后移将当前元素设为下一个元素：for(int i=1;i<n;i++)6、堆排序关键代码：①生成小顶堆：while(j<=m) {if(j<m&&r[j]>r[j+1]) {j++;}②if(r[i]<r[j]) {break; }③else{ int x; x=r[i]; r[i]=r[j]; r[j]=x; i=j; j=2*i; }}④将堆的根节点移至数组的最后： x=r[1]; r[1]=r[n-i+1]; r[n-i+1]=x;⑤去掉已做过根节点的元素继续生成小顶堆：sift(r,1,n-i,x,y);⑥数组倒置输出: for(int i=n;i>0;i--)cout<<r[i]<<" ";7、归并排序关键代码：①将数组每次以1/2拆分，直到为最小单位： mid=(low+high)/2;②小相邻单位数组比较重排合成新的单位：while(i<=m&&j<=high)if(L.r[i]<=L.r[j]) t[k++]=L.r[i++];else t[k++]=L.r[j++];while(i<=m) t[k++]=L.r[i++];while(j<=high) t[k++]=L.r[j++];for(i=low,k=0;i<=high;i++,k++) L.r[i]=t[k];三、计算关键算法的时间、空间复杂度插入排序O（n2）希尔排序O（n2）冒泡排序O（n2）快速排序O（nlog2n）简单选择排序O（n2）堆排序O（nlog2n）归并排序O（nlog2n）3. 程序运行结果1、测试主函数流程：流程图如图所示流程图示意图程序运行结果图如下：2、测试条件：按题目要求分别输入同组数据的正序、逆序、随机序列进行测试。
3、测试结论：不同的排序方法移动次数比较次数和所用时间都是有所区别的。
4. 总结调试时出现的问题及解决的方法：在调试时，开始在归并排序的时候，虽然代码编译成功，但调试出现了错误，通过逐步调试发现是由于发生了地址冲突。
因此将原本的直接调用数组改成了结构体数组，通过引用来实现归并排序，最终获得了成功心得体会：学习、实现、对比、各种排序的算法，掌握各种排序算法的优劣，以及各种算法使用的情况下一步的改进：改进计数器，寻找其他排序方式。
附：源代码#include<iostream>using namespace std;int Cnum = 0;int Mnum = 0;class LED{private :int compare;int move;public:void InsertSort(int r[] , int n) ;//直接插入排序void ShellInsert(int r[],int n) ;//希尔排序void BubbleSort(int r[],int n);//冒泡排序void Qsort(int r[],int i,int j);//快速排序void SelectSort(int r[],int n);//选择排序void HeapSort (int r[],int n);void MergePass(int r[],int r1[],int n ,int h);int Partion(int r[] ,int first ,int end );void Sift(int r[],int k , int m);void Merge(int r[],int r1[],int s,int m,int t);};void LED::InsertSort(int r[] , int n) //插入排序{compare = 0;move = 0;for(int i=2;i<=n;i++){if(r[i]<r[i-1]){r[0]=r[i];move ++;r[i]=r[i-1];move ++;int j;for(j=i-2;r[0]<r[j];j--){compare++;r[j+1]=r[j];move ++;}++compare;r[j+1]=r[0];move ++;}++compare;}for(int i=1;i<=n;i++)cout<<r[i]<<" ";cout<<"比较次数为"<<compare <<" ; 移动次数为"<<move<<" ;"; }void LED::ShellInsert(int r[],int n) //希尔排序{compare = 0;move = 0;for(int d=n/2;d>=1;d=d/2){for(int i=d+1;i<=n;i++){if(r[i]<r[i-d]){move++;r[0]=r[i];int j;for(j=i-d;j>0&&r[0]<r[j];j=j-d){r[j+d]=r[j];move++;}compare++;r[j+d]=r[0];move++;}compare++;}}for(int i=1;i<=n;i++)cout<<r[i]<<" ";cout<<"比较次数为"<<compare <<" ; 移动次数为"<<move<<" ;"; }void LED::BubbleSort(int r[],int n) //冒泡排序改进{compare = 0;move = 0;int pos = n ;while(pos != 0){int bound = pos;pos = 0;for(int i =1;i <bound ; i++){compare ++;if(r[i]>r[i+1]){r[0] = r[i];r[i] = r[i+1];r[i+1] = r[0]; //交换pos = i;move=move+3;}}}for(int i=1;i<=n;i++)cout<<r[i]<<" ";cout<<"比较次数为"<<compare <<" ; 移动次数为"<<move<<" ;";}int LED::Partion(int r[] ,int first ,int end ){int i = first ; //分区的左界int j = end; //分区的右界int pivot = r[i]; //保存第一个元素，作为基准元素while(i < j){while((i<j)&&(r[j]>=pivot)) //右侧扫描，寻找<pivot的元素前移{j -- ;Cnum++;}r[i] = r[j] ;while((i<j)&&(r[i]<=pivot )) //左侧扫描，寻找>pivot的元素后移{i ++;Cnum++;}r[j] = r[i];}r[i] = pivot ; //将轴值移动到i=j的位置return i; //返回分区的分界值i}void LED::Qsort(int r[],int i,int j){if(i < j){ Mnum ++;int pivotloc = Partion(r,i,j);Qsort (r,i,pivotloc -1); //左分区快速排序Qsort (r,pivotloc +1,j); // 右分区快速排序}else{}}void LED::SelectSort(int r[],int n) //简单选择排序{compare = 0;move = 0;for(int i =1 ; i <n ; i++) //n-1趟排序{int index = i; //查找最小记录的位置indexfor(int j = i + 1;j<=n;j++){compare++;if(r[j]<r[index])index = j;}if(index != i) //若第一就是最小元素，则不用交换{r[0] = r[i];r[i] = r[index];r[index] = r[0]; //利用r[0]，作为临时空间交换记录move+=3;}}for(int i=1;i<=n;i++)cout<<r[i]<<" ";cout<<"比较次数为"<<compare <<" ; 移动次数为"<<move<<" ;";}/*void LED::Sift(int r[],int k , int m){int i = k, j = 2*i;while(j<=m){if(j<m&&r[j]<r[j+1])j++;if(r[i]>=r[j])break;else{r[0] = r[i];r[i] = r[j];r[j] = r[0];i = j ;j = 2* i;}}}void LED::HeapSort (int r[],int n){for(int i = n/2; i >= 1 ; i--) //建堆Sift(r,i,n);for(int i = n;i>1;i--) //堆排序{r[0] = r[1]; r[1] = r[i];r[i]= r[0]; //输出堆顶元素Sift(r,1,i-1); //重建堆}}void LED::Merge(int r[],int r1[],int s,int m,int t){int i=s;int j = m + 1;int k = s ;while(i<=m&&j<=t){if(r[i]<r[j])r1[k++] = r[i++];elser1[k++] = r[j++];}while(i<=m)r1[k++] = r[i++];while(j<=t)r1[k++] = r[j++];}void LED::MergePass(int r[],int r1[],int n ,int h) {int i = 1;while(i<=n-2*h+1){Merge (r ,r1,i,i+h-1,i+2*h-1);i+= 2*h;}if(i<n-h+1)Merge (r,r1,i,i+h-1,n);elsefor(;i<=n;i++)r1[i] = r[i];}*/void main(){int r1[10000],r2[10000],r3[10000];int R[10000];char y ;int j=0;cout<<"请输入元素个数："<<endl;cin>>j;cout<<"请输入将要排序的元素(正序)："<<endl;for(int i=1;i<=j;i++){cin>>r1[i];}cout<<"请输入将要排序的元素(逆序)："<<endl;for(int i=1;i<=j;i++){cin>>r2[i];}cout<<"请输入将要排序的元素（乱序）："<<endl;for(int i=1;i<=j;i++){cin>>r3[i];}cout<<endl;LED l;for(int i= 1;i<=j;i++){R[i]=r1[i];}cout<<"直接插入排序正序输出结果：";l.InsertSort(R,j); cout<<endl;for(int i= 1;i<=j;i++){R[i]=r2[i];}cout<<"直接插入排序逆序输出结果：";l.InsertSort(R,j); cout<<endl;for(int i= 1;i<=j;i++){R[i]=r3[i];}cout<<"直接插入排序乱序输出结果：";l.InsertSort(R,j); cout<<endl;for(int i= 1;i<=j;i++){R[i]=r1[i];}cout<<"希尔排序正序输出结果：";l.ShellInsert(R,j);cout<<endl;for(int i= 1;i<=j;i++){R[i]=r2[i];}cout<<"希尔排序逆序输出结果：";l.ShellInsert(R,j);cout<<endl;for(int i= 1;i<=j;i++){R[i]=r3[i];}cout<<"希尔排序乱序输出结果：";l.ShellInsert(R,j);cout<<endl;for(int i= 1;i<=j;i++){R[i]=r1[i];}cout<<"冒泡排序正序输出结果：";l.BubbleSort(R,j);cout<<endl;for(int i= 1;i<=j;i++){R[i]=r2[i];}cout<<"冒泡排序逆序输出结果：";l.BubbleSort(R,j);cout<<endl;for(int i= 1;i<=j;i++){R[i]=r3[i];}cout<<"冒泡排序乱序输出结果：";l.BubbleSort(R,j);cout<<endl;for(int i= 1;i<=j;i++){R[i]=r1[i];}cout<<"快速排序正序输出结果：";l.Qsort(R,1,j);for(int k=1;k<=j;k++)cout<<R[k]<<" ";cout<<"比较次数为"<<Cnum <<" ; 移动次数为"<<Mnum<<" ";Cnum = 0;Mnum = 0;cout<<endl;for(int i= 1;i<=j;i++){R[i]=r2[i];}cout<<"快速排序逆序输出结果：";l.Qsort(R,1,j);for(int k=1;k<=j;k++)cout<<R[k]<<" ";cout<<"比较次数为"<<Cnum <<" ; 移动次数为"<<Mnum<<" ";Cnum = 0;Mnum = 0;cout<<endl;for(int i= 1;i<=j;i++){R[i]=r3[i];}cout<<"快速排序乱序输出结果：";l.Qsort(R,1,j);for(int k=1;k<=j;k++)cout<<R[k]<<" ";cout<<"比较次数为"<<Cnum <<" ; 移动次数为"<<Mnum<<" "; cout<<endl;for(int i= 1;i<=j;i++){R[i]=r1[i];}cout<<"简单选择排序正序输出结果：";l.SelectSort(R,j);cout<<endl;for(int i= 1;i<=j;i++){R[i]=r2[i];}cout<<"简单选择排序逆序输出结果：";l.SelectSort(R,j); cout<<endl;for(int i= 1;i<=j;i++){R[i]=r3[i];}cout<<"简单选择排序乱序输出结果：";l.SelectSort(R,j); cout<<endl;}。