武汉理工数据结构排序算法比较实验报告

学生学号实验课成绩

武汉理工大学

学生实验报告书

实验课程名称数据结构与算法

开课学院计算机科学与技术学院指导教师姓名

学生姓名

学生专业班级计算机类

2017 —2018 学年第一学期

实验课程名称：高级语言程序设计

实验项目名称内部排序算法比较实验成绩

实验者专业班级组别

同组者实验日期年月日第一部分：实验分析与设计（可加页）

一、实验内容描述（问题域描述）

内部排序算法比较。编制一个演示内部排序算法比较的程序。对起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、归并排序算法进行比较。

二、实验基本原理与设计（包括实验方案设计，实验手段的确定，试验步骤等，用硬件逻辑或

者算法描述）

(1)伪随机产生数据：用伪随机产生程序产生一组随机数，再用不同排序算法进行排

序。

(2)简单选择排序：运用简单选择排序法对伪随机产生的数据进行排序。

(3) 起泡排序：运用起泡排序法对伪随机产生的数据进行排序。

(4)直接插入排序：运用直接插入排序法对伪随机产生的数据进行排序。

(5)希尔排序：运用希尔排序法对伪随机产生的数据进行排序。

(6)快速排序：运用快速排序法对伪随机产生的数据进行排序。

(7)归并排序：运用归并排序法对伪随机产生的数据进行排序。

定义抽象数据类型

typedef struct

{

int key;

}ElemType; //关键字

typedef struct

{

ElemType *elem;

int length;

}SqList;//本实验使用线性表的存储结构

三、主要仪器设备及耗材

PC

Dev-C++ 5.11

Sublime Text 3 编辑器

第二部分：实验调试与结果分析（可加页）

一、调试过程（包括调试方法描述、实验数据记录，实验现象记录，实验过程发现的问题等）

二、实验结果及分析（包括结果描述、实验现象分析、影响因素讨论、综合分析和结论等）

实验结果只有在待排序个数数目比较大的时候才能体现更明显的区别。实验运行成功，整体符合预期。

简单选择排序：运用顺序表。时间复杂度O(n2)，空间复杂度O(1)。

起泡排序：时间复杂度O(n2)，空间复杂度O(1)

直接插入排序：时间复杂度O(n2)，空间复杂度O(1)

希尔排序：时间复杂度O(n1.3)，空间复杂度O(1)

快速排序：时间复杂度O(nlog2n)，空间复杂度O(nlog2n)

归并排序：时间复杂度O(nlog2n)，空间复杂度O(n)

三、实验小结、建议及体会

深入学习理解各种排序方法的性能差别：

排序算法的性能评估

稳定性（假设记录 a 和记录 b 都位于待排序的序列中）

（1）稳定：如果 a 本来就在 b 前面，且 a = b，排序之后 a 仍然在 b 前面；

（2）不稳定：如果 a 本来就在 b 前面，且 a = b，排序之后 a 可能出现在 b 后面；

待排序的记录是否全部被放置在内存中

（1）内排序：在整个排序过程中，待排序的所有记录全部被放置在内存中；（文中的所有排序算法都属于内排序）

（2）外排序：由于排序的记录个数太多，不能同时放置在内存，整个排序过程需要在内外存之间多次交换数据才能进行；

时间复杂度：排序算法的时间开销

空间复杂度：排序算法所需的存储空间

算法本身的复杂度。

从平均情况来看，堆排序，归并排序和快速排序算法要胜过希尔排序，并远远超过冒泡，选择

和插入排序的三种简单算法；

从最好情况来看，冒泡和插入排序算法要比其他算法更胜一筹，也就是说如果待排序的序列基本有序，则可以选择这两种排序算法；

从最坏情况来看，堆排序和归并排序要由于快速排序以及其他简单排序；

从空间复杂度来看，除了归并排序和快速排序之外，其余算法对辅助空间的要求一致，都是O(1)；如果排序过程中，对空间复杂度有要求，则不建议选择归并排序和快速排序。

从稳定性来看，改进算法中，只有归并排序是稳定的，而简单排序都是稳定的；

