支付数据结构实验实例.docx

支付数据结构实验实例.docx

《支付数据结构实验实例.docx》由会员分享，可在线阅读，更多相关《支付数据结构实验实例.docx（22页珍藏版）》请在冰豆网上搜索。

支付数据结构实验实例

目录

一、实验题目---------------------------------------------------1

二、实验目的---------------------------------------------------1

三、实验内容---------------------------------------------------1

四、实验要求---------------------------------------------------1

五、实验环境---------------------------------------------------1

六、实验过程---------------------------------------------------1

七、实验结果---------------------------------------------------9

一、实验题目

排序算法验证

二、实验目的

1．掌握常用排序方法的基本思想及其实现技术

2．了解各种排序方法的优缺点和适用范围

三、实验内容

实现冒泡排序、直接插入排序、选择排序和快速排序，并比较各种排序算法的运行速度。

四、实验要求

1．采用顺序表存放排序的记录，设关键字类型为典型。

2．设计一个菜单，以菜单方式选择上述排序方法。

3．程序执行时，能按趟输出排序的结果。

4．对每种基本排序方法改进算法，再给出改进算法前后的实验结果：

（1）随机生成10个随机数进行排序的结果；

（2）分别给出升序和降序的随机数排序的结果。

5．对上述四种算法给出结论性意见，说明改进算法后的效果明显或不明显的原因。

五、实验环境

软件需求：

C语言

硬件需求：

微型计算机

六、实验过程

1．实验步骤

（1）理解顺序表排序的基本实验原理；

（2）仔细分析实验内容，给出其算法和流程图；

（3）用C语言实现该算法；

（4）给出测试数据，并分析其结果；

（5）在实验报告册上写出实验过程。

2．算法步骤

（1）文件的类型说明

typedefstruct

{keytypekey;

infotypeotherinfo;

}rectype;

typedefrectypeseqlist[n+1];

（2）主函数调用

voidmain（）生成需要排序的关键字，选择调用各排序的算法；

（3）算法调用

voidinsertsort（）;插入排序算法，输入趟数，按趟输出排序的结果；

voidrubblesort（）;起泡排序算法，输入趟数，按趟输出排序的结果；

voidquicksort（intlow,inthigh）;快速排序算法，调用intpartition（inti,intj）函数对R[low]到R[high]做划分，输入趟数，按趟输出排序的结果；

voidselectsort（）;选择排序算法，输入趟数，按趟输出排序的结果；

（4）返回主函数

3．算法修改

随机生成10个随机数进行升序和降序的随机数排序的程序如下：

#include"stdio.h"

#include"stdlib.h"

1

#definen10

#defineFALSE0

#defineTRUE1

#defineMaxsize100

typedefintkeytype;

typedefcharinfotype;

typedefstruct

{keytypekey;

infotypeotherinfo;

}rectype;

typedefrectypeseqlist[n+1];

typedefrectypetemlist[n+1];

intV[Maxsize][n+1];

intm,num;

inta=1,b=1;

seqlistR;

temlistT;

voidinsertsort（）;

voidrubblesort（）;

voidquicksort（）;

voidquicksort2（）;

voidselectsort（）;

intpartition（inti,intj）;

intpartition2（inti,intj）;

voidmain（）

{seqlists;

temlistu;

inti;

charch1,ch2;

for（i=1;i<=n;i++）s[i].key=rand（）%1000;

for（i=1;i<=n;i++）u[i].key=s[i].key;

printf（"Havegeneratedrandomly10sortnumbers:

\n"）;

for（i=1;i<=n;i++）

printf（"%5d",s[i].key）;

printf（"\n"）;

ch1='y';

while（ch1=='y'||ch1=='Y'）

{printf（"*******Menu*******\n"）;

printf（"Pleaseselectoption:

\n"）;

printf（"1------Updatadata------\n"）;

printf（"2------Insertsort------\n"）;

printf（"3------Rubblesort------\n"）;

printf（"4------Quicksort------\n"）;

printf（"5------Selectsort------\n"）;

printf（"6------Quitsort------\n"）;

2

printf（"Pleaseselectoperatingtype:

"）;

scanf（"\n%c",&ch2）;

switch（ch2）

{case'1':

for（i=1;i<=n;i++）s[i].key=rand（）%1000;

printf（"Haveagaingeneratedrandomly10sortnumbers:

\n"）;

for（i=1;i<=n;i++）

printf（"%5d",s[i].key）;

printf（"\n"）;

for（i=1;i<=n;i++）u[i].key=s[i].key;

break;

case'2':

printf（"Pleaseenternumberoftimesforresult:

"）;

scanf（"%d",&m）;

for（i=1;i<=n;i++）

{R[i].key=s[i].key;

T[i].key=u[i].key;

}

insertsort（）;

break;

case'3':

printf（"Pleaseenternumberoftimesforresult:

"）;

scanf（"%d",&m）;

for（i=1;i<=n;i++）

{R[i].key=s[i].key;

T[i].key=u[i].key;

}

rubblesort（）;

break;

case'4':

printf（"Pleaseenternumberoftimesforresult:

"）;

scanf（"%d",&m）;

for（i=1;i<=n;i++）

{R[i].key=s[i].key;

T[i].key=u[i].key;

}

num=0;

quicksort（1,n）;

quicksort2（1,n）;

break;

case'5':

printf（"Pleaseenternumberoftimesforresult:

"）;

scanf（"%d",&m）;

for（i=1;i<=n;i++）

{R[i].key=s[i].key;

3

T[i].key=u[i].key;

}

selectsort（）;

break;

case'6':

ch1='n';

break;

default:

ch1='n';

}

}

}

