实验四排序实验报告
排序的实验报告范文
排序的实验报告范文数据结构实验报告实验名称：实验四排序学生姓名：班级：班内序号：学号：日期：2022年12月21日实验要求题目2使用链表实现下面各种排序算法，并进行比较。
排序算法：1、插入排序2、冒泡排序3、快速排序4、简单选择排序5、其他要求：1、测试数据分成三类：正序、逆序、随机数据。
2、对于这三类数据，比较上述排序算法中关键字的比较次数和移动次数（其中关键字交换计为3次移动）。
3、对于这三类数据，比较上述排序算法中不同算法的执行时间，精确到微秒（选作）。
4、对2和3的结果进行分析，验证上述各种算法的时间复杂度。
编写测试main()函数测试线性表的正确性。
2、程序分析2.1存储结构说明：本程序排序序列的存储由链表来完成。
其存储结构如下图所示。
(1)单链表存储结构：结点地址：1000HA[2]结点地址：1000H1080H……头指针地址：1020HA[0]头指针地址：1020H10C0H……地址：1080HA[3]地址：1080HNULL……地址：10C0HA[1]地址：10C0H1000H……（2）结点结构tructNode{intdata;Node某ne某t;};示意图：intdataNode某ne某tintdataNode某ne某t2.2关键算法分析一：关键算法(一)直接插入排序voidLinkSort::InertSort()直接插入排序是插入排序中最简单的排序方法，其基本思想是：依次将待排序序列中的每一个记录插入到一个已排好的序列中，直到全部记录都排好序。
（1）算法自然语言1.将整个待排序的记录序列划分成有序区和无序区，初始时有序区为待排序记录序列中的第一个记录，无序区包括所有剩余待排序的记录；2.将无须去的第一个记录插入到有序区的合适位置中，从而使无序区减少一个记录，有序区增加一个记录；3.重复执行2，直到无序区中没有记录为止。
（2）源代码voidLinkSort::InertSort()//从第二个元素开始，寻找前面那个比它大的{Node某P=front->ne某t;//要插入的节点的前驱while(P->ne某t){Node某S=front;//用来比较的节点的前驱while(1){if(P->ne某t->data<S->ne某t->data)//P的后继比S的后继小则插入{inert(P,S);break;}S=S->ne某t;if(S==P)//若一趟比较结束，且不需要插入{P=P->ne某t;break;}}}}(3)时间和空间复杂度最好情况下，待排序序列为正序，时间复杂度为O（n）。
算法性能实验报告
一、实验目的本次实验旨在通过对比分析几种常用排序算法的性能，深入了解各种算法在不同数据规模和不同数据分布情况下的时间复杂度和空间复杂度，为实际应用中算法的选择提供参考。
二、实验环境- 操作系统：Windows 10- 编程语言：C++- 编译器：Visual Studio 2019- 测试数据：随机生成的正整数序列三、实验内容本次实验主要对比分析了以下几种排序算法：1. 冒泡排序（Bubble Sort）2. 选择排序（Selection Sort）3. 插入排序（Insertion Sort）4. 快速排序（Quick Sort）5. 归并排序（Merge Sort）6. 希尔排序（Shell Sort）四、实验方法1. 对每种排序算法，编写相应的C++代码实现。
2. 生成不同规模（1000、5000、10000、50000、100000）的随机正整数序列作为测试数据。
3. 对每种排序算法，分别测试其时间复杂度和空间复杂度。
4. 对比分析不同算法在不同数据规模和不同数据分布情况下的性能。
五、实验结果与分析1. 时间复杂度（1）冒泡排序、选择排序和插入排序的平均时间复杂度均为O(n^2)，在数据规模较大时性能较差。
（2）快速排序和归并排序的平均时间复杂度均为O(nlogn)，在数据规模较大时性能较好。
（3）希尔排序的平均时间复杂度为O(n^(3/2))，在数据规模较大时性能优于冒泡排序、选择排序和插入排序，但不如快速排序和归并排序。
2. 空间复杂度（1）冒泡排序、选择排序和插入排序的空间复杂度均为O(1)，属于原地排序算法。
（2）快速排序和归并排序的空间复杂度均为O(n)，需要额外的空间来存储临时数组。
（3）希尔排序的空间复杂度也为O(1)，属于原地排序算法。
3. 不同数据分布情况下的性能（1）对于基本有序的数据，快速排序和归并排序的性能会受到影响，此时希尔排序的性能较好。
（2）对于含有大量重复元素的数据，快速排序的性能会受到影响，此时插入排序的性能较好。
数据结构实验报告
姓名：学号：班级：2010年12月15日实验一线性表的应用【实验目的】1、熟练掌握线性表的基本操作在顺序存储和链式存储上的实现。
、；2、以线性表的各种操作（建立、插入、删除、遍历等）的实现为重点；3、掌握线性表的动态分配顺序存储结构的定义和基本操作的实现；4、通过本章实验帮助学生加深对C语言的使用（特别是函数的参数调用、指针类型的应用和链表的建立等各种基本操作）。
【实验内容】约瑟夫问题的实现：n只猴子要选猴王，所有的猴子按1,2，…，n编号围坐一圈，从第一号开始按1,2…，m报数，凡报到m号的猴子退出圈外，如此次循环报数，知道圈内剩下一只猴子时，这个猴子就是猴王。
编写一个程序实现上述过程，n和m由键盘输入。
【实验要求】1、要求用顺序表和链表分别实现约瑟夫问题。
2、独立完成，严禁抄袭。
3、上的实验报告有如下部分组成：①实验名称②实验目的③实验内容：问题描述：数据描述：算法描述：程序清单：测试数据算法：#include <stdio.h>#include <stdlib.h>typedef struct LPeople{int num;struct LPeople *next;}peo;void Joseph(int n,int m) //用循环链表实现{int i,j;peo *p,*q,*head;head=p=q=(peo *)malloc(sizeof(peo));p->num=0;p->next=head;for(i=1;i<n;i++){p=(peo *)malloc(sizeof(peo));p->num=i;q->next=p;p->next=head;}q=p;p=p->next;i=0;j=1;while(i<n){if(j%m==0){q->next=p->next;p=q->next;printf("%4d",j%n);i++;}else{q=p;p=p->next;}j++;}printf("\n");}void main(){int n,m; /*人的个数*/printf("Please Enter n amd m(n>m):\n");scanf("%d%d",&n,&m);Joseph(n,m);}实验二树和图的应用【实验目的】1．熟练掌握数的基本概念、二叉树的基本操作及在链式存储结构上的实现。
数据结构排序实验报告
数据结构排序实验报告数据结构排序实验报告引言：数据结构是计算机科学中的重要概念之一，它涉及到数据的组织、存储和操作方式。
排序是数据结构中的基本操作之一，它可以将一组无序的数据按照特定的规则进行排列，从而方便后续的查找和处理。
本实验旨在通过对不同排序算法的实验比较，探讨它们的性能差异和适用场景。
一、实验目的本实验的主要目的是通过实际操作，深入理解不同排序算法的原理和实现方式，并通过对比它们的性能差异，选取合适的排序算法用于不同场景中。
二、实验环境和工具实验环境：Windows 10 操作系统开发工具：Visual Studio 2019编程语言：C++三、实验过程1. 实验准备在开始实验之前，我们需要先准备一组待排序的数据。
为了保证实验的公正性，我们选择了一组包含10000个随机整数的数据集。
这些数据将被用于对比各种排序算法的性能。
2. 实验步骤我们选择了常见的五种排序算法进行实验比较，分别是冒泡排序、选择排序、插入排序、快速排序和归并排序。
- 冒泡排序：该算法通过不断比较相邻元素的大小，将较大的元素逐渐“冒泡”到数组的末尾。
实现时，我们使用了双重循环来遍历整个数组，并通过交换元素的方式进行排序。
- 选择排序：该算法通过不断选择数组中的最小元素，并将其放置在已排序部分的末尾。
实现时，我们使用了双重循环来遍历整个数组，并通过交换元素的方式进行排序。
- 插入排序：该算法将数组分为已排序和未排序两部分，然后逐个将未排序部分的元素插入到已排序部分的合适位置。
实现时，我们使用了循环和条件判断来找到插入位置，并通过移动元素的方式进行排序。
- 快速排序：该算法通过选取一个基准元素，将数组分为两个子数组，并对子数组进行递归排序。
实现时，我们使用了递归和分治的思想，将数组不断划分为更小的子数组进行排序。
- 归并排序：该算法通过将数组递归地划分为更小的子数组，并将子数组进行合并排序。
实现时，我们使用了递归和分治的思想，将数组不断划分为更小的子数组进行排序，然后再将子数组合并起来。
排序的实验报告册
一、实验目的1. 了解排序算法的基本原理和常用算法。
2. 掌握几种常用排序算法的代码实现。
3. 比较不同排序算法的性能，分析其优缺点。
4. 培养实验操作能力和分析问题能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.73. 开发工具：PyCharm三、实验内容1. 实验一：冒泡排序2. 实验二：选择排序3. 实验三：插入排序4. 实验四：快速排序5. 实验五：归并排序四、实验步骤1. 实验一：冒泡排序（1）编写冒泡排序的Python代码。
（2）对一组随机生成的数据进行排序。
（3）观察排序过程，分析冒泡排序的优缺点。
2. 实验二：选择排序（1）编写选择排序的Python代码。
（2）对一组随机生成的数据进行排序。
（3）观察排序过程，分析选择排序的优缺点。
3. 实验三：插入排序（1）编写插入排序的Python代码。
（2）对一组随机生成的数据进行排序。
（3）观察排序过程，分析插入排序的优缺点。
4. 实验四：快速排序（1）编写快速排序的Python代码。
（2）对一组随机生成的数据进行排序。
（3）观察排序过程，分析快速排序的优缺点。
5. 实验五：归并排序（1）编写归并排序的Python代码。
（2）对一组随机生成的数据进行排序。
（3）观察排序过程，分析归并排序的优缺点。
五、实验结果与分析1. 实验一：冒泡排序（1）代码实现：```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]```（2）排序过程：冒泡排序通过比较相邻两个元素的大小，将较大的元素向后移动，从而实现排序。
（3）优缺点分析：优点：易于理解，实现简单。
缺点：时间复杂度较高，对于大数据量排序效率较低。
数据结构实验报告-排序
本章共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;}。
算法课设实验报告(3篇)
第1篇一、实验背景与目的随着计算机技术的飞速发展，算法在计算机科学中扮演着至关重要的角色。
为了加深对算法设计与分析的理解，提高实际应用能力，本实验课程设计旨在通过实际操作，让学生掌握算法设计与分析的基本方法，学会运用所学知识解决实际问题。
二、实验内容与步骤本次实验共分为三个部分，分别为排序算法、贪心算法和动态规划算法的设计与实现。
1. 排序算法（1）实验目的：熟悉常见的排序算法，理解其原理，比较其优缺点，并实现至少三种排序算法。
（2）实验内容：- 实现冒泡排序、快速排序和归并排序三种算法。
- 对每种算法进行时间复杂度和空间复杂度的分析。
- 编写测试程序，对算法进行性能测试，比较不同算法的优劣。
（3）实验步骤：- 分析冒泡排序、快速排序和归并排序的原理。
- 编写三种排序算法的代码。
- 分析代码的时间复杂度和空间复杂度。
- 编写测试程序，生成随机测试数据，测试三种算法的性能。
- 比较三种算法的运行时间和内存占用。
2. 贪心算法（1）实验目的：理解贪心算法的基本思想，掌握贪心算法的解题步骤，并实现一个贪心算法问题。
（2）实验内容：- 实现一个贪心算法问题，如活动选择问题。
- 分析贪心算法的正确性，并证明其最优性。
（3）实验步骤：- 分析活动选择问题的贪心策略。
- 编写贪心算法的代码。
- 分析贪心算法的正确性，并证明其最优性。
- 编写测试程序，验证贪心算法的正确性。
3. 动态规划算法（1）实验目的：理解动态规划算法的基本思想，掌握动态规划算法的解题步骤，并实现一个动态规划算法问题。
（2）实验内容：- 实现一个动态规划算法问题，如背包问题。
- 分析动态规划算法的正确性，并证明其最优性。
（3）实验步骤：- 分析背包问题的动态规划策略。
- 编写动态规划算法的代码。
- 分析动态规划算法的正确性，并证明其最优性。
- 编写测试程序，验证动态规划算法的正确性。
三、实验结果与分析1. 排序算法实验结果：- 冒泡排序：时间复杂度O(n^2)，空间复杂度O(1)。
数据结构实验报告-排序
数据结构实验报告-排序一、实验目的本实验旨在探究不同的排序算法在处理大数据量时的效率和性能表现，并对比它们的优缺点。
二、实验内容本次实验共选择了三种常见的排序算法：冒泡排序、快速排序和归并排序。
三个算法将在同一组随机生成的数据集上进行排序，并记录其性能指标，包括排序时间和所占用的内存空间。
三、实验步骤1. 数据的生成在实验开始前，首先生成一组随机数据作为排序的输入。
定义一个具有大数据量的数组，并随机生成一组在指定范围内的整数，用于后续排序算法的比较。
2. 冒泡排序冒泡排序是一种简单直观的排序算法。
其基本思想是从待排序的数据序列中逐个比较相邻元素的大小，并依次交换，从而将最大（或最小）的元素冒泡到序列的末尾。
重复该过程直到所有数据排序完成。
3. 快速排序快速排序是一种分治策略的排序算法，效率较高。
它将待排序的序列划分成两个子序列，其中一个子序列的所有元素都小于等于另一个子序列的所有元素。
然后对两个子序列分别递归地进行快速排序。
4. 归并排序归并排序是一种稳定的排序算法，使用分治策略将序列拆分成较小的子序列，然后递归地对子序列进行排序，最后再将子序列合并成有序的输出序列。
归并排序相对于其他算法的优势在于其稳定性和对大数据量的高效处理。
四、实验结果经过多次实验，我们得到了以下结果：1. 冒泡排序在数据量较小时，冒泡排序表现良好，但随着数据规模的增大，其性能明显下降。
排序时间随数据量的增长呈平方级别增加。
2. 快速排序相比冒泡排序，快速排序在大数据量下的表现更佳。
它的排序时间线性增长，且具有较低的内存占用。
3. 归并排序归并排序在各种数据规模下都有较好的表现。
它的排序时间与数据量呈对数级别增长，且对内存的使用相对较高。
五、实验分析根据实验结果，我们可以得出以下结论：1. 冒泡排序适用于数据较小的排序任务，但面对大数据量时表现较差，不推荐用于处理大规模数据。
2. 快速排序是一种高效的排序算法，适用于各种数据规模。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构实验报告实验名称：实验四排序学生姓名：班级：班内序号：学号：日期：2012年12月21日1、实验要求题目2使用链表实现下面各种排序算法，并进行比较。
排序算法：1、插入排序2、冒泡排序3、快速排序4、简单选择排序5、其他要求：1、测试数据分成三类：正序、逆序、随机数据。
2、对于这三类数据，比较上述排序算法中关键字的比较次数和移动次数（其中关键字交换计为3次移动）。
3、对于这三类数据，比较上述排序算法中不同算法的执行时间，精确到微秒（选作）。
4、对2和3的结果进行分析，验证上述各种算法的时间复杂度。
编写测试main()函数测试线性表的正确性。
2、程序分析2.1存储结构说明：本程序排序序列的存储由链表来完成。
其存储结构如下图所示。
(1)单链表存储结构：（2）结点结构struct Node{int data;Node * next;};示意图：2.2关键算法分析一：关键算法(一)直接插入排序void LinkSort::InsertSort()直接插入排序是插入排序中最简单的排序方法，其基本思想是：依次将待排序序列中的每一个记录插入到一个已排好的序列中，直到全部记录都排好序。
（1）算法自然语言1.将整个待排序的记录序列划分成有序区和无序区，初始时有序区为待排序记录序列中的第一个记录，无序区包括所有剩余待排序的记录；2.将无须去的第一个记录插入到有序区的合适位置中，从而使无序区减少一个记录，有序区增加一个记录；3.重复执行2，直到无序区中没有记录为止。
（2）源代码void LinkSort::InsertSort() //从第二个元素开始，寻找前面那个比它大的{Node * P = front->next; //要插入的节点的前驱while(P->next){Node * S = front; //用来比较的节点的前驱while(1){CompareCount++;if( P->next->data < S->next->data ) // P的后继比S的后继小则插入{insert(P, S);break;}S = S->next;if(S==P) //若一趟比较结束，且不需要插入{P = P->next;break; }}}}(3)时间和空间复杂度最好情况下，待排序序列为正序，时间复杂度为O（n）。
最坏情况下，待排序序列为逆序，时间复杂度为O（n2）。
直接插入排序只需要一个记录的辅助空间，用来作为待插入记录的暂存单元和查找记录的插入位置过程中的“哨兵”。
直接插入排序是一种稳定的排序方法。
直接插入排序算法简单容易实现，当序列中的记录基本有序或带排序记录较少时，他是最佳的排序方法。
但当待排序的记录个数较多时，大量的比较和移动操作使直接插入排序算法的效率减低。
插入到合适位置（二）冒泡排序void LinkSort::BubbleSort()冒泡排序是交换排序中最简单的排序方法，其基本思想是：两两比较相邻记录的关键码，如果反序则交换，直到没有反序的记录为止。
本程序采用改进的冒泡程序。
（1）算法自然语言1.将整个待排序的记录序列划分成有序区和无序区，初始状态有序区为空，无序区包括所有待排序的记录。
2.对无序区从前向后依次将相邻记录的关键码进行比较，若反序则交换，从而使得关键码小的记录向前移，关键码大的记录向后移（像水中的气泡，体积大的先浮上来）。
3.将最后一次交换的位置pos，做为下一趟无序区的末尾。
4.重复执行2和3，直到无序区中没有反序的记录。
* * （2）源代码void LinkSort::BubbleSort(){Node * P = front->next;while(P->next) //第一趟排序并查找无序范围{CompareCount++;if( P->data > P->next->data)swap(P, P->next);P = P->next;}Node * pos = P;P = front->next;while(pos != front->next){Node * bound = pos;pos = front->next;while(P->next != bound){CompareCount++;if( P->data > P->next->data){swap(P, P->next);pos = P->next;}P = P->next;}P = front->next;}}(3)时间和空间复杂度在最好情况下，待排序记录序列为正序，算法只执行了一趟，进行了n-1次关键码的比较，不需要移动记录，时间复杂度为O（n）；在最坏情况下，待排序记录序列为反序，时间复杂度为O（n2），空间复杂度为O(1)。
冒泡排序是一种稳定的排序方法。
反序则交换初始键值序列［50 13 55 97 27 38 49 65］第一趟排序结果［13 50 55 27 38 49 65］97第二趟排序结果［13 50 27 38 49］5565 97第三趟排序结果［13 27 38 49］5055 65 97第四趟排序结果13 27 38 49 50 55 65 97（三）快速排序void LinkSort::Qsort()（1）算法自然语言1.首先选一个轴值（即比较的基准），将待排序记录分割成独立的两部分，左侧记录的关键码均小于或等于轴值，右侧记录的关键码均大于或等于轴值。
2.然后分别对这两部分重复上述过程，直到整个序列有序。
3.整个快速排序的过程递归进行。
（2）源代码void LinkSort::Qsort(){Node * End = front;while(End->next){End = End->next;}Partion(front, End);}void LinkSort::Partion(Node * Start, Node * End){if(Start->next==End || Start==End) //递归返回return ;Node * Mid = Start; //基准值前驱Node * P = Mid->next;while(P!=End && P!=End->next){CompareCount++;if( Mid->next->data > P->next->data ) //元素值小于轴点值，则将该元素插在轴点之前{if( P->next == End ) //若该元素为End，则将其前驱设为EndEnd = P;insert(P, Mid);Mid = Mid->next;}else P = P->next;}Partion(Start, Mid); //递归处理基准值左侧链表Partion(Mid->next, End); //递归处理基准值右侧链表}（3）时间和空间复杂度在最好的情况下，时间复杂度为O（nlog2n）。
在最坏的情况下，时间复杂度为O（n2）。
快速排序是一种不稳定的排序方法。
（四）简单选择排序基本思想为：第i趟排序通过n-i次关键码的比较，在n-i+1（1≤i≤n-1）各记录中选取关键码最小的记录，并和第i个记录交换作为有序序列的第i个记录。
（1）算法自然语言1.将整个记录序列划分为有序区和无序区，初始状态有序区为空，无序区含有待排序的所有记录。
2.在无序区中选取关键码最小的记录，将它与无序区中的第一个记录交换，使得有序区扩展了一个记录，而无序区减少了一个记录。
3.不断重复2，直到无序区之剩下一个记录为止。
（2）源代码void LinkSort::SelectSort(){Node * S = front;while(S->next->next){Node * P = S;Node * Min = P;while(P->next) //查找最小记录的位置{CompareCount++;if(P->next->data < Min->next->data)Min = P;P = P->next;}insert(Min, S);S = S->next;}}（3）时间和空间复杂度简单选择排序最好、最坏和平均的时间复杂度为O（n2）。
简单选择排序是一种不稳定的排序方法。
（五）输出比较结果函数（含计算函数体执行时间代码）（1）算法自然语言1、依次调用直接插入排序、冒泡排序、快速排序、简单选择排序的函数体，进行序列的排序，并输出相应的比较次数、移动次数。
2、获取当前系统时间。
在调用函数之前设定一个调用代码前的时间，在调用函数之后再次设定一个调用代码后的时间，两个时间相减就是代码运行时间。
说明：运用QueryPerformanceFrequency()可获取计时器频率；QueryPerformanceCounter()用于得到高精度计时器的值。
（2）源代码void printResult(LinkSort &a, LinkSort &b, LinkSort &c, LinkSort &d) {_LARGE_INTEGER time_start; //开始时间_LARGE_INTEGER time_over; //结束时间double dqFreq; //计时器频率LARGE_INTEGER f; //计时器频率QueryPerformanceFrequency(&f);dqFreq=(double)f.QuadPart;a.print();double TimeCount;CompareCount = 0; MoveCount = 0; TimeCount = 0;QueryPerformanceCounter(&time_start); //记录起始时间a.InsertSort();QueryPerformanceCounter(&time_over); //记录结束时间TimeCount =((time_over.QuadPart-time_start.QuadPart)/dqFreq)*1000000;cout << "排序结果："; a.print();cout << "1.插入。
比较次数：" << setw(3) << CompareCount << "; 移动次数：" << setw(3) << MoveCount << "; 时间: " << TimeCount <<"us"<< endl;CompareCount = 0; MoveCount = 0; TimeCount = 0;QueryPerformanceCounter(&time_start); //记录起始时间b.BubbleSort();QueryPerformanceCounter(&time_over); //记录结束时间TimeCount =((time_over.QuadPart-time_start.QuadPart)/dqFreq)*1000000;cout << "2.冒泡。