数据结构实验10：排序子系统

合集下载

数据结构排序实验报告

数据结构排序实验报告数据结构排序实验报告引言：数据结构是计算机科学中的重要概念之一，它涉及到数据的组织、存储和操作方式。

排序是数据结构中的基本操作之一，它可以将一组无序的数据按照特定的规则进行排列，从而方便后续的查找和处理。

本实验旨在通过对不同排序算法的实验比较，探讨它们的性能差异和适用场景。

一、实验目的本实验的主要目的是通过实际操作，深入理解不同排序算法的原理和实现方式，并通过对比它们的性能差异，选取合适的排序算法用于不同场景中。

二、实验环境和工具实验环境：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．实验要求【实验目的】学习、实现、对比各种排序算法，掌握各种排序算法的优劣，以及各种算法使用的情况。

【实验内容】使用简单数组实现下面各种排序算法，并进行比较。

排序算法：1、插入排序2、希尔排序3、冒泡排序4、快速排序5、简单选择排序6、堆排序（选作）7、归并排序（选作）8、基数排序（选作）9、其他要求：1、测试数据分成三类：正序、逆序、随机数据2、对于这三类数据，比较上述排序算法中关键字的比较次数和移动次数（其中关键字交换计为3次移动）。

3、对于这三类数据，比较上述排序算法中不同算法的执行时间，精确到微秒（选作）4、对2和3的结果进行分析，验证上述各种算法的时间复杂度编写测试main()函数测试线性表的正确性。

2. 程序分析2.1 存储结构存储结构：数组2.2 关键算法分析//插入排序void InsertSort(int r[], int n) {int count1=0,count2=0;插入到合适位置for (int i=2; i<n; i++){r[0]=r[i]; //设置哨兵for (int j=i-1; r[0]<r[j]; j--) //寻找插入位置r[j+1]=r[j]; //记录后移r[j+1]=r[0];count1++;count2++;}for(int k=1;k<n;k++)cout<<r[k]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl; }//希尔排序void ShellSort(int r[], int n){int i;int d;int j;int count1=0,count2=0;for (d=n/2; d>=1; d=d/2) //以增量为d进行直接插入排序{for (i=d+1; i<n; i++){r[0]=r[i]; //暂存被插入记录for (j=i-d; j>0 && r[0]<r[j]; j=j-d)r[j+d]=r[j]; //记录后移d个位置r[j+d]=r[0];count1++;count2=count2+d;}count1++;}for(i=1;i<n;i++)cout<<r[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl; }//起泡排序void BubbleSort(int r[], int n) {插入到合适位置int temp;int exchange;int bound;int count1=0,count2=0;exchange=n-1; //第一趟起泡排序的范围是r[1]到r[n]while (exchange) //仅当上一趟排序有记录交换才进行本趟排序{bound=exchange;exchange=0;for(int j=0;j<bound;j++) //一趟起泡排序{count1++; //接下来有一次比较if(r[j]>r[j+1]){temp=r[j]; //交换r[j]和r[j+1]r[j]=r[j+1];r[j+1]=temp;exchange=j; //记录每一次发生记录交换的位置count2=count2+3; //移动了3次}}}for(int i=1;i<n;i++)cout<<r[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl;}//快速排序一次划分int Partition(int r[], int first, int end,int &count1,int &count2){int i=first; //初始化int j=end;while (i<j){while (i<j && r[i]<= r[j]){j--; //右侧扫描count1++;}count1++;if (i<j){temp=r[i]; //将较小记录交换到前面r[i]=r[j];r[j]=temp;i++;count2=count2+3;}while (i<j && r[i]<= r[j]){i++; //左侧扫描count1++;}count1++;if (i<j){temp=r[j];r[j]=r[i];r[i]=temp; //将较大记录交换到后面j--;count2=count2+3;}}return i; //i为轴值记录的最终位置}//快速排序void QuickSort(int r[], int first, int end,int &count1,int &count2){if (first<end){ //递归结束int pivot=Partition(r, first, end,count1,count2); //一次划分QuickSort(r, first, pivot-1,count1,count2);//递归地对左侧子序列进行快速排序QuickSort(r, pivot+1, end,count1,count2); //递归地对右侧子序列进行快速排序}}//简单选择排序Array void SelectSort(int r[ ], int n){int i;int j;int index;int temp;int count1=0,count2=0;for (i=0; i<n-1; i++) //对n个记录进行n-1趟简单选择排序{index=i;for(j=i+1;j<n;j++) //在无序区中选取最小记录{count1++; //比较次数加一if(r[j]<r[index]) //如果该元素比现在第i个位置的元素小index=j;}count1++; //在判断不满足循环条件j<n时，比较了一次if(index!=i){temp=r[i]; //将无序区的最小记录与第i个位置上的记录交换r[i]=r[index];r[index]=temp;count2=count2+3; //移动次数加3 }}for(i=1;i<n;i++)cout<<r[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl;}//筛选法调整堆void Sift(int r[],int k,int m,int &count1,int &count2) //s，t分别为比较和移动次数{int i;int j;int temp;i=k;j=2*i+1; //置i为要筛的结点，j为i的左孩子while(j<=m) //筛选还没有进行到叶子{if(j<m && r[j]<r[j+1]) j++; //比较i的左右孩子，j为较大者count1=count1+2; //该语句之前和之后分别有一次比较if(r[i]>r[j])break; //根结点已经大于左右孩子中的较大者else{temp=r[i];r[i]=r[j];r[j]=temp; //将根结点与结点j交换i=j;j=2*i+1; //下一个被筛结点位于原来结点j的位置count2=count2+3; //移动次数加3 }}}//堆排序void HeapSort(int r[],int n){int count1=0,count2=0; //计数器，计比较和移动次数int i;int temp;for(i=n/2;i>=0;i--) //初始建堆，从最后一个非终端结点至根结点Sift(r,i,n,count1,count2) ;for(i=n-1; i>0; i--) //重复执行移走堆顶及重建堆的操作{temp=r[i]; //将堆顶元素与最后一个元素交换r[i]=r[0];r[0]=temp; //完成一趟排序，输出记录的次序状态Sift(r,0,i-1,count1,count2); //重建堆}for(i=1;i<n;i++)cout<<r[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl;}//一次归并void 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++]; //取r[i]和r[j]中较小者放入r1[k]elser1[k++]=r[j++];}if (i<=m)while (i<=m) //若第一个子序列没处理完，则进行收尾处理r1[k++]=r[i++];elsewhile (j<=t) //若第二个子序列没处理完，则进行收尾处理r1[k++]=r[j++];}//一趟归并void MergePass(int r[ ], int r1[ ], int n, int h){int i=0;int k;while (i<=n-2*h) //待归并记录至少有两个长度为h的子序列{Merge(r, r1, i, i+h-1, i+2*h-1);i+=2*h;}if (i<n-h)Merge(r, r1, i, i+h-1, n); //待归并序列中有一个长度小于h else for (k=i; k<=n; k++) //待归并序列中只剩一个子序列r1[k]=r[k];}//归并排序void MergeSort(int r[ ], int r1[ ], int n ){int h=1;int i;while (h<n){MergePass(r, r1, n-1, h); //归并h=2*h;MergePass(r1, r, n-1, h);h=2*h;}for(i=1;i<n;i++)cout<<r[i]<<" ";cout<<endl;}void Newarray(int a[],int b[],int c[]) {cout<<"新随机数组：";c[0]=0;a[0]=0;b[0]=0;for(int s=1;s<11;s++){a[s]=s;b[s]=20-s;c[s]=rand()%50+1;cout<<c[s]<<" ";}cout<<endl;}2.3 其他3. 程序运行结果void main(){srand(time(NULL));const int num=11; //赋值int a[num];int b[num];int c[num];int c1[num];c[0]=0;a[0]=0;b[0]=0;Newarray(a,b,c);cout<<"顺序数组：";for(int j=1;j<num;j++)cout<<a[j]<<" ";cout<<endl;cout<<"逆序数组：";for(j=1;j<num;j++)cout<<b[j]<<" ";cout<<endl;cout<<endl;cout<<"插入排序结果为："<<"\n";InsertSort(a,num);InsertSort(b,num);InsertSort(c,num);cout<<endl;Newarray(a,b,c);cout<<"希尔排序结果为："<<"\n";ShellSort(a, num);ShellSort(b, num);ShellSort(c, num);cout<<endl;Newarray(a,b,c);cout<<"起泡排序结果为："<<"\n";BubbleSort(a, num);BubbleSort(b, num);BubbleSort(c, num);cout<<endl;int count1=0,count2=0;Newarray(a,b,c);cout<<"快速排序结果为："<<"\n";QuickSort(a,0,num-1,count1,count2);for(int i=1;i<num;i++)cout<<a[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl; count1=0,count2=0;QuickSort(b,0,num-1,count1,count2);for(i=1;i<num;i++)cout<<b[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl; count1=0,count2=0;QuickSort(c,0,num-1,count1,count2);for(i=1;i<num;i++)cout<<c[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl;cout<<endl;cout<<endl;Newarray(a,b,c);cout << "简单选择排序结果为：" << "\n";SelectSort(a,num);SelectSort(b,num);SelectSort(c,num);cout<<endl;Newarray(a,b,c);cout << "堆排序结果为：" << "\n";HeapSort(a, num);HeapSort(b, num);HeapSort(c, num);cout<<endl;Newarray(a,b,c);cout << "归并排序结果为：" << "\n";MergeSort(a, c1,num );MergeSort(b, c1,num );MergeSort(c, c1,num );}。