从待排序的记录的个数看，如果待排序的个数 n 越小，则采用简单排序算法比较合适；如果待排序的个数 n 越大，则采用改进排序算法更合适。

四、附件：实验代码

1)#include

2)#include

3)#include

4)#include

5)#include

6)#define LIST_INIT_SIZE 30000

7)int bj1,yd1,n,com,mov;

8)long int A[5],B[5];

9)double t0,t1,t2,t3,t4,t5,C[5];

10)clock_t start_t,end_t;

11)typedef struct

12){

13) int key;

14)}ElemType;

15)typedef struct

16){

17) ElemType *elem;

18) int length;

19)}SqList;

20)void addlist(SqList &L)

21){

22) int i;

23)a: printf("请输入你要输入的个数:");

24) scanf("%d",&n);

25) if(n>20000)

26) {

27) printf("超出范围重新输入!!!\n");

28) goto a;

29) }

30) L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));

31) if(!L.elem)exit(0);

32) L.length=0;

33) for(i=1;i

34) {

35)b: L.elem[i].key=rand();

36) if(L.elem[i].key>20000)goto b;

37) ++L.length;

38) }

39)}

40)void SelectSort(SqList &L) //简单选择排序

41){

42) start_t=clock();

43) int i,j,k,com=0,mov=0;

44) for(i=1;i

45) {

46) k=i;

47) for(j=i+1;j

48) {

49) com++;

50) if(L.elem[j].key

51) }

52) if(i!=k)

53) {

54) L.elem[0].key=L.elem[i].key;

55) L.elem[i].key=L.elem[k].key;

56) L.elem[k].key=L.elem[0].key;

57) mov+=3;

58) }

59) }

60) end_t=clock();

61) printf("比较次数为 %d移动次数为 %d\n",com,mov);

62) t0=(double)(end_t-start_t)/CLK_TCK;

63) printf("排序用时为 %f\n",t0);

64) A[0]=com;

65) B[0]=mov;

66) C[0]=t0;

67)}

68)void bubblesort(SqList &L) //起泡排序

69){

70) start_t=clock();

71) int i=1,j,com=0,mov=0;

72) while(i

73) {

74) for(j=1;j

75) {

76) com++;

77) if(L.elem[j].key>L.elem[j+1].key)

78) {

79) L.elem[0].key=L.elem[j].key;

80) L.elem[j].key=L.elem[j+1].key;

81) L.elem[j+1].key=L.elem[0].key;

82) mov+=3;

83) }

84) }

85) i++;

86) }

87) end_t=clock();

88) printf("比较次数为 %d移动次数为 %d\n",com,mov);

89) t1=(double)(end_t-start_t)/CLK_TCK;

90) printf("排序用时为 %f\n",t1);

91) A[1]=com;

92) B[1]=mov;

93) C[1]=t1;

94)}

95)void InsertSort(SqList &L) //直接插入排序

96){

97) start_t=clock();

98) int i,j,com=0,mov=0;

99) for(i=2;i<=L.length;i++)

100) {

101) if(L.elem[i].key

102) {

103) L.elem[0].key=L.elem[i].key;

104) mov++;

105) j=i-1;

106) com++;

107) while(L.elem[0].key

108) {

109) L.elem[j+1].key=L.elem[j].key;

110) j--;

111) mov++;

112) com++;

113) }

114) L.elem[j+1].key=L.elem[0].key;

115) mov++;

116) }

117) }

118) end_t=clock();

119) printf("比较次数为 %d移动次数为 %d\n",com,mov); 120) t2=(double)(end_t-start_t)/CLK_TCK;

121) printf("排序用时为 %f\n",t2);

122) A[2]=com;

123) B[2]=mov;

124) C[2]=t2;

125)}

126)void xier(SqList &L) //希尔排序

127){

128) start_t=clock();

129) int i,d=L.length/2,j,w=0,k,com=0,mov=0;

130) while(w

131) {

132) w=1;

133) for(i=w;i

134) {

135) k=i;

136) for(j=i+d;j

137) {

138) if(L.elem[i].key>L.elem[j].key)

139) {

140) k=j;