voidinsertsort（）

{inti,j,k;

for（i=2;i<=n;i++）

{if（R[i].key

{R[0]=R[i];

j=i-1;

while（R[0].key

{R[j+1]=R[j];

j--;

}

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

}

if（T[i].key>T[i-1].key）

{T[0]=T[i];

j=i-1;

while（T[0].key>T[j].key）

{T[j+1]=T[j];

j--;

}

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

}

if（i-1==m）

{printf（"Theascendingresultis:

%d\n",m）;

for（k=1;k<=n;k++）

printf（"%5d",R[k].key）;

printf（"\n"）;

printf（"Thedescendingresultis:

%d\n",m）;

for（k=1;k<=n;k++）

printf（"%5d",T[k].key）;

printf（"\n"）;

printf（"Continue?

Exittopress0:

\n"）;

scanf（"%d",&m）;

}

4

}

if（m!

=0）

{printf（"Theascendingsortresultis:

\n"）;

for（k=1;k<=n;k++）

printf（"%5d",R[k].key）;

printf（"\n"）;

printf（"Thedescendingsortresultis:

\n"）;

for（k=1;k<=n;k++）

printf（"%5d",T[k].key）;

printf（"\n"）;

}

}

voidrubblesort（）

{inti,j,k;

intexchange,exchange2;

for（i=1;i

{exchange=FALSE;

exchange2=FALSE;

for（j=n-1;j>=i;j--）

{if（R[j+1].key

{R[0]=R[j+1];

R[j+1]=R[j];

R[j]=R[0];

exchange=TRUE;

}

if（T[j+1].key>T[j].key）

{T[0]=T[j+1];

T[j+1]=T[j];

T[j]=T[0];

exchange2=TRUE;

}

}

if（i==m）

{printf（"Theascendingresultis:

%d\n",m）;

for（k=1;k<=n;k++）

printf（"%5d",R[k].key）;

printf（"\n"）;

printf（"Thedescendingresultis:

%d\n",m）;

for（k=1;k<=n;k++）

printf（"%5d",T[k].key）;

printf（"\n"）;

printf（"Continue?

Exittopress0:

\n"）;

scanf（"%5d",&m）;

}

if（（!

exchange）&&（!

exchange2）||（m==0））

5

break;

}

if（m!

=0）

{printf（"Theascendingsortresultis:

\n"）;

for（k=1;k<=n;k++）

printf（"%5d",R[k].key）;

printf（"\n"）;

printf（"Thedescendingsortresultis:

\n"）;

for（k=1;k<=n;k++）

printf（"%5d",T[k].key）;

printf（"\n"）;

}

}

intpartition（inti,intj）

{intc=1;

rectypepivot=R[i];

while（i

{while（i=pivot.key）

j--;

if（i

R[i++]=R[j];

while（i

i++;

if（i

R[j--]=R[i];

}

R[i]=pivot;

for（b=1;b<=n;b++）

{V[a][b]=R[c].key;

c++;

}

a++;

returni;

}

voidquicksort（intlow,inthigh）

{intpivotpos;

if（low

{pivotpos=partition（low,high）;

quicksort（low,pivotpos-1）;

quicksort（pivotpos+1,high）;

}

}

intpartition2（inti,intj）

{rectypepivot=T[i];

while（i

6

{while（i

j--;

if（i

T[i++]=T[j];

while（i=pivot.key）

i++;

if（i

T[j--]=T[i];

}

T[i]=pivot;

returni;

}

voidquicksort2（intlow,inthigh）