数据结构排序实验报告

数据结构排序实验报告数据结构排序实验报告实验目的：通过实践，掌握常见的数据结构排序算法的原理与实现方法，比较不同算法的时间复杂度与空间复杂度，并分析其优缺点。

实验环境：编程语言：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. 快速排序由于其递归调用栈的使用，时间复杂度虽然较低，但空间复杂度较高。

综上所述，选择排序、插入排序和冒泡排序适用于小规模数据排序，而归并排序、快速排序和堆排序适用于大规模数据排序。

数据结构实验报告——排序

数据结构实验报告排序姓名：13-计算机-舞学号：0000000000专业：计算机科学与技术班级：计算机13-2班日期：2014年6月6日星期五一、实验目的和要求通过编程实现直接插入排序、希尔排序、冒泡排序、快速排序、直接选择排序。

要求输入一些无序数，执行程序后使他们变成有序数并在窗口输出。

二、实验环境1、windows 72、c-free 5.0三、实验内容用五种排序算法对输入的数进行排序，并在屏幕中输出。

四、实验过程1、直接插入排序：即将所需要排序的数据分成两部分，其中一部分为已排好序部分，另一部分为未排序部分。

然后从未排序部分中选出一元素插入到一排序部分中，要求插入后已排序部分任然有序。

在编写该程序时，我将要排序的数据储存在一个数组中，并将第一个数划分为已经排序部分然后从下一个数开始不断和前边的最后一个数比较，知道找到插入位置。

2、希尔排序：希尔排序是建立在直接插入排序的基础之上的，他是通过将数据分成几组，在组内实现插入排序，使整个数据基本有序，最后再对整个数据实现插入排序。

这里同样将数据储存在数组中，分组的步长每次取之前步长的一半。

需要注意的是，移动元素时，下标不再是减1，而是减去步长。

3、冒泡排序：通过不断比较相邻的两个元素，发现倒序即交换，最终实现排序。

在这个程序中，我从后面开始向前比较。

每依次循环可以最终确定一个元素在其最终位置上，所以每次循环之后，元素间的两两比较次数减1.4、快速排序：选定一个元素作为中间元素，将整个数据分为比中间元素小的一组和比中间元素大的一组，并且小的在中间元素前，大的在中间元素后。

