数据结构实验七排序
数据结构排序实验报告
数据结构排序实验报告数据结构排序实验报告引言：数据结构是计算机科学中的重要概念之一，它涉及到数据的组织、存储和操作方式。
排序是数据结构中的基本操作之一，它可以将一组无序的数据按照特定的规则进行排列，从而方便后续的查找和处理。
本实验旨在通过对不同排序算法的实验比较，探讨它们的性能差异和适用场景。
一、实验目的本实验的主要目的是通过实际操作，深入理解不同排序算法的原理和实现方式，并通过对比它们的性能差异，选取合适的排序算法用于不同场景中。
二、实验环境和工具实验环境：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 );}。
数据结构实验报告-排序
数据结构实验报告-排序一、实验目的本实验旨在探究不同的排序算法在处理大数据量时的效率和性能表现，并对比它们的优缺点。
二、实验内容本次实验共选择了三种常见的排序算法：冒泡排序、快速排序和归并排序。
三个算法将在同一组随机生成的数据集上进行排序，并记录其性能指标，包括排序时间和所占用的内存空间。
三、实验步骤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. 快速排序由于其递归调用栈的使用，时间复杂度虽然较低，但空间复杂度较高。
综上所述，选择排序、插入排序和冒泡排序适用于小规模数据排序，而归并排序、快速排序和堆排序适用于大规模数据排序。
数据结构实验报告——排序
数据结构实验报告排序姓名：13-计算机-舞学号：0000000000专业：计算机科学与技术班级：计算机13-2班日期：2014年6月6日星期五一、实验目的和要求通过编程实现直接插入排序、希尔排序、冒泡排序、快速排序、直接选择排序。
要求输入一些无序数，执行程序后使他们变成有序数并在窗口输出。
二、实验环境1、windows 72、c-free 5.0三、实验内容用五种排序算法对输入的数进行排序，并在屏幕中输出。
四、实验过程1、直接插入排序：即将所需要排序的数据分成两部分，其中一部分为已排好序部分，另一部分为未排序部分。
然后从未排序部分中选出一元素插入到一排序部分中，要求插入后已排序部分任然有序。
在编写该程序时，我将要排序的数据储存在一个数组中，并将第一个数划分为已经排序部分然后从下一个数开始不断和前边的最后一个数比较，知道找到插入位置。
2、希尔排序：希尔排序是建立在直接插入排序的基础之上的，他是通过将数据分成几组，在组内实现插入排序，使整个数据基本有序，最后再对整个数据实现插入排序。
这里同样将数据储存在数组中，分组的步长每次取之前步长的一半。
需要注意的是，移动元素时，下标不再是减1，而是减去步长。
3、冒泡排序：通过不断比较相邻的两个元素，发现倒序即交换，最终实现排序。
在这个程序中，我从后面开始向前比较。
每依次循环可以最终确定一个元素在其最终位置上，所以每次循环之后，元素间的两两比较次数减1.4、快速排序：选定一个元素作为中间元素，将整个数据分为比中间元素小的一组和比中间元素大的一组，并且小的在中间元素前，大的在中间元素后。
再分好的两组内再次重复上诉过程使所有元素排好序。
5、直接选择排序：将待排序数据存入数组中，扫描一遍数组，将其中最小的元素找出并放在第一位，再扫描一遍剩下的元素，找到最小的放在第二位。
如此不断重复知道扫描了n-1次。
由于不要再开新空间，所以找到最小元素时用交换的方式使其放在第一位。
比如第一遍扫描，假设第一个为最小元素，再扫描过程中，如果发现比它小的数，则把第一个元素和该位置的元素交换。
数据结构各种排序实验报告
目录1.引言............................................................................................................................ 错误！未定义书签。
2.需求分析.................................................................................................................... 错误！未定义书签。
3.详细设计.................................................................................................................... 错误！未定义书签。
3.1 直接插入排序................................................................................................ 错误！未定义书签。
3.2折半排序......................................................................................................... 错误！未定义书签。
3.3 希尔排序........................................................................................................ 错误！未定义书签。
3.4简单选择排序................................................................................................. 错误！未定义书签。
《数据结构》实验报告——排序
《数据结构》实验报告排序实验题目：输入十个数，从插入排序，快速排序，选择排序三类算法中各选一种编程实现。
实验所使用的数据结构内容及编程思路：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．掌握顺序查找操作的算法实现。
二、实验平台操作系统：Windows7或Windows XP开发环境：JA V A三、实验内容及要求1．建立顺序查找表，并在此查找表上实现顺序查找操作。
四、实验的软硬件环境要求硬件环境要求：PC机（单机）使用的软件名称、版本号以及模块：Netbeans 6.5以上或Eclipse、MyEclipse等编程环境下。
五、知识准备前期要求掌握查找的含义和顺序查找操作的方法。
六、验证性实验1．实验要求编程实现如下功能：（1）根据输入的查找表的表长n和n个关键字值，建立顺序查找表，并在此查找表中用顺序查找方法查找给定关键值的记录，最后输出查找结果。
2. 实验相关原理：查找表分别静态查找表和动态查找表两种，其中只能做引用操作的查找表称为静态查找表。
静态查找表采用顺序存储结构，待查找的记录类可描述如下：public class RecordNode {private Comparable key; //关键字private Object element; //数据元素……}待排序的顺序表类描述如下：public class SeqList {private RecordNode[] r; //顺序表记录结点数组private int curlen; //顺序表长度，即记录个数// 顺序表的构造方法，构造一个存储空间容量为maxSize的顺序表public SeqList(int maxSize) {this.r = new RecordNode[maxSize]; // 为顺序表分配maxSize个存储单元this.curlen = 0; // 置顺序表的当前长度为0}……}【核心算法提示】查找操作是根据给定的某个值，在查找表中确定一个其关键字等于给定值的数据元素或记录的过程。
若查找表中存在这样一个记录，则称“查找成功”。
查找结果给出整个记录的信息，或指示该记录在查找表中的位置；若在查找表中不存在这样的记录，则称“查找不成功”。
北邮数据结构实验报告-排序
北邮数据结构实验报告-排序北邮数据结构实验报告-排序一、实验目的本实验旨在掌握常见的排序算法，包括冒泡排序、插入排序、选择排序、快速排序、归并排序等，并通过实际编程实现对数字序列的排序。
二、实验内容1.冒泡排序冒泡排序是一种简单的排序算法，其基本思想是依次比较相邻的两个元素，并按照从小到大或从大到小的顺序交换。
具体步骤如下：- 从待排序序列的第一个元素开始，依次比较相邻的两个元素；- 如果前面的元素大于后面的元素，则交换这两个元素的位置；- 重复上述步骤，直到整个序列有序。
2.插入排序插入排序是一种简单且直观的排序算法，其基本思想是将待排序序列分为已排序和未排序两部分，每次从未排序部分中选择一个元素插入到已排序部分的合适位置。
具体步骤如下：- 从待排序序列中选择一个元素作为已排序部分的第一个元素；- 依次将未排序部分的元素插入到已排序部分的合适位置，使得已排序部分保持有序；- 重复上述步骤，直到整个序列有序。
3.选择排序选择排序是一种简单且直观的排序算法，其基本思想是每次选择未排序部分中的最小（或最大）元素，并将其放在已排序部分的末尾。
具体步骤如下：- 在未排序部分中选择最小（或最大）的元素；- 将选择的最小（或最大）元素与未排序部分的第一个元素交换位置；- 重复上述步骤，直到整个序列有序。
4.快速排序快速排序是一种高效的排序算法，其基本思想是通过一趟排序将待排序序列分割成两部分，其中一部分的元素都比另一部分的元素小。
具体步骤如下：- 选择一个枢轴元素（一般选择第一个元素）；- 将待排序序列中小于枢轴元素的元素放在枢轴元素的左侧，大于枢轴元素的元素放在枢轴元素的右侧；- 对枢轴元素左右两侧的子序列分别进行递归快速排序；- 重复上述步骤，直到整个序列有序。
5.归并排序归并排序是一种高效的排序算法，其基本思想是将待排序序列划分成足够小的子序列，然后对这些子序列进行两两合并，最终形成有序的序列。
具体步骤如下：- 将待排序序列递归地划分成足够小的子序列；- 对每个子序列进行归并排序；- 合并相邻的子序列，直到整个序列有序。
数据结构 实验报告 排序
实验报告实验目的：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.实验小节：通过本程序的练习，对各种排序方法的排序过程有了更深的了解，对各种排序算法的实现特别是选择排序有了更深的认识。
数据结构实验报告排序
数据结构实验报告排序数据结构实验报告：排序引言：排序是计算机科学中常见的算法问题之一，它的目标是将一组无序的数据按照特定的规则进行排列，以便于后续的查找、统计和分析。
在本次实验中，我们将学习和实现几种常见的排序算法，并对它们的性能进行比较和分析。
一、冒泡排序冒泡排序是最简单的排序算法之一，它通过不断交换相邻的元素，将较大（或较小）的元素逐渐“冒泡”到数组的一端。
具体实现时，我们可以使用两层循环来比较和交换元素，直到整个数组有序。
二、插入排序插入排序的思想是将数组分为两个部分：已排序部分和未排序部分。
每次从未排序部分中取出一个元素，插入到已排序部分的适当位置，以保持已排序部分的有序性。
插入排序的实现可以使用一层循环和适当的元素交换。
三、选择排序选择排序每次从未排序部分中选择最小（或最大）的元素，与未排序部分的第一个元素进行交换。
通过不断选择最小（或最大）的元素，将其放置到已排序部分的末尾，从而逐渐形成有序序列。
四、快速排序快速排序是一种分治的排序算法，它通过选择一个基准元素，将数组划分为两个子数组，其中一个子数组的所有元素都小于等于基准元素，另一个子数组的所有元素都大于基准元素。
然后对两个子数组分别递归地进行快速排序，最终将整个数组排序。
五、归并排序归并排序也是一种分治的排序算法，它将数组划分为多个子数组，对每个子数组进行排序，然后再将排好序的子数组合并成一个有序的数组。
归并排序的实现可以使用递归或迭代的方式。
六、性能比较与分析在本次实验中，我们对以上几种排序算法进行了实现，并通过对不同规模的随机数组进行排序，比较了它们的性能。
我们使用了计算排序时间的方式，并记录了每种算法在不同规模下的运行时间。
通过对比实验结果，我们可以得出以下结论：1. 冒泡排序和插入排序在处理小规模数据时表现较好，但在处理大规模数据时性能较差，因为它们的时间复杂度为O(n^2)。
2. 选择排序的时间复杂度也为O(n^2)，与冒泡排序和插入排序相似，但相对而言，选择排序的性能稍好一些。
数据结构试验查找排序
实验七查找、排序的应用一、实验目的1、本实验可以使学生更进一步巩固各种查找和排序的基本知识。
2、学会比较各种排序与查找算法的优劣。
3、学会针对所给问题选用最适合的算法。
4、掌握利用常用的排序与选择算法的思想来解决一般问题的方法和技巧。
二、实验内容[问题描述]对学生的基本信息进行管理。
[基本要求]设计一个学生信息管理系统，学生对象至少要包含：学号、姓名、性别、成绩1、成绩2、总成绩等信息。
要求实现以下功能：1．总成绩要求自动计算；2．查询：分别给定学生学号、姓名、性别，能够查找到学生的基本信息（要求至少用两种查找算法实现）；3．排序：分别按学生的学号、成绩1、成绩2、总成绩进行排序（要求至少用两种排序算法实现）。
[测试数据]由学生依据软件工程的测试技术自己确定。
三、实验前的准备工作1、掌握哈希表的定义，哈希函数的构造方法。
2、掌握一些常用的查找方法。
1、掌握几种常用的排序方法。
2、掌握直接排序方法。
四、实验报告要求1、实验报告要按照实验报告格式规范书写。
2、实验上要写出多批测试数据的运行结果。
3、结合运行结果，对程序进行分析。
一、需求分析设计一个学生信息管理系统，学生对象包含：学号、姓名、性别、班级、成绩1、成绩2、总成绩，要求实现以下功能：1．总成绩要求自动计算；2．查询：分别给定学生学号、姓名、性别，能够查找到学生的基本信息3．排序：分别按学生的学号、成绩1、成绩2、总成绩进行排序二、概要设计typedef struct{float num;//学生学号string name;//学生姓名string sex;//性别char className[20];//班级名称float mark1;//第1门成绩float mark2;//第2门成绩float sum;//第3门成绩}DataType;typedef struct //定义顺序表的结构{DataType r[ MAXSIZE +1 ]; //存储顺序表的向量int length; //顺序表的长度}SqList;int menu()菜单函数void CreatList(SqList &ST) //创建学生的相关信息void sort(SqList &ST) //排序void Query(SqList &ST) //查询信息void main()三、详细设计#include <iostream>#include<string>#include <iomanip>using namespace std;#define MAXSIZE 100typedef struct{float num;//学生学号string name;//学生姓名string sex;//性别char className[20];//班级名称float mark1;//第1门成绩float mark2;//第2门成绩float sum;//第3门成绩}DataType;typedef struct //定义顺序表的结构{DataType r[ MAXSIZE +1 ]; //存储顺序表的向量int length; //顺序表的长度}SqList;int menu(){int i;cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;cout<<" 学生信息管理系统清单\n "<<endl;cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;cout<<" 1.成绩的输入"<<endl;cout<<" 2.成绩查询"<<endl;cout<<" 3.成绩排序"<<endl;cout<<" 4.退出"<<endl;cout<<"请选择1-4:"<<endl;cin>>i;while(i<0||i>4){cout<<"系统提示: 您输入错误!"<<endl; //提示输入是否错误cout<<"请重新输入1-4: "<<endl;cin>>i;}return i;}void CreatList(SqList &ST) //创建学生的相关信息{cout<<"输入学生个数"<<endl;cin>>ST.length;cout<<" 学号姓名性别班级成绩1 成绩2 "<<endl;for(int i=0;i<ST.length;i++){cout<<"输入第"<<i+1<<"学生的信息"<<endl;cin>>ST.r[i].num>>ST.r[i].name>>ST.r[i].sex>>ST.r[i].className>>ST.r[i].mar k1>>ST.r[i].mark2;}cout<<"输入完毕"<<endl;}void output(SqList &ST)//输出{cout<<"学生的信息如下"<<endl;cout<<" 学号姓名性别班级成绩1 成绩2 总分"<<endl;for(int i=0;i<ST.length;i++)cout<<setw(6)<<ST.r[i].num<<setw(6)<<ST.r[i].name<<setw(6)<<ST.r[i].se x<<setw(6)<<ST.r[i].className<<setw(8)<<ST.r[i].mark1<<setw(8)<<ST.r[i].mark2 <<setw(8)<<ST.r[i].mark1+ST.r[i].mark2<<" "<<endl;}void Query(SqList &ST) //查询信息{cout<<endl;cout<<" (1)根据学号查询"<<endl;cout<<" (2)根据姓名查询"<<endl; cout<<" (3)根据性别查询"<<endl; cout<<" (4)退出"<<endl;int a,m,n,i,j;int low,high,mid;DataType LI; //使学号变为有序string name;string xb;cin>>m;switch(m){case 1: //折半查找for(i=1;i<ST.length;i++){for(j=i;j>=1;j--)if(ST.r[j].num<ST.r[j-1].num){LI=ST.r[j];ST.r[j]=ST.r[j-1];ST.r[j-1]=LI;}}a=0;cout<<"输入要查找的学号"<<endl;cin>>n;low=0;high=ST.length-1; // 置区间初值while (low<=high){mid=(low+high)/2;if(n==ST.r[mid].num){cout<<ST.r[mid].num<<" "<<ST.r[mid].name<<" "<<ST.r[mid].sex<<" "<<ST.r[mid].className<<" "<<ST.r[mid].mark1<<" "<<ST.r[mid].mark2<<" "<<(ST.r[mid].mark1+ST.r[mid].mark2)<<endl;a=1;break;}else if(n<ST.r[mid].num)high=mid-1; // 继续在前半区间进行查找elselow=mid+1; // 继续在后半区间进行查找}if(!a){cout<<"所查信息不存在!"<<endl;cout<<"请重新输入"<<endl;}break;case 2: //顺序查找{a=0;cout<<"输入要查找的姓名"<<endl;cin>>name;for(i=0;i<ST.length;i++){if(name==ST.r[i].name){cout<<ST.r[i].num<<" "<<ST.r[i].name<<" "<<ST.r[i].sex<<" "<<ST.r[i].className<<" "<<ST.r[i].mark1<<" "<<ST.r[i].mark2<<" "<<ST.r[i].mark1+ST.r[i].mark2<<endl;a=1;}}if(!a){cout<<"所查信息不存在!"<<endl;cout<<"请重新输入"<<endl;}break;}case 3: //顺序查找{a=0;cout<<"输入要查找性别"<<endl;cin>>xb;for(i=0;i<ST.length;i++){if(xb==ST.r[i].sex){cout<<ST.r[i].num<<" "<<ST.r[i].name<<" "<<ST.r[i].sex<<" "<<ST.r[i].className<<" "<<ST.r[i].mark1<<" "<<ST.r[i].mark2<<" "<<ST.r[i].mark1+ST.r[i].mark2<<endl;a=1;}}if(!a){cout<<"所查信息不存在!"<<endl;cout<<"请重新输入"<<endl;}break;}case 4:menu();break;}}void sort(SqList &ST) //排序{int n,i,j;DataType LI; //定义存储学号向量cout<<endl;cout<<" (1)根据学号排序"<<endl;cout<<" (2)根据成绩1排序"<<endl;cout<<" (3)根据成绩2排序"<<endl;cout<<" (4)根据总成绩排序"<<endl;cout<<" (5)退出"<<endl;cin>>n;switch(n){case 1: //按学号排序，使用插入排序for(i=1;i<ST.length;i++)for(j=i;j>=1;j--)if(ST.r[j].num<ST.r[j-1].num){LI=ST.r[j];ST.r[j]=ST.r[j-1];ST.r[j-1]=LI;}output(ST);cout<<"排序完毕"<<endl;break;case 2: //按成绩1排序,用选择排序for(i=0; i<ST.length;i++){for (j=i+1;j<ST.length;j++){if(ST.r[i].mark1>ST.r[j].mark1){LI=ST.r[j];ST.r[j]=ST.r[i];ST.r[i]=LI;}}}output(ST);cout<<"排序完毕"<<endl;break;case 3: // 根据成绩2排序,使用选择法排for(i=0; i<ST.length;i++){for (j=i+1;j<ST.length;j++){if(ST.r[i].mark2>ST.r[j].mark2){LI=ST.r[j];ST.r[j]=ST.r[i];ST.r[i]=LI;}}output(ST);cout<<"排序完毕"<<endl;break;case 4: //根据总成绩排序,使用选择法排序for(i=0; i<ST.length;i++){for (j=i+1;j<ST.length;j++){if(ST.r[i].sum>ST.r[j].sum){LI=ST.r[j];ST.r[j]=ST.r[i];ST.r[i]=LI;}}}output(ST);cout<<"排序完毕"<<endl;break;case 5: //退出menu();break;}}}#include"查找排序.h"void main(){SqList ST;while(1){switch(menu()){case 1:cout<<endl;cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;cout<<" 1.成绩的输入"<<endl;cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;CreatList(ST);break;case 2:cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;cout<<" 2.成绩的查询"<<endl;cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;Query(ST);break;case 3:cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;cout<<" 3.成绩的排序"<<endl;cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;sort(ST);break;case 4:cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;cout<<" 4.退出"<<endl;cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;exit(0);break;}}}四、运行结果图表1图表2图表3图表 4图表 5图表 6图表7图表8五、心得体会整个程序前前后后整整用了一个星期，每天只要有空闲时间就在翻书本，画流程图，写代码，反反复复一点一点。
数据结构之排序算法
数据结构之排序算法排序算法1.冒泡排序1.算法原理：通过相邻元素的比较和交换，将较大的元素逐步向右侧移动。
2.算法步骤：1.从第一个元素开始，依次比较相邻的两个元素。
2.如果前一个元素大于后一个元素，则交换它们的位置。
3.继续向右侧比较并交换，直到最大的元素被移动到了最右侧。
4.重复上述步骤，直到所有的元素都排序完成。
3.算法复杂度：- 最好情况时间复杂度：O(n)- 最坏情况时间复杂度：O(n^2)- 平均情况时间复杂度：O(n^2)2.插入排序1.算法原理：将待排序的元素插入到已排序序列的合适位置，保持已排序序列始终有序。
2.算法步骤：1.从第二个元素开始，将其与前面的元素依次比较。
2.如果比前面的元素小，则将其插入到前面元素的位置上。
3.继续向前比较并插入，直到找到合适的位置。
4.重复上述步骤，直到所有的元素都排序完成。
3.算法复杂度：- 最好情况时间复杂度：O(n)- 最坏情况时间复杂度：O(n^2)- 平均情况时间复杂度：O(n^2)3.选择排序1.算法原理：每次从待排序的元素中选出最小（或最大）的一个元素，依次放到已排序序列的末尾。
2.算法步骤：1.找到待排序序列中最小（或最大）的元素。
2.将最小（或最大）元素与待排序序列的第一个元素交换位置。
3.缩小待排序序列的范围，重复上述步骤。
4.重复步骤1~3，直到所有的元素都排序完成。
3.算法复杂度：- 最好情况时间复杂度：O(n^2)- 最坏情况时间复杂度：O(n^2)- 平均情况时间复杂度：O(n^2)4.快速排序1.算法原理：通过一趟排序将待排序序列分割成独立的两部分，其中一部分的所有元素均比另一部分小，然后对这两部分分别进行快速排序。
2.算法步骤：1.在待排序序列中选择一个基准元素。
2.根据基准元素将待排序序列分割成两部分，使左边部分的元素都小于等于基准元素，右边部分的元素都大于等于基准元素。
3.递归地对左右两部分进行快速排序。
4.重复步骤1~3，直到所有的元素都排序完成。
数据结构实验七-二分排序
1
void main() {
rec A; int j,n,i; printf("\n\n 输入初始数据（每个数据一空格隔开，-1结束）："); n=0; scanf("%d", &j); while(j!=-1) {
n++; A[n]=j; scanf("%d",&j); } printf("插入排序\n\n排序前\n\n"); for (i=1;i<=n;i++) printf("%d ", A[i]); InsertSort1(A,n); printf("\n\n排序后\n\n"); for (i=1;i<=n;i++) printf("%d ", A[i]); }
2
数据结构实验报告七
班级：
姓名： 吴前斌
学号：
课程名称
数据结构
实验项目 排序
实验项目类型 验演综设 证示合计
指导掌握二分排序的基本概念，掌握二分排序的基本思想和算法实现。
二、实验内容 设计一个算法用二分查找实现插入排序的“寻找插入位置”操作。
三、实验要求 二分查找：在有序表中进行，先确定表的中点位置，再通过比较确定下一步查找哪个半区。
四、实验过程及结果：
# include "stdio.h" # define Max 20 typedef int elemtype; typedef elemtype rec[Max];
void InsertSort1(rec A,int n) {
int i,j,low,high,mid,now; for(i=2; i<=n; i++) {
数据结构实验：排序
排序实验：常用排序方法实现
实验目的：
1、熟悉常用的内部排序方法：插入排序、选择排序、交换
排序、基数排序和归并排序；
2、通过实验，掌握排序的思路和方法，并能分析常用的排序
方法的时间复杂度和稳定性。
实验要求：
1、在vc++或tc环境下实现基本功能；
2、先完成基本功能，基本功能为必做内容，有多余时间的同
学可以做选做的内容；
3、独自完成实验操作，并给出相关的数据；
4、每次实验后，撰写实验报告，并在下星期一由学习委员收
集并按学号整理好后，交任课教师。
实验内容及步骤：
必做题：
1、从键盘任意输入一组数据，对该组数据进行希尔排序，
并输出每一趟的排序结果；
2、从键盘任意输入一组数据，对该组数据进行快速排序，
并输出每一趟的排序结果；
3、从键盘任意输入一组数据，对该组数据进行选择排序，
并输出每一趟的排序结果；
选做题：1、从键盘任意输入一组数据，对该组数据进行堆排
序，并输出每一趟的排序结果；
2、从键盘任意输入一组数据，对该组数据进行归并排序，
并输出每一趟的排序结果；
3、从键盘任意输入一组数据，对该组数据进行基数排序，并输出每一趟的排序结果；。
数据结构实验报告——排序
2008级数据结构实验报告实验名称：实验四排序学生姓名：班级：班内序号：学号：日期：2009年12月6日1．实验要求a. 实验目的通过实现下述实验内容，学习、实现、对比各种排序算法，掌握各种排序算法的优劣，以及各种算法使用的情况。
b. 实验内容使用简单数组实现下面各种排序算法，并进行比较。
排序算法：1、插入排序2、希尔排序3、冒泡排序4、快速排序5、简单选择排序6、堆排序（选作）7、归并排序（选作）8、基数排序（选作）9、其他2. 程序分析2.1 存储结构存储结构:顺序存储结构示意图如下:2.2 关键算法分析核心算法思想：1.利用教材讲述的基本算法思想，实现七种排序算法，统计其运行相关数据。
2.将七种排序函数入口地址作为函数指针数组，实现快速调用和统计。
使得程序代码可读性增、结构更加优化。
关键算法思想描述和实现：关键算法1：实现七种算法的基本排序功能。
1、插入排序：依次将待排序的序列中的每一个记录插入到先前排序好的序列中，直到全部记录排序完毕。
2、希尔排序：先将整个序列分割成若干个子列，分别在各个子列中运用直接插入排序，待整个序列基本有序时，再对全体记录进行一次直接插入排序。
3、冒泡排序：两两比较相邻记录的关键码，如果反序则交换，直到没有反序记录为止。
4、快速排序：首先选择一个基准，将记录分割为两部分，左支小于或等于基准，右支则大于基准，然后对两部分重复上述过程，直至整个序列排序完成。
5、选择排序：从待排序的记录序列中选择关键码最小（或最大）的记录并将它与序列中的第一个记录交换位置；然后从不包括第一个位置上的记录序列中选择关键码最小（或最大）的记录并将它与序列中的第二个记录交换位置；如此重复，直到序列中只剩下一个记录为止。
6、堆排序：通过建立大根堆或者小根堆，取出根节点，反复调整堆使之保持大根堆或者小根堆，直至最后序列有序。
7、归并排序：将若干个有序序列两两归并，直至所有待排序的记录都在一个有序序列为止。
数据结构排序实验报告
引言概述：数据结构排序实验是计算机科学与技术专业中一项重要的实践课程。
通过实验，可以深入理解和掌握不同排序算法的原理、特点和性能表现。
本文将针对数据结构排序实验进行详细的阐述和总结，包括实验目的、实验内容、实验结果分析和总结。
一、实验目的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、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
k=i; /*假设最小数的位置*/
for(j=i+1;j<=n;j++){ /*找出真正最小数的位置*/
if(b[j].score<b[k].score) k=j;
}
if(k!=i) /*如果k不是假定位置，则交换数据元素，使k位置的元素为最小*/
{
temp=b[k];
b[k]=b[i];
b[i]=temp;
_lpMem++;
}
}
int main(){
int n=6;
int i;
struct student *p;
struct student a[7] ;
struct student b[7] ;
struct student c[7] ;
InPutStudent(a,n)
memcpy(b,a,sizeof(structstudent)*7);
memcpy(c,a,sizeof(structstudent)*7);
p=a+1;
ShowAuthor();
insertsort(a,n);
bubblesort(b,n);
selectsort(c,n);
system("PAUSE");
return 0;
}
设置计数器：
五，实验结果分析或总结
本次实验要求做修改的部分需要较多的思考，要认真分析一下算法。
const char lpszMyName[]="pangcaiping";
const char lpszFarmat1[]="编译时间:%s\n编译时间:%s\n学号:%s\n姓名:%s\n";
int ShowAuthor()
{
printf(lpszFarmat1,__DATE__,__TIME__,lpszMyStudentID,lpszMyName);
}
Show(b,n,"InsertSort");
return ;
}
void bubblesort(struct student b[],int n) /*冒泡排序*/
{ int i,j,flag;
for(i=1;i<n;i++)
{
flag=TRUE; /*每趟比较前设置flag的值为TRUE,假定该序列已经有序*/
{
b[0]=b[i]; /*把当前要插入的元素b[i]设置为监视哨*/
j=i-1; /*从j=i-1开始往前搜索*/
while(b[0].score>b[j].score) /*确定当前要插入元素b[i]的插入位置*/
{
b[j+1]=b[j];
j--;
}
b[j+1]=b[0];/*找到位置后插入第i个记录*/
for(j=1;j<=n-i;j++)
if(b[j+1].score>b[j].score)
{
flag=FALSE; /*如果有逆序的则表示序列还没有排完，可继续排*/
b[0]=b[j];
b[j]=b[j+1];
b[j+1]=b[0];
}
if(flag==TRUE) /*若flag为TRUE则表示序列已经有序可以结束排序过程*/
#define TRUE 1
#define FALSE 0
#include<stdio.h>
#include<stdlib.h>
#define TRUE 1
#define FALSE 0
struct student
{ char name[8];
int score;
};
const char lpszMyStudentID[]="1200710110";
break;
}
Show(b,n,"BubbleSort");
return ;
}
void selectsort(struct student b[],int n)
{
int i,j,k;
struct student temp;
for(i=1;i<n;i++) /*共进行n-1趟排序，每趟选出一个最小的元素*/
桂林电子科技大学
数学与计算科学学院实验报告
实验室：06303 实验日期：2014年 6月28日
院（系）
数学与计算科学学院
Hale Waihona Puke 学号1200730姓名
成绩
课程
名称
数据结构实验
实验项目
名称
排序
一 ，实验目的
（1）掌握在数组上进行各种排序的方法和算法。
（2）理解各种方法的特点，并能加以灵活应用。
（3）加深对排序的理解，逐步培养解决实际问题的编程能力。
}
}
Show(b,n,"SelectSort");
return ;
}
int InPutStudent(struct student *_lpMem,int _n)
{
int i;
_lpMem++;
for(i=1;i<_n;i++)
{
printf("[%d]:",i);
scanf("%s,%d",_lpMem->name,_lpMem);
printf("[%d]:%s,%d\n",i+1,p->name,p->score);
p++;
}
return 0;
}
void insertsort(struct student b[],int n)
{
int i ,j;
for(i=2;i<=n;i++) /*将全部记录存放在b[1]至b[n]中。*/
二，实验原理
根据各个排序的算法对无序的数据进行排序。
三，实验内容
对一组数据进行直接插入排序、冒泡排序及直接选择排序。
四，实验过程原始记录（数据，图表，计算等）
调试结果：
修改源程序，从键盘输入n个学生的考试成绩表，按分数高低次序，打印出每个学生的信息。
#include<stdio.h>
#include<stdlib.h>
return 0;
}
int Show(struct student*_lpStudent,int _n,const char *_strMethod)
{
struct student *p=_lpStudent+1;
int i;
printf("方法：%s,结果为:\n",_strMethod);
for(i=0;i<_n;i++){