实验一 算法的时间复杂度

实验一算法的时间复杂度

一、实验目的与要求

熟悉C/C++语言的集成开发环境；

通过本实验加深对算法分析基础知识的理解。

二、实验内容:

掌握算法分析的基本方法，并结合具体的问题深入认识算法的时间复杂度分析。

三、实验题

定义一个足够大的整型数组，并分别用起泡排序、简单选择排序、快速排序和归并排序对数组中的数据进行排序（按从小到大的顺序排序），记录每种算法的实际耗时，并结合数据结构中的知识对算法的时间复杂度分析进行说明。实验数据分两种情况：

1、数组中的数据随机生成；

2、数组中的数据已经是非递减有序。

四、实验步骤

理解算法思想和问题要求；

编程实现题目要求；

上机输入和调试自己所编的程序；

验证分析实验结果；

整理出实验报告。

五、实验程序

#include

#include

#include

#include "sort.cpp";

#include

using namespace std;

void InsertSort(int r[], int n); //直接顺序排序

void BubbleSort(int r[], int n); //起泡排序

void QuickSort(int r[], int first, int end); //快速排序

void SelectSort(int r[ ], int n); //简单选择排序

int main()

{

time_t tval;

struct tm *now;

tval=time(NULL);

now=localtime(&tval);

const int numv=5000;

int a[numv];

int b[numv];

int c[numv];

int d[numv];

for(int A=0;A

a[A]=1+rand()%numv;

for(int B=0;B

b[B]=1+rand()%numv;

for(int C=0;C

c[C]=1+rand()%numv;

for(int D=0;D

d[D]=1+rand();

cout << "\n直接顺序排序前：" << "\n";

printf("直接顺序排序前时间为：%d:%02d:%02d\n",now->tm_hour,now->tm_min,now->tm_sec); for(int j=1;j

cout<

cout << "\n直接顺序排序结果为：" << "\n";

InsertSort(a,numv);

printf("直接顺序排序后时间为：%d:%02d:%02d\n",now->tm_hour,now->tm_min,now->tm_sec);

cout << "\n起泡排序前：" << "\n";

printf("起泡排序前时间为：%d:%02d:%02d\n",now->tm_hour,now->tm_min,now->tm_sec);

for(int k=0;k

cout<

cout << "\n起泡排序结果为：" << "\n";

BubbleSort(b, numv);

printf("起泡排序后时间为：%d:%02d:%02d\n",now->tm_hour,now->tm_min,now->tm_sec);

cout << "\n快速排序前：" << "\n";

printf("快速排序前时间为：%d:%02d:%02d\n",now->tm_hour,now->tm_min,now->tm_sec); for(j=0;j

cout<

cout << "\n快速排序结果为：" << "\n";

QuickSort(c,0,numv-1);

for(int i=0;i

cout<

cout<<"\n";

printf("快速排序后时间为：n%d:%02d:%02d\n",now->tm_hour,now->tm_min,now->tm_sec);

cout << "\n简单选择排序前：" << "\n";

printf("简单选择排序前时间为：%d:%02d:%02d\n",now->tm_hour,now->tm_min,now->tm_sec); for(j=0;j

cout<

cout << "\n简单选择排序结果为：" << "\n";

SelectSort(d,numv);

printf("简单选择排序后时间为：%d:%02d:%02d\n",now->tm_hour,now->tm_min,now->tm_sec); return 0;

}

#include

using namespace std;

//直接顺序排序

void InsertSort(int r[], int n)

{

for (int i=2; i

{

r[0]=r[i]; //设置哨兵

for (int j=i-1; r[0]

r[j+1]=r[j]; //记录后移

r[j+1]=r[0];

}

for(int k=1;k

cout<

cout<<"\n";

}

//起泡排序

void BubbleSort(int r[], int n)

{

int temp;

int exchange;

int bound;

exchange=n-1; //第一趟起泡排序的范围是r[0]到r[n-1] while (exchange) //仅当上一趟排序有记录交换才进行本趟排序{

bound=exchange;

exchange=0;

for (int j=0; j

if (r[j]>r[j+1])

{

temp=r[j];

r[j]=r[j+1];

r[j+1]=temp;

exchange=j; //记录每一次发生记录交换的位置}

}

for(int i=0;i

cout<

cout<<"\n";

}

//快速排序一次划分

int Partition(int r[], int first, int end)

{

int i=first; //初始化

int j=end;

int temp;

while (i

{

while (i

j--; //右侧扫描

if (i

{

temp=r[i]; //将较小记录交换到前面

r[i]=r[j];

r[j]=temp;

i++;

}

while (i

i++; //左侧扫描

if (i

{

temp=r[j];

r[j]=r[i];

r[i]=temp; //将较大记录交换到后面

j--;

}

}

return i; //i为轴值记录的最终位置

}

//快速排序

void QuickSort(int r[], int first, int end)

{

if (first

{ //递归结束

int pivot=Partition(r, first, end); //一次划分

QuickSort(r, first, pivot-1);//递归地对左侧子序列进行快速排序

QuickSort(r, pivot+1, end); //递归地对右侧子序列进行快速排序}

}

//简单选择排序

void SelectSort(int r[ ], int n)

{

int i;

int j;

int index;

int temp;

for (i=0; i

index=i;

for (j=i+1; j

if (r[j]

index=j;

if (index!=i)

{

temp=r[i];

r[i]=r[index];

r[index]=temp;

}

}

for(i=0;i

cout<

cout<<"\n";

}

六、实验结果

七、实验分析

直接顺序排序

算法：

经过i-1遍处理后，L[1..i-1]己排好序。第i遍处理仅将L[i]插入L[1..i-1]的适当位置，使得L[1..i]又是排好序的序列。要达到这个目的，我们可以用顺序比较的方法。首先比较L[i]和L[i-1]，如果L[i-1]<=L[i]，则L[1..i]已排好序，第i遍处理就结束了;否则交换L[i]与L[i-1]的位置，继续比较L[i-1]和L[i-2]，直到找到某一个位置j(1≤j≤i-1)，使得L[j] ≤L[j+1]时为止优点:移动元素次数少，只需要一个辅助空间时间复杂度n*n 当待排序记录的数量n很小时，这是一种很好的排序方法。但是n很大时，则不适合

冒泡排序

算法：

核心思想是扫描数据清单，寻找出现乱序的两个相邻的项目。当找到这两个项目后交换项目的位置然后继续扫描。重复上面的操作直到所有的项目都按顺序排好时间复杂度n*n (n-1)*n/2。

快速排序

算法：

快速排序是对起泡排序的一种改进，通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分继续进行排序，以达到整个序列有序. 交换顺序表L中子表L.r[low..high]的记录，使枢轴记录到位，并返回其所在位置，此时在它之前(后)的记录均不大(小)于它时间复杂度为 n*logn,其平均性能最好，若初始记录序列按关键字有序或基本有序，快速排序将锐化为起泡排序

简单选择排序

算法：

首先找到数据清单中的最小的数据，然后将这个数据同第一个数据交换位置；接下来找第二小的数据，再将其同第二个数据交换位置，以此类推。所需移动的操作次数最少为0,,最大为3(n-1) 然而无论记录的初始排列如何，需要比较的次数相同n(n-1)/2 复杂度为n*n