再分好的两组内再次重复上诉过程使所有元素排好序。

5、直接选择排序：将待排序数据存入数组中，扫描一遍数组，将其中最小的元素找出并放在第一位，再扫描一遍剩下的元素，找到最小的放在第二位。

如此不断重复知道扫描了n-1次。

由于不要再开新空间，所以找到最小元素时用交换的方式使其放在第一位。

比如第一遍扫描，假设第一个为最小元素，再扫描过程中，如果发现比它小的数，则把第一个元素和该位置的元素交换。

《数据结构》实验报告——排序

《数据结构》实验报告排序实验题目：输入十个数，从插入排序，快速排序，选择排序三类算法中各选一种编程实现。

实验所使用的数据结构内容及编程思路：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为止。

排序子系统实验报告

一、实验目的1. 理解和掌握常见的排序算法原理和实现方法。

2. 分析各种排序算法的优缺点，以及适用场景。

3. 提高编程能力，培养对数据结构和算法的深入理解。

二、实验环境1. 操作系统：Windows 102. 编程语言：Python3. 开发工具：PyCharm三、实验内容1. 设计并实现以下排序算法：（1）冒泡排序（2）选择排序（3）插入排序（4）快速排序（5）归并排序2. 对随机生成的测试数据进行排序，并计算排序所需时间。

3. 分析比较各种排序算法的性能，得出适用场景。

四、实验步骤1. 设计排序算法（1）冒泡排序：通过比较相邻元素，若逆序则交换，重复此过程，直到整个序列有序。

（2）选择排序：从序列中找到最小（或最大）元素，将其与第1个元素交换，然后对剩余未排序元素重复此过程。

（3）插入排序：将未排序元素插入到已排序序列中正确的位置，重复此过程，直到整个序列有序。

（4）快速排序：选择一个基准元素，将序列划分为两部分，分别包含小于和大于基准元素的元素，递归地对这两部分进行快速排序。

（5）归并排序：将序列划分为两个子序列，分别对这两个子序列进行归并排序，最后将两个有序子序列合并为一个有序序列。