141) com++;

142) }

143) }

144) if(i!=k)

145) {

146) L.elem[0].key=L.elem[i].key;

147) L.elem[i].key=L.elem[k].key;

148) L.elem[k].key=L.elem[0].key;

149) mov+=3;

150) }

151) w++;

152) }

153) d=d/2;

154) w=1;

155) }

156) end_t=clock();

157) printf("比较次数为 %d移动次数为 %d\n",com,mov); 158) t3=(double)(end_t-start_t)/CLK_TCK;

159) printf("排序用时为 %f\n",t3);

160) A[3]=com;

161) B[3]=mov;

162) C[3]=t3;

163)}

164)void BeforeSort()

165){

166) yd1=0,bj1=0;

167)}

168)void display(int m,int n)

169){

170) printf("比较次数为 %d移动次数为 %d\n",m,n); 171)}

172)int Partition(SqList L,int low,int high) //快速排序173){

174) int pivotkey;

175) L.elem[0]=L.elem[low];

176) yd1++;

177) pivotkey=L.elem[low].key;

178) while (low

179) {

180) yd1++;

181) while(low=pivotkey)

182) {

183)--high;

184) L.elem[low]=L.elem[high];

185) bj1++;

186) yd1++;

187)}

188) while (low

189) {

190)++low;

191) L.elem[high]=L.elem[low];

192) bj1++;

193) yd1++;

194)}

195) }

196) L.elem[low]=L.elem[0];

197) yd1++;

198) return low;

199)}

200)void QSort(SqList &L,int low,int high)

201){

202) int pivotloc;

203) if(low

204) {

205) pivotloc=Partition(L,low,high);

206) QSort(L,low,pivotloc-1);

207) QSort(L,pivotloc+1,high);

208) }

209)}

210)void QuickSort(SqList &L)

211){

212) start_t=clock();

213) BeforeSort();

214) QSort(L,1,L.length);

215) display(bj1,yd1);

216) end_t=clock();

217) t4=(double)(end_t-start_t)/CLK_TCK;

218) printf("排序用时为 %f\n",t4);

219) A[4]=bj1;

220) B[4]=yd1;

221) C[4]=t4;

222)}

223)void Merge(ElemType R[],ElemType R1[],int low,int m,int high) //归并排序

224){

225) int i=low, j=m+1, k=low;

226) while(i<=m&&j<=high)

227) {

228) if(R[i].key<=R[j].key)

229) {

230) bj1++;

231) R1[k]=R[i];

232) yd1++;

233) i++;

234) k++;

235) }

236) else

237) {

238) bj1++;

239) R1[k]=R[j];

240) yd1++;

241) j++;

242) k++;

243) }

244) }

245) while(i<=m)

246) {

247) R1[k]=R[i];

248) yd1++;

249) i++;

250) k++;

251) }

252) while(j<=high)

253) {

254) R1[k]=R[j];

255) yd1++;

256) j++;

257) k++;

258) }

259)}

260)void MergePass(ElemType R[],ElemType R1[],int length, int n) 261){

262) int i=0,j;

263) while(i+2*length-1

264) {

265) Merge(R,R1,i,i+length-1,i+2*length-1);

266) i=i+2*length;

267) }

268) if(i+length-1

269) Merge(R,R1,i,i+length-1,n-1);

270) else

271) for(j=i;j

272) R1[j]=R[j];

273)}

274)void MSort(ElemType R[],ElemType R1[],int n) 275){

276) int length=1;

277) while (length

278) {

279) MergePass(R,R1,length,n);

280) length=2*length;

281) MergePass(R1,R,length,n);

282) length=2*length;

283) }

284)}

285)void MergeSort(SqList &L)

286){

287) start_t=clock();

288) BeforeSort();

289) MSort(L.elem,L.elem,L.length);

290) display(bj1,yd1);

291) end_t=clock();

292) t5=(double)(end_t-start_t)/CLK_TCK;

293) printf("排序用时为 %f\n",t5);

294) A[5]=bj1;

295) B[5]=yd1;

296) C[5]=t5;

297)}

298)void printf(SqList &L)