{intpivotpos,k;

if（low

{pivotpos=partition2（low,high）;

num++;

if（num==m）

{printf（"Theascendingsortresultis:

%d\n",m）;

for（k=1;k<=n;k++）

{while（V[m][k]==0）m--;

printf（"%5d",V[m][k]）;

}

printf（"\n"）;

printf（"Thedescendingsortresultis:

%d\n",m）;

for（k=1;k<=n;k++）

printf（"%5d",T[k].key）;

printf（"\n"）;

printf（"Continue?

Exittopress0:

\n"）;

scanf（"%5d",&m）;

}

quicksort2（low,pivotpos-1）;

quicksort2（pivotpos+1,high）;

}

if（m!

=0&&V[m][k]==0）

{if（low==1&&high==n）

{printf（"Theascendingsortresultis:

\n"）;

for（k=1;k<=n;k++）

{while（V[m][k]==0）m--;

printf（"%5d",V[m][k]）;

}

printf（"\n"）;

printf（"Thedescendingsortresultis:

\n"）;

for（k=1;k<=n;k++）

printf（"%5d",T[k]）;

7

printf（"\n"）;

}

}

while（m!

=0&&V[m][k]!

=0）

{printf（"Theascendingsortresultis:

\n"）;

for（k=1;k<=n;k++）

printf（"%5d",V[m][k]）;

printf（"\n"）;

printf（"Thedescendingsortresultis:

\n"）;

for（k=1;k<=n;k++）

printf（"%5d",T[k]）;

printf（"\n"）;

printf（"Continue?

Exittopress0:

\n"）;

scanf（"%5d",&m）;

}

}

voidselectsort（）

{inti,j,k,h;

for（i=1;i

{h=i;

for（j=i+1;j<=n;j++）

{if（R[j].key

h=j;

}

if（h!

=i）

{R[0]=R[i];

R[i]=R[h];

R[h]=R[0];

}

for（j=i+1;j<=n;j++）

{if（T[j].key>T[h].key）

h=j;

}

if（h!

=i）

{T[0]=T[i];

T[i]=T[h];

T[h]=T[0];

}

if（i==m）

{printf（"Theascendingresultis:

%d\n",m）;

for（k=1;k<=n;k++）

printf（"%5d",R[k].key）;

printf（"\n"）;

printf（"Thedescendingresultis:

%d\n",m）;

for（k=1;k<=n;k++）

8

printf（"%5d",T[k].key）;

printf（"\n"）;

printf（"Continue?

Exittopress0:

\n"）;

scanf（"%5d",&m）;

}

}

if（m!

=0）

{printf（"Theascendingsortresultis:

\n"）;

for（k=1;k<=n;k++）

printf（"%5d",R[k].key）;

printf（"\n"）;

printf（"Thedescendingsortresultis:

\n"）;

for（k=1;k<=n;k++）

printf（"%5d",T[k].key）;

printf（"\n"）;

}

}

七、实验结果

1．排序思想：

（1）插入排序（InsertionSort）的基本思想是：

每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的文件中的适当位置，直到全部记录插入完成为止。

（2）起泡排序（RubbleSort）的基本思想是：

两两比较待排序记录的关键字，发现两个记录的次序相反时即进行交换，直到没有反序的记录为止。

3）快速排序（QuickSort）又称划分交换排序。

其基本思想是：

在当前无序区R[1]到R[h]中任取一个记录作为比较的“基准”（不妨记为temp），用此基准将当前的无序区划分为左右两个较小的无序子区：

R[1]到R[i-1]和R[i+1]到R[h],且左边的无序子区中记录关键字均小于或等于基准temp的关键字，右边的无序子区中记录的关键字均大于或等于基准temp的关键字，而基准temp则位于最终排序的位置上，即：

R[1]到R[i-1]中关键字<=temp.key<=R[i+1]到R[h]的关键字（1<=i<=h）

当R[1]到R[i-1]和R[i+1]到R[h]均非空时，分别对它们进行上述的划分过程，直到所有的无序子区中记录均已排好序为止。

（4）选择排序（SelectionSort）的基本方法是：

每一趟从待排序的记录中选出关键字最小的记录，顺序放在排好序的子文件的最后，直到全部记录排序完毕。

2．运行结果：

（1）第一次生成随机数排序结果：

Havegeneratedrandomly10sortnumbers:

418454606756860709967529968

*******Menu*******

Pleaseselectoption:

1------Updatadata------

2------Insertsort------

3------Rubblesort------

4------Quicksort------

5------Selectsort------

6------Quitsort------

9

Pleaseselectoperatingtype:

2

10

Theascendingsortresultis:

416067460529568709845967968

Thedescendingsortresultis:

968967845709568529460676041

*******Menu*******

Pleaseselectoption:

1------Updatadata------

2------Insertsort------

3------Rubblesort------

4------Quicksort------

5------Selectsort------

6------Quitsort------

Pleaseselectoperatingtype:

3

10

Theascendingsortresultis:

416067460529568709845967968

Thedescendingsortresultis:

968967845709568529460676041

*******Menu*******

Pleaseselectoption:

1------Updatadata------

2------Insertsort------

3------Rubblesort------

4------Quicksort------

5------Selectsort------

6------Quitsort------

Pleaseselectoperatingtype:

4

8

Theascendingsortresultis:

416067460529568709845967