2. 实现排序算法使用Python语言实现上述五种排序算法，代码如下：```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):for i in range(1, len(arr)):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. 对随机生成的测试数据进行排序，并计算排序所需时间```pythonimport randomimport timedef test_sorting_algorithms():n = 10000arr = [random.randint(0, 100000) for _ in range(n)] bubble_start = time.time()bubble_sorted = bubble_sort(arr.copy())bubble_end = time.time()bubble_time = bubble_end - bubble_startselection_start = time.time()selection_sorted = selection_sort(arr.copy())selection_end = time.time()selection_time = selection_end - selection_startinsertion_start = time.time()insertion_sorted = insertion_sort(arr.copy())insertion_end = time.time()insertion_time = insertion_end - insertion_startquick_start = time.time()quick_sorted = quick_sort(arr.copy())quick_end = time.time()quick_time = quick_end - quick_startmerge_start = time.time()merge_sorted = merge_sort(arr.copy())merge_end = time.time()merge_time = merge_end - merge_startprint("Bubble Sort: {:.6f}s".format(bubble_time))print("Selection Sort: {:.6f}s".format(selection_time)) print("Insertion Sort: {:.6f}s".format(insertion_time)) print("Quick Sort: {:.6f}s".format(quick_time))print("Merge Sort: {:.6f}s".format(merge_time))test_sorting_algorithms()```4. 分析比较各种排序算法的性能根据实验结果，以下是各种排序算法的性能分析：- 冒泡排序：时间复杂度为O(n^2)，适用于小规模数据排序。

北邮数据结构实验报告-排序

北邮数据结构实验报告-排序北邮数据结构实验报告-排序一、实验目的本实验旨在掌握常见的排序算法，包括冒泡排序、插入排序、选择排序、快速排序、归并排序等，并通过实际编程实现对数字序列的排序。

二、实验内容1.冒泡排序冒泡排序是一种简单的排序算法，其基本思想是依次比较相邻的两个元素，并按照从小到大或从大到小的顺序交换。

具体步骤如下：- 从待排序序列的第一个元素开始，依次比较相邻的两个元素；- 如果前面的元素大于后面的元素，则交换这两个元素的位置；- 重复上述步骤，直到整个序列有序。

2.插入排序插入排序是一种简单且直观的排序算法，其基本思想是将待排序序列分为已排序和未排序两部分，每次从未排序部分中选择一个元素插入到已排序部分的合适位置。

具体步骤如下：- 从待排序序列中选择一个元素作为已排序部分的第一个元素；- 依次将未排序部分的元素插入到已排序部分的合适位置，使得已排序部分保持有序；- 重复上述步骤，直到整个序列有序。

3.选择排序选择排序是一种简单且直观的排序算法，其基本思想是每次选择未排序部分中的最小（或最大）元素，并将其放在已排序部分的末尾。

具体步骤如下：- 在未排序部分中选择最小（或最大）的元素；- 将选择的最小（或最大）元素与未排序部分的第一个元素交换位置；- 重复上述步骤，直到整个序列有序。

4.快速排序快速排序是一种高效的排序算法，其基本思想是通过一趟排序将待排序序列分割成两部分，其中一部分的元素都比另一部分的元素小。

具体步骤如下：- 选择一个枢轴元素（一般选择第一个元素）；- 将待排序序列中小于枢轴元素的元素放在枢轴元素的左侧，大于枢轴元素的元素放在枢轴元素的右侧；- 对枢轴元素左右两侧的子序列分别进行递归快速排序；- 重复上述步骤，直到整个序列有序。

5.归并排序归并排序是一种高效的排序算法，其基本思想是将待排序序列划分成足够小的子序列，然后对这些子序列进行两两合并，最终形成有序的序列。

具体步骤如下：- 将待排序序列递归地划分成足够小的子序列；- 对每个子序列进行归并排序；- 合并相邻的子序列，直到整个序列有序。

数据结构实验报告-实验5-排序

数据结构实验报告实验名称：排序学号：姓名：实验日期：2016.07.01一、实验目的至少掌握一种排序算法二、实验内容随机生成10个从1－100之间的随机数，编程实现至少一种排序算法，对该数据进行排序。

要求1、要排序的数据随机生成2、先升序排序一次，再用同样的算法降序排序一次（2）分析（3）实验代码#include <stdio.h>#include <stdlib.h>#include <time.h>typedef struct{int key;}keytype;typedef struct{ keytype r[1000];int length;}sqlist;/*产生随机数*/void creat(sqlist *l){int i;printf("请输入要产生的随机数个数:");scanf("%d",&l->length);srand((unsigned)time(NULL));for(i=1;i<=l->length;i++){l->r[i].key = rand() %900+100;printf("%d ",l->r[i].key);}printf("\n");}/*交换顺序表中子表r[low...high]的记录，使枢轴记录到位，并返回其所在的位置*/int partion(sqlist *l,int low,int high){ int pivotkey;l->r[0]=l->r[low];pivotkey=l->r[low].key;while(low<high){ while(low<high&&l->r[high].key>=pivotkey) --high;l->r[low]=l->r[high];while(low<high&&l->r[low].key<=pivotkey) ++low;l->r[high]=l->r[low];}l->r[low]=l->r[0];return low;}/*快速排序*/void Qsort(sqlist *l,int low,int high){ int pivotloc;if(low<high){ pivotloc=partion(l,low,high);Qsort(l,low,pivotloc-1);Qsort(l,pivotloc+1,high);}}/*显示顺序表*/void display(sqlist *l){ int i;for(i=1;i<=l->length;i++)printf("%-4.2d",i);printf("\n");for(i=1;i<=2*l->length;i++)printf("--");printf("\n");for(i=1;i<=l->length;i++)printf("%-4.2d",l->r[i].key);}/*主函数*/void main(){sqlist t;creat(&t);Qsort(&t,1,t.length);printf("\n\n");printf("快速排序:\n");display(&t);}三、实验小结。

数据结构实验报告排序

数据结构实验报告排序数据结构实验报告：排序引言：排序是计算机科学中常见的算法问题之一，它的目标是将一组无序的数据按照特定的规则进行排列，以便于后续的查找、统计和分析。

在本次实验中，我们将学习和实现几种常见的排序算法，并对它们的性能进行比较和分析。

一、冒泡排序冒泡排序是最简单的排序算法之一，它通过不断交换相邻的元素，将较大（或较小）的元素逐渐“冒泡”到数组的一端。

具体实现时，我们可以使用两层循环来比较和交换元素，直到整个数组有序。

二、插入排序插入排序的思想是将数组分为两个部分：已排序部分和未排序部分。

每次从未排序部分中取出一个元素，插入到已排序部分的适当位置，以保持已排序部分的有序性。

插入排序的实现可以使用一层循环和适当的元素交换。

三、选择排序选择排序每次从未排序部分中选择最小（或最大）的元素，与未排序部分的第一个元素进行交换。

通过不断选择最小（或最大）的元素，将其放置到已排序部分的末尾，从而逐渐形成有序序列。

四、快速排序快速排序是一种分治的排序算法，它通过选择一个基准元素，将数组划分为两个子数组，其中一个子数组的所有元素都小于等于基准元素，另一个子数组的所有元素都大于基准元素。

然后对两个子数组分别递归地进行快速排序，最终将整个数组排序。

五、归并排序归并排序也是一种分治的排序算法，它将数组划分为多个子数组，对每个子数组进行排序，然后再将排好序的子数组合并成一个有序的数组。

归并排序的实现可以使用递归或迭代的方式。

六、性能比较与分析在本次实验中，我们对以上几种排序算法进行了实现，并通过对不同规模的随机数组进行排序，比较了它们的性能。

我们使用了计算排序时间的方式，并记录了每种算法在不同规模下的运行时间。

通过对比实验结果，我们可以得出以下结论：1. 冒泡排序和插入排序在处理小规模数据时表现较好，但在处理大规模数据时性能较差，因为它们的时间复杂度为O(n^2)。

2. 选择排序的时间复杂度也为O(n^2)，与冒泡排序和插入排序相似，但相对而言，选择排序的性能稍好一些。

数据结构实验—排序

实验十五排序1.实验目的（1）掌握各种排序的基本思想。

（2）掌握各种排序算法实现方法。

2.实验内容随机函数产生若干个随机数，用直接插入、冒泡、快速等排序方法排序。

3.实验要求（1）根据实验内容编写程序，上机调试并获得运行结果（2）撰写实验报告4.关键步骤与算法(1)直接插入算法步骤；1）将整个待排序的记录序列划分成有序区和无序区，初始时有序区为待排序记录序列的第一个记录，无序区包括所有剩余待排序的记录。

2）将无序区的第一个记录插入到有序区的合适位置，从而使无序区减少一个记录，有序区增加一个记录。

3）重复执行第（2）步，直到无序区中没有记录为止。

算法如下；1.//插入排序2.void SortC(SqList *L){3.int i, j;4.for (i = 2; i <= L->length;i++){5. L->R[0] = L->R[i];6. j = i - 1;7.while(LT(L->R[0].key,8. L->R[j].key)){9. L->R[j + 1] = L->R[j];10. j--;11. }12. L->R[j + 1] = L->R[0];13. }14.}(2)冒泡排序算法步骤；冒泡排序的基本思想是对所有相邻记录的关键字进行比效，如果是逆序（a ［i］＞a［j＋1］），则将其交换，最终达到有序化，其处理过程如下。

1）将整个待排序的记录序列划分成有序区和无序区，初始状态有序区为空，无序区则包括所有待排序的记录。

2）对无序区从前往后依次将相邻记录的关键字进行比较，若逆序，则将其交换，从而使得关键字小的记录向上“飘浮”（左移），关键字大的记录好像石块，向下“坠落”（右移）。

每经过一趟冒泡排序，都使无序区中关键字最大的记录进入有序区，对于由n个记录组成的记录序列，最多经过（n-1）趟冒泡排序，就可以将这n个记录重新按关键字顺序排列。

排序系统设计数据结构课程设计

排序系统设计数据结构课程设计一、项目背景和目的排序系统是计算机科学中常见的一种算法，用于将一组数据按照特定的顺序进行罗列。

在数据结构课程设计中，我们需要设计一个排序系统，以实现对输入数据的排序功能。

本文将详细介绍排序系统的设计思路、数据结构的选择和实现方法。

二、设计思路1. 功能需求根据任务名称所描述的需求，我们的排序系统需要具备以下功能：- 支持多种排序算法，如冒泡排序、插入排序、选择排序、快速排序等。

- 能够处理不同类型的数据，如整数、浮点数、字符串等。

- 具备可扩展性，方便后续添加更多的排序算法。

2. 数据结构选择为了实现排序系统的功能，我们需要选择适合的数据结构来存储和操作数据。

常见的数据结构有数组、链表、栈、队列等。

在排序系统中，我们可以使用数组来存储待排序的数据。

3. 算法选择根据任务名称所描述的排序系统，我们需要选择多种排序算法来实现。

以下是几种常见的排序算法：- 冒泡排序：通过相邻元素的比较和交换，将较大的元素逐渐“冒泡”到数组末尾。

- 插入排序：将待排序的元素按照顺序插入到已排序的数组中。

- 选择排序：每次从待排序的数组中选择最小的元素，放到已排序的数组末尾。

- 快速排序：通过一趟排序将待排序的数组分割成独立的两部份，其中一部份的元素都比另一部份的元素小。

4. 系统设计基于以上的设计思路，我们可以将排序系统设计为以下几个模块：- 输入模块：用于接收用户输入的待排序数据。

- 排序算法模块：包含多种排序算法的实现。

- 输出模块：将排序结果输出给用户。

三、数据结构的实现在排序系统中，我们选择使用数组来存储待排序的数据。

数组具有随机访问的特性，方便进行元素的比较和交换。

以下是数组的实现代码示例：```pythonclass Array:def __init__(self, capacity):self.capacity = capacityself.data = [None] * capacityself.size = 0def append(self, value):if self.size == self.capacity:# 数组已满，需要扩容self.resize()self.data[self.size] = valueself.size += 1def resize(self):self.capacity *= 2new_data = [None] * self.capacityfor i in range(self.size):new_data[i] = self.data[i]self.data = new_datadef swap(self, i, j):self.data[i], self.data[j] = self.data[j], self.data[i]```四、排序算法的实现在排序系统中，我们需要实现多种排序算法。