299){

300)long int d[6];

301)int i,n;

302)printf("\n**********比较次数*********\n"); 303)printf("\n*******************\n");

304)for(i=0;i<5;i++)

305) d[i]= sqrt (A[i]/A[5]);

306) printf("\n 归并排序： *");

307)printf("\n*******************\n"); 308) printf(" 选择排序： ");

309) for(n=0,i=0;n<=d[i];n++)

310) {

311) printf("*");

312) }

313) printf("\n*******************\n");

314) printf(" 冒泡排序： ");

315) for(n=0,i=1;n<=d[i];n++)

316) {

317) printf("*");

319) printf("\n*******************\n");

320) printf(" 直插排序： ");

321) for(n=0,i=2;n<=d[i];n++)

322) {

323) printf("*");

324) }

325) printf("\n*******************\n");

326) printf(" 希尔排序： ");

327) for(n=0,i=3;n<=d[i];n++)

328) {

329) printf("*");

330) }

331) printf("\n*******************\n");

332) printf(" 快排排序： ");

333) for(n=0,i=4;n<=d[i];n++)

334) {

335) printf("*");

336) }

337) printf("\n*******************\n");

338) printf("\n★★★★★★移动次数★★★★★★\n"); 339) printf("\n*******************\n");

340) double e[6];

341) for(i=0;i<6;i++)

342) e[i]= sqrt (B[i]/B[3]);

343) printf("\n 希尔排序： *");

344) printf("\n*******************\n");

345) printf(" 选择排序： ");

346) for(n=0,i=0;n<=e[i];n++)

347) {

348) printf("*");

349) }

350) printf("\n*******************\n");

351) printf(" 冒泡排序： ");

352) for(n=0,i=1;n<=e[i];n++)

353) {

354) printf("*");

355) }

356) printf("\n*******************\n");

357) printf(" 直插排序： ");

358) for(n=0,i=2;n<=e[i];n++)

359) {

360) printf("*");

361) }

362) printf("\n*******************\n");

363) printf(" 快排排序： ");

364) for(n=0,i=4;n<=e[i];n++)

366) printf("*");

367) }

368) printf("\n*******************\n");

369)printf(" 归并排序： ");

370) for(n=0,i=5;n<=e[i];n++)

371) {

372) printf("*");

373) }

374) printf("\n*******************\n");

375) printf("\n★★★★★★排序用时★★★★★★\n"); 376) printf("\n*******************\n");

377) double f[6];

378) for(i=0;i<6;i++)

379) f[i]= sqrt (C[i]/0.001);

380) printf("\n 希尔排序： *");

381) printf("\n*******************\n");

382) printf(" 选择排序： ");

383) for(n=0,i=0;n<=f[i];n++)

384) {

385) printf("*");

386) }

387) printf("\n*******************\n");

388) printf(" 冒泡排序： ");

389) for(n=0,i=1;n<=f[i];n++)

390) {

391) printf("*");

392) }

393) printf("\n*******************\n");

394) printf(" 直插排序： ");

395) for(n=0,i=2;n<=f[i];n++)

396) {

397) printf("*");

398) }

399) printf("\n*******************\n");

400) printf(" 快排排序： ");

401) for(n=0,i=4;n<=f[i];n++)

402) {

403) printf("*");

404) }

405) printf("\n*******************\n");

406) printf(" 归并排序： ");

407) for(n=0,i=5;n<=f[i];n++)

408) {

409) printf("*");

410) }

411) printf("\n*******************\n");

412)}

413)int main()

414){

415) SqList L;

416) addlist(L);

417) printf("\n选择排序: \n"); 418) SelectSort(L);

419) addlist(L);

420) printf("\n起泡排序: \n"); 421) bubblesort(L);

422) addlist(L);

423) printf("\n直插排序: \n"); 424) InsertSort(L);

425)addlist(L);

426) printf("\n希尔排序: \n"); 427) xier(L);

428) addlist(L);

429) printf("\n快速排续: \n"); 430) QuickSort(L);

431) addlist(L);

432) printf("\n归并排序: \n"); 433) MergeSort(L);

434) printf(L);

435)}