数据结构排序实验报告

引言概述：数据结构排序实验是计算机科学与技术专业中一项重要的实践课程。

通过实验，可以深入理解和掌握不同排序算法的原理、特点和性能表现。

本文将针对数据结构排序实验进行详细的阐述和总结，包括实验目的、实验内容、实验结果分析和总结。

一、实验目的1. 加深对数据结构排序算法的理解：通过实验，掌握不同排序算法的工作原理和实现方式。

2. 分析和比较不同排序算法的性能：对比不同排序算法在不同数据规模下的时间复杂度和空间复杂度，理解它们的优劣势。

3. 提高编程和算法设计能力：通过实验的编写，提升对排序算法的实现能力和代码质量。

二、实验内容1. 选择排序算法：选择排序是一种简单直观的排序算法，将序列分为有序和无序两部分，每次从无序部分选择最小（最大）元素，放到有序部分的末尾（开头）。

- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析2. 插入排序算法：插入排序逐步构建有序序列，对于未排序的元素，在已排序序列中从后向前扫描，找到对应位置插入。

- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析3. 快速排序算法：快速排序利用分治的思想，将序列分为左右两部分，选取基准元素，将小于基准的放在左边，大于基准的放在右边，递归地对左右部分进行排序。

- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析4. 归并排序算法：归并排序是一种稳定的排序算法，通过将序列分为若干子序列，分别进行排序，然后再将排好序的子序列合并成整体有序序列。

- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析5. 堆排序算法：堆是一种特殊的树状数据结构，堆排序利用堆的性质进行排序，通过构建大顶堆或小顶堆，并逐个将堆顶元素移出形成有序序列。

- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析三、实验结果分析1. 比较不同排序算法的执行时间：根据实验数据和分析，对比不同排序算法在不同数据规模下的执行时间，并针对其时间复杂度进行验证和分析。

数据结构排序实验报告

数据结构排序实验报告一、实验目的本次数据结构排序实验的主要目的是深入理解和掌握常见的排序算法，包括冒泡排序、插入排序、选择排序、快速排序和归并排序，并通过实际编程和实验分析，比较它们在不同规模数据下的性能表现，从而为实际应用中选择合适的排序算法提供依据。

二、实验环境本次实验使用的编程语言为 Python 3x，开发环境为 PyCharm。

实验中使用的操作系统为 Windows 10。

三、实验原理1、冒泡排序（Bubble Sort）冒泡排序是一种简单的排序算法。

它重复地走访要排序的数列，一次比较两个数据元素，如果顺序不对则进行交换，并一直重复这样的走访操作，直到没有要交换的数据元素为止。

2、插入排序（Insertion Sort）插入排序是一种简单直观的排序算法。

它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入，直到整个数组有序。

3、选择排序（Selection Sort）首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

以此类推，直到所有元素均排序完毕。

4、快速排序（Quick Sort）通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

5、归并排序（Merge Sort）归并排序是建立在归并操作上的一种有效、稳定的排序算法，该算法是采用分治法(Divide and Conquer）的一个非常典型的应用。

将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。

四、实验步骤1、算法实现使用 Python 语言分别实现上述五种排序算法。

为每个算法编写独立的函数，函数输入为待排序的列表，输出为排序后的列表。

2、生成测试数据生成不同规模（例如 100、500、1000、5000、10000 个元素）的随机整数列表作为测试数据。

数据结构实验报告排序

实验报告实验目的：1.掌握各种排序方法的排序过程；2.了解一些排序算法的实现。

实验内容：学生的考试成绩表由学生的学号、姓名和成绩组成，设计一个程序对给定的n个学生信息实现：1.按分数高低排序，打印出每个学生在考试中的排名，分数相同的为同一名次，同一名次的学生按学号从小到大排列。

2.按照名次列出每个学生的名次、学号、姓名、成绩。

实验原理：排序分为插入排序、交换排序、选择排序、归并排序等。

插入排序又分为直接插入排序、其他插入排序和希尔排序；交换排序分为冒泡排序和快速排序；选择排序又分为简单选择排序和堆排序。

不同的排序方法各有利弊，根据具体的情况选择合适的排序方法。

设计思想:本程序采用简单选择排序的方法。

程序中定义一个stu结构和student类。

类中定义creat 创建函数，selectgrade成绩排序函数，samegrade、selectnum成绩相同的按学号排序函数，print输出函数。

按照选择排序的思想，先对成绩按照从高到低进行排序；然后寻找成绩相同的部分，对该局部元素的学号从小到大进行排序。

然后调用输出函数，输出名次、学号、姓名、成绩。

实现部分:源代码：#include<iostream.h>struct stu{int num;char name[100];int grade;};class student{ struct stu s[100];int length;int start,end;public:student(){length=0;}void creat();void selectgrade();void samegrade();void selectnum();void print();};//创建顺序表void student::creat(){cout<<"请依次输入学生的学号、姓名、成绩。

输入#结束:"<<endl; int num;cin>>num;while(num){s[length].num=num;cin>>s[length].name;cin>>s[length].grade;cin>>num;length++;}}//对成绩进行选择排序void student::selectgrade(){stu temp;int i,j,k;for(i=0;i<length;i++){k=i;for(j=i+1;j<length;j++){if(s[j].grade>s[k].grade)k=j;}if(k!=i){temp=s[i];s[i]=s[k];s[k]=temp;}}}//对成绩相同的学号进行选择排序void student::samegrade(){int i,j;for(i=0;i<length;i++){if(s[i].grade==s[i+1].grade){for(j=length-1;;j--){if(s[j].grade==s[i].grade)break;}start=i;end=j;i=j;}selectnum();}}//对学号进行选择排序void student::selectnum(){stu temp;int i,j,k;for(i=start;i<=end;i++){k=i;for(j=i+1;j<=end;j++){if(s[j].num<s[k].num)k=j;}if(k!=i){temp=s[i];s[i]=s[k];s[k]=temp;}}}void student::print(){int i,j=0,k=0;cout<<"成绩从高到低依次为（成绩相同按学号从小到大排列）"<<endl;cout<<"名次学号姓名成绩"<<endl;for(i=0;i<length;i++){ if(i==0)cout<<k+1<<" "<<s[i].num<<" "<<s[i].name<<""<<s[i].grade<<endl;else{if(s[i].grade==s[i-1].grade){j++;k=i-j;}else {j=0;k=i-j;}cout<<k+1<<" "<<s[i].num<<" "<<s[i].name<<" "<<s[i].grade<<endl;} }}int main(){student ss;ss.creat();ss.selectgrade();ss.samegrade();ss.print();}测试用例1.实验小节：通过本程序的练习，对各种排序方法的排序过程有了更深的了解，对各种排序算法的实现特别是选择排序有了更深的认识。

数据结构实验10：排序子系统

验证性实验10：排序子系统班级学号 BX100420 姓名施程程1．实验目的（1）掌握常用排序方法的基本思想。

（2）通过实验加深理解各种排序算法。

（3）通过实验掌握各种排序方法的时间复杂度分析。

（4）了解各种排序方法的优缺点及适用范围。

2．实验内容（1）编写直接插入排序程序。

（2）编写希尔排序程序。

（3）编写冒泡排序程序。

（4）编写快速排序程序。

（5）编写选择排序程序。

（6）编写归并排序程序。

（7）编写堆排序程序。

（8）程序执行时，要求能显示每一趟的排序结果。

（9）设计一个选择式菜单，以菜单方式选择上述排序程序。

排序子系统**************************************************** 1------------更新排序数据 ** 2------------直接插入排序 ** 3------------希尔排序 ** 4------------冒泡排序 ** 5------------快速排序 ** 6------------选择排序 ** 7------------归并排序 ** 8------------堆排序 ** 0------------返回 **************************************************** 请选择菜单号（0--8）：3．实验程序#include<stdio.h>#include<stdlib.h>#include<math.h>#define L 8#define FALSE 0#define TURE 1typedef struct{int key;char otherinfo;}RecType;typedef RecType Seqlist[L+1];int num;Seqlist R;void Insertsort();void Bubblesort();void QuickSort(int low,int high);void Shellsort();void Selectsort();void Mergesort();int Partition(int i,int j);void Heap();void main(){Seqlist S;int i,k;char ch1,ch2,q;printf("\n\t请输入%d个待排序数据（按【Enter】键分隔）：\n\t",L);for(i=1;i<=L;i++){scanf("%d",&S[i].key);getchar();printf("\t");}printf("\n\t排序数据已经输入完毕！");ch1='y';while(ch1=='y'||ch1=='Y'){printf("\n");printf("\n\t\t 排序子系统");printf("\n\t\t***************************************************");printf("\n\t\t* 1------------更新排序数据*");printf("\n\t\t* 2------------直接插入排序*");printf("\n\t\t* 3------------希尔排序*");printf("\n\t\t* 4------------冒泡排序*");printf("\n\t\t* 5------------快速排序*");printf("\n\t\t* 6------------选择排序*");printf("\n\t\t* 7------------归并排序*");printf("\n\t\t* 8------------堆排序*");printf("\n\t\t* 0------------返回*");printf("\n\t\t***************************************************");printf("\n\t\t请选择菜单号（0--8）：");scanf("%c",&ch2);getchar();for(i=1;i<=L;i++)R[i].key=S[i].key;switch(ch2){case '1':printf("\n\t请输入%d个待排序数据（按【Enter】键分隔）：\n\t",L);for(i=1;i<=L;i++){scanf("%d",&S[i].key);getchar();printf("\t");}printf("\n\t排序数据已经输入完毕！");break;case '2':Insertsort();break;case '3':Shellsort();break;case '4':Bubblesort();break;case '5':printf("\n\t原始数据为（按【Enter】键开始排序）：");for(k=1;k<=L;k++)printf("%5d",R[k].key);getchar();printf("\n");num=0;QuickSort(1,L);printf("\n\t排序的最终结果是：");for(k=1;k<=L;k++)printf("%5d",R[k].key);printf("\n");break;case '6':Selectsort();break;case '7':Mergesort();break;case '8':Heap();break;case '0':ch1='n';break;default:printf("\n\t输入出错！");}if(ch2!='0'){if(ch2=='2'||ch2=='3'||ch2=='4'||ch2=='5'||ch2=='6'||ch2=='7'||ch2=='8') printf("\n\t排序输出完毕！");printf("\n\n\t按回车键返回。

数据结构实验：排序

排序实验：常用排序方法实现
实验目的：
1、熟悉常用的内部排序方法：插入排序、选择排序、交换
排序、基数排序和归并排序；
2、通过实验，掌握排序的思路和方法，并能分析常用的排序
方法的时间复杂度和稳定性。

实验要求：
1、在vc++或tc环境下实现基本功能；
2、先完成基本功能，基本功能为必做内容，有多余时间的同
学可以做选做的内容；
3、独自完成实验操作，并给出相关的数据；
4、每次实验后，撰写实验报告，并在下星期一由学习委员收
集并按学号整理好后，交任课教师。

实验内容及步骤：
必做题：
1、从键盘任意输入一组数据，对该组数据进行希尔排序，
并输出每一趟的排序结果；
2、从键盘任意输入一组数据，对该组数据进行快速排序，
并输出每一趟的排序结果；
3、从键盘任意输入一组数据，对该组数据进行选择排序，
并输出每一趟的排序结果；
选做题：1、从键盘任意输入一组数据，对该组数据进行堆排
序，并输出每一趟的排序结果；
2、从键盘任意输入一组数据，对该组数据进行归并排序，
并输出每一趟的排序结果；
3、从键盘任意输入一组数据，对该组数据进行基数排序，并输出每一趟的排序结果；。

排序子系统(二)程序

case 0: main(); break;
default: break;
}
fflush(stdin);
getchar();
system("cls");
}
}
{
printf("%d ", x[i]);
}
for (i=1; i <n; i++) //排序
{
t=*(x+i); //复制到哨兵
for (j=i-1; j>=0 && t <*(x+j); j--)
{
*(x+j+1) = *(x+j); //记录后移
}
*(x+j+1) = t; //插入到正确位置
int choose=0;
while(true)
{
show();
printf("\t\t请选择菜单号（0…2）：");
scanf("%d",&choose);
system("cls");
switch(choose)
{
case 1: insert_sort(x, n);back(); break;
case 2: shell_sort(arr, n); back(); break;
for(i=0; i<n; i++) //输出排序前的数组
{
printf("%d ", x[i]);
}
for (h=n/2; h>0; h=h/2) //排序
{
for (j=h; j <n; j++)

数据结构排序实验报告

《数据结构》课程设计报告实验五排序一、需求分析：本演示程序用C++6.0编写，完成各种排序的实现，对输入的一组数字实现不同的排序方法，对其由小到大顺序输出。

（1）分别对直接插入排序、希尔排序、冒泡排序、快速排序、选择排序、堆排序算法进行编写。

（2）、对存储的函数即输入的数字进行遍历。

（3）、初始化函数对输入的数字进行保存。

（4）、主函数实现使用者操作界面的编写，对输入、选择、保存、输出的各种实现。

这当中还包括了各个函数的调用的实现。

（5）、程序所能达到的功能：完成对输入的数字的生成，并通过对各排序的选择实现数字从小到大的输出。

二、程序主要功能以及基本要求：（1）、设计一个菜单，格式如下：1、直接插入排序2、希尔排序3、冒泡排序4、快速排序5、选择排序6、堆排序7、退出（2）、选择不同的菜单但进行相应的排序，并给出排序的关键字序列。

三、系统框架图：本程序包含了9个函数，它们分别是：（1）、直接插入排序的算法函数InsertSort（）。

（2）、希尔排序的算法函数ShellSort（）。

（4）、快速排序的算法函数Partition（）。

（5）、选择排序算法函数SelectSort（）。

（6）、堆排序算法函数HeapAdjust（）。

（7）、对存储数字的遍历函数Visit（）。

（8）、初始化函数InitSqList（）。

（9）、主函数main（）。

四、详细设计实现各个算法的主要内容，下面是各个函数的主要信息：（1）各个排序函数的算法：一、直接插入排序void InsertSort(SqList &L){int i,j;for( i=2; i<=L.length;i++){if(L.r[i].key < L.r[i-1].key){L.r[0] = L.r[i];L.r[i] = L.r[i-1];for( j=i-2; (L.r[0].key < L.r[j].key); j--)L.r[j+1] = L.r[j];L.r[j+1] = L.r[0];}}}二、希尔排序void ShellSort(SqList &L){int i, j;int dk = 1;//增量while(dk <=L.length/3)dk = 3*dk+1;//增大增量while(dk>0){dk /= 3;//减小增量for (i = dk; i <=L.length; i++){L.r[0].key = L.r[i].key;j = i;while ((j >= dk) && (L.r[j-dk].key > L.r[0].key)){L.r[j].key = L.r[j-dk].key;j -= dk;}L.r[j].key = L.r[0].key;}}}三、冒泡排序void BubbleSort(SqList &L){int i,j;for(i=0;i<L.length-2;i++){int flag = 1;for(j=0;j<L.length-i-2;j++)if(L.r[j].key > L.r[j+1].key){flag = 0;int temp;temp = L.r[j].key;L.r[j].key = L.r[j+1].key;L.r[j+1].key = temp;}//若无交换说明已经有序if(flag==1)break;}四、快速排序int Partition(SqList &L,int low,int high){//分割区域函数L.r[0] = L.r[low];int pivotkey = L.r[low].key;//一般将顺序表第一个元素作为支点while(low < high){while(low<high && L.r[high].key>=pivotkey)high--;L.r[low] = L.r[high];while(low<high && L.r[low].key<=pivotkey)low++;L.r[high] = L.r[low];}L.r[low] = L.r[0];//返回枢轴位置return low;}void QSort(SqList &L,int low,int high){//每张子表的快速排序if(low<high){int pivotloc = Partition(L,low,high);QSort(L,low,pivotloc-1);QSort(L,pivotloc+1,high);}}void QuickSort(SqList &L)QSort(L,1,L.length);}五、简单选择排序void SelectSort(SqList &L){int min;int j;for (int i = 0; i <L.length; i++){ // 选择第i小的记录，并交换j = i;min = L.r[i].key;for (int k = i; k < L.length; k++){ // 在R[i..n-1]中选择最小的记录if (L.r[k].key < min){min = L.r[k].key ;j = k;}}if (i != j){ // 与第i个记录交换int temp = L.r[i].key;L.r[i].key = L.r[j].key;L.r[j].key = temp;}}}六、堆排序void HeapAdjust(HeapType &H,int s,int m)//堆调整，将记录调整为小顶堆int j;RedType rc = H.r[s];//暂时存储根结点for(j=2*s; j<=m; j*=2){//沿着结点记录较小的向下筛选if(j<m && H.r[j].key<H.r[j+1].key)++j;if(rc.key>= H.r[j].key)break;H.r[s] = H.r[j];s = j;}H.r[s] = rc;}void HeapSort(HeapType &H){int i;RedType temp;for(i = H.length; i>0; --i)HeapAdjust(H,i,H.length);for(i=H.length; i>1; --i){temp = H.r[1];H.r[1] = H.r[i];H.r[i] = temp;HeapAdjust(H,1,i-1);}（2）遍历函数与初始化void Visit(SqList L){for(int i=1; i<=L.length; i++)cout<<L.r[i].key<<" ";cout<<endl;}void InitSqList(SqList &L,int a[]){for(int i=1;i<=L.length;i++)L.r[i].key = a[i];}五、测试结果以下是各种界面的测试结果：（1）输入的界面:（2）排序操作界面：（3）各种排序的结果：六、设计不足以及存在问题本程序是基于C++6.0的实现，其实在设计上的改进可以利用类进行操作，这种类的改进了存储上的不足还可以实现了，对各种的函数基于类的实现，这就是对本程序的改进，这是十分重要的与是改进的基础。

数据结构实验安排

数据结构实验安排实验一顺序表的插入和删除1.实验目的：了解顺序表的基本概念、结构的定义及在顺序表上的基本操作(插入、删除、查找以及线性表合并)，通过用C语言实现以上操作，更好地了解书本上的内容。

2.实验预备知识：⑴复习C语言中数组的用法。

⑵了解线性表和顺序表的概念，顺序表的定义方法；✧线性表是n个数据元素的有限序列，至于每个数据元素的具体含义，在不同的情况下各不相同。

✧顺序表是线性表的顺序存储表示，是用一组地址连续的存储单元依次存储线性表的数据元素。

✧在C语言中，顺序表是用数组或指针来实现的。

⑶掌握线性表在顺序存储结构上实现基本操作：查找、插入、删除和合并的算法。

在实现这些算法的时候，要注意判断输入数据的合法性，除此之外还要要注意以下内容：✧在实现查找的时候，首先要判断该顺序表是否为空，其次要判断查找后的结果(查到时输出查到的数据，未查到时给出错误提示)。

✧在实现插入的时候，首先要判断该顺序表是否为满，如为满则须重新分配空间(此时要注意：若顺序表是用数组来实现的，它不能随机分配空间)；如不为满，则需判断要插入的位置是否合法（例如：如果一个线性表的元素只有10个，而要在第0个元素前插入或在第11个元素后插入就为不合法）。

其次要注意是前插还是后插，两者是有区别的；最后还要注意插入时各个数据元素移动的次序是从后面依次开始移动。

在实现删除的时候，首先要判断该顺序表是否为空，如为空则报错，如不为空，则需判断要删除的位置是否合法（例如：如果一个线性表的元素只有10个，而要删除第0个或第十一个元素就为不合法）。

其次还要注意删除时各个数据元素移动的次序是从前面依次开始移动。

3.实验内容：1、顺序表的建立2、顺序表的插入（输入插入位置i,插入元素）3、顺序表的删除（输入删除元素位置i）4、顺序表的打印5、顺序表的合并算法（选做）实验二单链表的插入和删除1.实验目的：了解单链表的基本概念、结构的定义及在单链表上的基本操作(插入、删除、查找以及线性表合并)，通过在Turbo C实现以上操作更好的了解书本上的内容并体会线性表的两种存储结构的区别。

数据结构实验10：排序子系统

数据结构排序实验报告

数据结构实验报告-排序

数据结构实验报告——排序

数据结构排序实验报告

数据结构实验报告——排序

《数据结构》实验报告——排序

排序子系统实验报告

北邮数据结构实验报告-排序

数据结构实验报告-实验5-排序

数据结构实验报告排序

数据结构实验—排序

排序系统设计数据结构课程设计

数据结构排序实验报告

数据结构排序实验报告

数据结构 实验报告 排序

数据结构实验10：排序子系统

数据结构实验：排序

排序子系统(二)程序

数据结构排序实验报告

数据结构实验安排

数据结构实验报告排序