北邮数据结构第四次实验排序(MFC实现)
- 格式:doc
- 大小:207.00 KB
- 文档页数:7
本科实验报告实验名称:排序一、实验目的2、通过编程、上机调试,进一步理解排序的方法。
3、具体尝试插入排序、快速排序、选择排序的操作步骤。
4、锻炼动手编程,独立思考的能力。
二、实验题目排序输入10个数,从插入排序、快速排序、选择排序三类算法中各选一种编程实现三、实验基础知识插入排序、快速排序、选择排序三类算法的基本思想四、实验设计方法1、概要设计(1)、插入排序(此次使用直接插入排序)void InsertionSort ( SqList &L ){ // 对顺序表L 作直接插入排序。
for ( i=2; i<=L.length; ++i )if (L.r[i].key < L.r[i-1].key){L.r[0] = L.r[i]; // 复制为监视哨for ( j=i-1; L.r[0].key < L.r[j].key; -- j )L.r[j+1] = L.r[j]; // 记录后移L.r[j+1] = L.r[0]; // 插入到正确位置}} // InsertSort(2)、快速排序(此次用的是起泡排序)V oid Bubblesort(elem R[],int n){I=n;While(i>1){lastExchangeIndex = 1;for(j=1;j<i;j++)if(R[j+1].key<R[j].key){swap(R[j],R[j+1]);lastExchangeIndex =j; //记下进行交换的记录位置}I=lastExchangeIndex ; //本趟进行过交换的最后一个记录的位置}//Bubblesort(3)、选择排序V oid selectsort(elem r[],int n){//对记录序列r[1..n]作简单选择排序。
for(i=1;i<n;++i){//选择第i小的记录,并交换到位j=selectminkey(r,i);//zai r[i..n]中选择关键字最小的记录if(i!=j) R[i] R[j];//与第i个记录交换}}//selectsort五、实验结果及数据分析数据为3 2 4 1 5 0 6 9 8 7的十个数的三种排序方法1、插入排序2、快速排序3、选择排序六、总结此次编程实验,较前几次而言稍微简单一点,并且以前用过起泡排序法,所以对排序方面比较熟悉,但是也遇到了一些问题,例如数组下标问题没处理好,让我在编程实践中花费了大量时间检查。
实验4 排序的编程与实现实验目的:掌握常用的排序方法,并掌握C语言实现排序算法的方法;了解各种排序方法过程及依据原则,并掌握各种排序方法的时间复杂度和稳定性的分析方法。
实验原理:参照课本p.220页内容中的 Figure7.2;课本p.223页内容中的Figure7.4;p.228,Figure7.8;p.232-233, Figure7.9-7.10; p240-243, Figure 7.12-7.15.实验内容:统计成绩【问题描述】:给出n个学生的考试成绩表,每条信息由姓名和分数组成,利用排序算法完成以下任务:1)按照分数高低次序,打印出每个学生在考试中获得的名次,分数相同的为同一名次。
2)按照名次列出每个学生的姓名和分数【要求】学生的考试成绩需要从键盘输入数据建立,同时要设计输出格式。
实验要求:1)能够采用常用的排序算法中的一种实现以上两个任务;实验步骤:一、实验源程序#include<stdio.h>#include <string.h>#include<stdlib.h>#include <conio.h>void Input(int n); \\实现从键盘输入学生姓名和分数的功能void Ranking(int n); \\实现根据学生成绩进行排序的功能struct student \\结构体,存放学生姓名及分数{char name[8];int score;} R[101];int main ( ) \\主程序{int x;printf("请输入需要录入信息的学生个数(不超过100): ");scanf ("%d",&x);Input(x);printf("学生成绩排名如下:\n ");printf(" 排名学生姓名成绩\n ");Ranking(x);getch();return 0;}void Input(int n) \\从键盘输入学生姓名和分数{int i;printf("请输入学生的姓名和成绩: \n");for (i=0; i<n; i++){printf ("学生姓名:");scanf ("%s", R[i].name);printf ("此学生的成绩:");scanf ("%d", &R[i].score);}}void Ranking(int n) \\根据学生成绩进行排序{int num=1,number=0, i, j, max=0;for (i=0; i<n; i++) \\外循环,将学生成绩从高到低进行排序{max=i;for (j=i+1; j<n; j++){if (R[j].score>R[i].score) \\内循环,如果排在后面的分数高于前面的,则进行结构体内容互换{max=j;R[100]=R[max];R[max]=R[i];R[i]=R[100];}}number=number+1; \\记录学生排名名次if ((i>0)&&(R[i].score<R[i-1].score)){num=number;}if(num==1)printf(" %3d %s%6d\n", num, R[i].name, R[i].score);elseprintf(" %4d %s%6d\n", num, R[i].name, R[i].score);}}二、实验结果①从键盘上输入学生姓名和分数信息,这里选择输入5个学生信息(上限人数程序中已经设置为100)。
实验四函数与数组的应用【实验目的】1.进一步掌握数据类型变量和常量的应用、运算符与表达式的应用、程序基本结构的应用。
2.熟悉定义函数的方法、函数实参和形参的对应关系以及“值”传递的方式。
3.掌握全局变量和局部变量的概念和使用方法。
4.理解并运用调用、递归调用、内联、重载和默认参数的函数,掌握函数调用的内部实现机制。
5.学会使用头文件,理解多文件结构,理解编译预处理的概念。
【实验要求】1.看懂讲义第三、四、五章所给出的典型例题,并在其上进行简单的修改,体会并理解所涉及到的内容。
2.完成实验所给出的题目,注意参照课本上的相应内容。
3.掌握编译器的调试功能,学会单步和设断点调试程序的方法。
【实验内容】1.设计一个程序,用户输入一个整数,然后计算此数的绝对值、平方根、立方、自然对数值。
提示:绝对值函数:abs( );平方根:sqrt( );立方:pow( );自然对数:log( )程序:#include<iostream>#include<cmath>using namespace std;void main(){int a;float pow(int a);cout<<"please input a mumber"<<endl;cin>>a;cout<<"jueduizhi is"<<abs(a)<<endl;cout<<"pingfanggen is"<<sqrt(a)<<endl;cout<<"lifang is"<<pow(a)<<endl;cout<<"ziranduishu is"<<log(a)<<endl;}float pow(int a){float sum;sum=a*a*a;return sum;}2.已知有10个常数21,56,178,9,21,70,206,90,16,88,并按照从小到大的顺序打印出来。
实验报告课程名称数据结构实验名称查找与排序得实现系别专业班级指导教师11学号姓名实验日期实验成绩一、实验目得(1)掌握交换排序算法(冒泡排序)得基本思想;(2)掌握交换排序算法(冒泡排序)得实现方法;(3)掌握折半查找算法得基本思想;(4)掌握折半查找算法得实现方法;二、实验内容1.对同一组数据分别进行冒泡排序,输出排序结果。
要求:1)设计三种输入数据序列:正序、反序、无序2)修改程序:a)将序列采用手工输入得方式输入b)增加记录比较次数、移动次数得变量并输出其值,分析三种序列状态得算法时间复杂性2.对给定得有序查找集合,通过折半查找与给定值k相等得元素。
3.在冒泡算法中若设置一个变量lastExchangeIndex来标记每趟排序时经过交换得最后位置,算法如何改进?三、设计与编码1、本实验用到得理论知识2、算法设计3、编码package sort_search;import java、util、Scanner;publicclass Sort_Search{//冒泡排序算法ﻩpublic voidBubbleSort(int r[]){int temp;ﻩint count=0,move=0;ﻩboolean flag=true;ﻩfor(int i=1;i〈r、length&&flag;i++){ﻩﻩflag=false;ﻩﻩcount++;ﻩfor(intj=0;j<r、length-i;j++){if(r[j]>r[j+1]){ﻩtemp=r[j];ﻩﻩﻩr[j]=r[j+1];r[j+1]=temp;ﻩﻩmove++;flag=true;ﻩﻩ}ﻩﻩﻩ}ﻩ}ﻩﻩSystem、out、println("排序后得数组为:”);ﻩfor(int i=0;i〈r、length;i++){ﻩﻩSystem、out、print(r[i]+" ”);ﻩ}System、out、println();ﻩSystem、out、println("比较次数为:"+count);ﻩﻩSystem、out、println("移动次数为:”+move);}ﻩpublic staticint BinarySearch(int r[],int key){//折半查找算法ﻩint low=0,high=r、length-1;ﻩwhile(low<=high){ﻩint mid=(low+high)/2;ﻩﻩif(r[mid]==key){ﻩreturn mid;ﻩﻩ}ﻩﻩelse if(r[mid]>key){high=mid—1;ﻩﻩ}ﻩﻩelse{ﻩﻩﻩlow=mid+1;ﻩﻩ}ﻩ}ﻩﻩreturn -1;ﻩ}//测试public static void main(String[]args){ﻩSort_Search ss=new Sort_Search();intt[]=new int[13];ﻩSystem、out、println(”依次输入13个整数为:");ﻩScanner sc=new Scanner(System、in);ﻩfor(int i=0;i〈t、length;i++){ﻩﻩt[i]=sc、nextInt();ﻩ}ﻩﻩSystem、out、println("排序前得数组为: ");ﻩfor(int i=0;i<t、length;i++){ﻩSystem、out、print(t[i]+"”);ﻩ}ﻩSystem、out、println();ﻩﻩss、BubbleSort(t);//查找ﻩwhile(true){ﻩﻩSystem、out、println("请输入要查找得数: ”); ﻩﻩint k=sc、nextInt();ﻩif(BinarySearch(t,k)>0)System、out、println(k+"在数组中得位置就是第:"+ BinarySearch(t,k));ﻩﻩelseﻩﻩSystem、out、println(k+”在数组中查找不到!");ﻩ}ﻩ }}四、运行与调试1.在调试程序得过程中遇到什么问题,就是如何解决得?问题:在计算比较次数与移动次数时,计算数据明显出错。
北京物资学院信息学院实验报告
课程名_数据结构与算法
实验名称查找与排序
实验日期年月日实验报告日期年月日姓名______ ___ 班级_____ ________ 学号___
一、实验目的
1.掌握线性表查找的方法;
2.了解树表查找思想;
3.掌握散列表查找的方法.
4.掌握插入排序、交换排序和选择排序的思想和方法;
二、实验内容
查找部分
1.实现顺序查找的两个算法(P307), 可以完成对顺序表的查找操作, 并根据查到和未查到两种情况输出结果;
2.实现对有序表的二分查找;
3.实现散列查找算法(链接法),应能够解决冲突;
排序部分
4.分别实现直接插入排序、直接选择排序、冒泡排序和快速排序算法
三、实验地点与环境
3.1 实验地点
3.2实验环境
(操作系统、C语言环境)
四、实验步骤
(描述实验步骤及中间的结果或现象。
在实验中做了什么事情, 怎么做的, 发生的现象和中间结果, 给出关键函数和主函数中的关键段落)
五、实验结果
六、总结
(说明实验过程中遇到的问题及解决办法;个人的收获;未解决的问题等)。
实验四数据排序实验一、实验目的1、熟悉80C51 指令系统,掌握程序设计方法;2、了解数据在单片机内的比较、交换过程;3、掌握使用汇编语言来实现数据冒泡排序并输出结果;二、实验仪器计算机一台、单片机实验箱一台,MCS51仿真开发系统。
三、实验基本原理编写并调试一个排序子程序,其功能为用冒泡法将内部RAM 中几个单元字节无符号的正整数,按从小到大的次序重新排列。
冒泡排序原理:依次比较相邻的两个数,将小数放在前面,大数放在后面。
即首先比较第1个和第2个数,将小数放前,大数放后。
然后比较第2个数和第3个数,将小数放前,大数放后,如此继续,直至比较最后两个数,将小数放前,大数放后。
重复以上过程,仍从第一对数开始比较(因为可能由于第2个数和第3个数的交换,使得第1个数不再小于第2个数),将小数放前,大数放后,一直比较到最大数前的一对相邻数,将小数放前,大数放后,第二趟结束,在倒数第二个数中得到一个新的最大数。
如此下去,直至最终完成排序。
四、实验内容及步骤1) 打开MCS51仿真开发系统,编写好程序,保存、编译正确后进入调试界面。
2)在仿真系统中打开寄存器窗口手工修改片内RAM 区50H—5AH 的值,在其中放入不等的数据。
3)用连续运行方式从起始地址0100H 开始运行程序。
4)观察寄存器的数据变化,检查50—5AH 中内容应是否从小到大排列。
ORG 0100HQUE: MOV R3,#50HQUE1: MOV A,R3 ;指针送R0MOV R0,AMOV R7,#0AH ;长度送R7CLR 00H ;标志位为0MOV A,@R0QL2: INC R0MOV R2,ACLR CMOV 22H,@R0CJNE A,22H,QL3 ;相等吗?SETB CQL3: MOV A,R2JC QL1 ;大于交换位置SETB 00HXCH A,@R0DEC R0XCH A,@R0INC R0 ;大于交换位置QL1: MOV A,@R0DJNZ R7,QL2JB 00H,QUE1 ;一次循环中有交换继续SJMP $ ;无交换退出五、实验结果及数据处理(实验结果数据暂时不填)运行程序前地址50H 51H 52H 53H 54H 55H 56H 57H 58H 59H 5AH 数据1FH 0FFH 56H 78H 7CH 80H 9AH 0A8H 0CH 0F0H 0FH运行程序后地址50H 51H 52H 53H 54H 55H 56H 57H 58H 59H 5AH 数据0CH 0FH 1FH 56H 78H 7CH 80H 9AH 0A8H 0F0H 0FFH六、实验分析及结论通过本次实验,使我对单片机MCS51系列指令系统有了更深层次的了解,也学会了如何运用它们编写程序来对单片机内存单元的读写操作进行控制,对于在单片机内如何利用寄存器来进行数据比较与交换也有了更深层次的了解。
数据结构(第4版)习题及实验参考答案数据结构复习资料完整版(c语言版)数据结构基础及深入及考试习题及实验参考答案见附录结论1、数据的逻辑结构是指数据元素之间的逻辑关系。
即从逻辑关系上描述数据,它与数据的存储无关,是独立于计算机的。
2、数据的物理结构亦称存储结构,是数据的逻辑结构在计算机存储器内的表示(或映像)。
它依赖于计算机。
存储结构可分为4大类:顺序、链式、索引、散列3、抽象数据类型:由用户定义,用以表示应用问题的数据模型。
它由基本的数据类型构成,并包括一组相关的服务(或称操作)。
它与数据类型实质上是一个概念,但其特征是使用与实现分离,实行封装和信息隐蔽(独立于计算机)。
4、算法:是对特定问题求解步骤的一种描述,它是指令的有限序列,是一系列输入转换为输出的计算步骤。
5、在数据结构中,从逻辑上可以把数据结构分成(C)A、动态结构和表态结构B、紧凑结构和非紧凑结构C、线性结构和非线性结构D、内部结构和外部结构6、算法的时间复杂度取决于(A)A、问题的规模B、待处理数据的初态C、问题的规模和待处理数据的初态线性表1、线性表的存储结构包括顺序存储结构和链式存储结构两种。
2、表长为n的顺序存储的线性表,当在任何位置上插入或删除一个元素的概率相等时,插入一个元素所需移动元素的平均次数为(E),删除一个元素需要移动的元素的个数为(A)。
A、(n-1)/2B、nC、n+1D、n-1E、n/2F、(n+1)/2G、(n-2)/23、“线性表的逻辑顺序与存储顺序总是一致的。
”这个结论是(B)A、正确的B、错误的C、不一定,与具体的结构有关4、线性表采用链式存储结构时,要求内存中可用存储单元的地址(D)A、必须是连续的B、部分地址必须是连续的C一定是不连续的D连续或不连续都可以5、带头结点的单链表为空的判定条件是(B)A、head==NULLB、head->ne某t==NULLC、head->ne某t=headD、head!=NULL6、不带头结点的单链表head为空的判定条件是(A)A、head==NULLB、head->ne某t==NULLC、head->ne某t=headD、head!=NULL7、非空的循环单链表head的尾结点P满足(C)A、p->ne某t==NULLB、p==NULLC、p->ne某t==headD、p==head8、在一个具有n个结点的有序单链表中插入一个新结点并仍然有序的时间复杂度是(B)A、O(1)B、O(n)C、O(n2)D、O(nlog2n)数据结构(第4版)习题及实验参考答案9、在一个单链表中,若删除p所指结点的后继结点,则执行(A)A、p->ne某t=p->ne某t->ne某t;B、p=p->ne某t;p->ne某t=p->ne某t->ne某t;C、p->ne某t=p->ne某t;D、p=p->ne某t->ne某t;10、在一个单链表中,若在p所指结点之后插入所指结点,则执行(B)A、->ne某t=p;p->ne某t=;B、->ne某t=p->ne某t;p->ne某t=;C、->ne某t=p->ne某t;p=;D、p->ne某t=;->ne某t=p;11、在一个单链表中,已知q是p的前趋结点,若在q和p之间插入结点,则执行(C)A、->ne某t=p->ne某t;p->ne某t=;B、p->ne某t=->ne某t;->ne某t=p;C、q->ne某t=;->ne某t=p;D、p->ne某t=;->ne某t=q;12、在线性结构中,第一个结点没有前趋结点,其余每个结点有且只有1个前趋结点。
5.3 实验题一、基础题1.修改下列程序中的错误,输出结果,输出示例如图5-1所示。
并对有注释标记的语句进行功能注释。
#include<iostream>using namespace std;void f1(int x[ ]){int i;for(i=0;i<10;i++){x[i]=2*x[i]+1;if(i==6) //如果i的值为6,则执行大括号里面的语句{cout<<endl<<x[i]<<" ";}elsecout<<x[i]<<" ";}cout<<endl;}void main(){int a[10],i;for(i=0;i<10;i++)cin>>a[i]; //循环输入a[i]的值f1(a); //调用函数f1,计算a[i]的值}图5-1 第1题的输出示例2.修改下列程序的错误,完成求最大数的功能。
#include<iostream>#include<cmath>using namespace std;int f1(int x ,int y);void main(){int a=120,b=300,c=40;int d,e;d=f1(a,b);e=f1(d,c);cout<<"a="<<a<<endl;cout<<"b="<<b<<endl;cout<<"c="<<c<<endl;cout<<"三个数中的最大数为:"<<e<<endl; }inline int f1(int x,int y){return x>y?x:y;}3.分析程序出错的原因,并更正、输出正确的结果。
第1篇一、实验目的本次实验旨在通过北邮程序实践,加深对编程基础知识的理解,提高编程能力和实践操作能力。
通过实验,使学生能够熟练运用编程语言进行实际问题求解,培养独立思考和团队协作能力。
二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.83. 开发工具:PyCharm三、实验内容本次实验主要分为三个部分:数据结构、算法设计与分析、编程实践。
1. 数据结构(1)实验内容:实现线性表、栈、队列、链表、树等基本数据结构。
(2)实验步骤:步骤一:创建一个线性表类,实现线性表的基本操作,如插入、删除、查找等。
步骤二:创建一个栈类,实现栈的基本操作,如入栈、出栈、判断栈空等。
步骤三:创建一个队列类,实现队列的基本操作,如入队、出队、判断队列空等。
步骤四:创建一个链表类,实现链表的基本操作,如插入、删除、查找等。
步骤五:创建一个树类,实现树的基本操作,如创建树、遍历树、查找节点等。
(3)实验结果:通过实验,成功实现了线性表、栈、队列、链表、树等基本数据结构,并验证了其功能。
2. 算法设计与分析(1)实验内容:设计并分析排序算法、查找算法、递归算法等。
(2)实验步骤:步骤一:设计并实现冒泡排序、选择排序、插入排序等排序算法。
步骤二:设计并实现二分查找、线性查找等查找算法。
步骤三:设计并实现递归算法,如汉诺塔、斐波那契数列等。
(3)实验结果:通过实验,成功实现了冒泡排序、选择排序、插入排序、二分查找、线性查找、递归算法等,并分析了其时间复杂度和空间复杂度。
3. 编程实践(1)实验内容:利用所学编程知识,解决实际问题。
(2)实验步骤:步骤一:分析问题,确定算法和数据结构。
步骤二:编写代码,实现算法。
步骤三:调试代码,确保程序正确运行。
步骤四:优化代码,提高程序效率。
(3)实验结果:通过实验,成功解决了以下实际问题:1. 输入一个整数序列,输出最大值、最小值、平均值和方差。
2. 输入一个字符串,输出字符串的逆序。
目录1.引言............................................................................................................................ 错误!未定义书签。
2.需求分析.................................................................................................................... 错误!未定义书签。
3.详细设计.................................................................................................................... 错误!未定义书签。
3.1 直接插入排序................................................................................................ 错误!未定义书签。
3.2折半排序......................................................................................................... 错误!未定义书签。
3.3 希尔排序........................................................................................................ 错误!未定义书签。
3.4简单选择排序................................................................................................. 错误!未定义书签。
实验报告课程名称:数据结构与算法课程类型:必修实验项目:排序算法实验实验题目:经典排序算法的实现一、实验目的1.了解几种基本排序算法的思想2.实现几种基本的排序算法3.分析比较各种排序算法的时间复杂度4.更好深入理解各种排序算法二、实验要求及实验环境实验要求:实现以下四组排序算法中的任意三组:冒泡排序和快速排序;选择排序和堆排序。
插入排序和希尔排序;(二路)归并排序, 基数排序产生不同规模和分布的数据,以“图或表”的方式给出输入规模和分布对排序方法运行时间变化趋势的影响(画出T(n)的曲线)。
并与理论分析结果比较。
将上述“图或表”采用图片等形式贴在实验报告中,与作适当分析或说明。
实验环境:codeblocks/Dev-C++三、设计思想(本程序中的用到的所有数据抽象数据性ADT的定义,主程序的流程图及各程序模块之间的调用关系)1. 所用的抽象数据性ADT的定义1)逻辑结构:最大堆:是一种特殊形式的线性表,根节点的值总是大于叶节点的值。
堆的操作:按照最大堆整理堆:void pushdown(int first, int last);结构体数组:一个具有很多结构体元素的数组。
结构体数组的操作:产生待排序数组a:void createtest(records a[]);找到数组a基准元素下标:int findpivot(int i, int j);对数组a的元素a[i]......a[j]进行快速排序:void quicksort(int i, int j);打印排序数组:void print();2) 存储结构:定义了一个结构体数组records a[max].里面存有一个关键字值int key,表示每个节点的值。
对应的结构如图所示:具体函数实现:void createtest(records a[]){int i, j, temp,k;for (i = 1; i < 101; i++){a[i].key = i;//printf("%d %d ", k, test[k]);}for (k = 1; k < 10000; k++){i = rand() % max;j = rand() % max;if (i != 0 && j != 0){temp = a[i].key;a[i].key = a[j].key;a[j].key = temp;}}}//产生待排序数组avoid quicksort(int i, int j){int pivot;int k; //关键字大于等于pivot的记录在序列中的起始下标int pivotindex; //关键字为pivot的记录在数组A中的下标pivotindex = findpivot(i, j);if (pivotindex != 0){pivot = a[pivotindex].key;k = partition(i, j, pivot);quicksort(i, k - 1);quicksort(k, j);}}//对数组a的元素a[i]......a[j]进行快速排序int findpivot(int i, int j) //返回a[i],a[j]总较大关键字的下标,若全相同则返回0 {int firstkey = a[i].key;int k;for (k = i + 1; k <= j; k++) //从左到右查找不同的关键字{if (a[k].key > firstkey){return k;}else if (a[k].key < firstkey){return i;}}return 0;}//找到数组a基准元素下标void print(){for (int i = 1; i <= max-1; i++){printf("%d ",a[i].key);}}//打印排序数组2. 主程序流程图及各程序模块之间的调用关系流程图:调用关系:在输入操作数1~7后,分别调用:1. createtest(a); bubblesort(max - 1);2. createtest(a); quicksort(1, max - 1);3. createtest(a); selectsort(max - 1);4. createtest(a); heapsort(max - 1);5. createtest(a);insertsort(max-1);6. createtest(a);shellsort(max - 1);7. createtest(a); mergesort(max-1);四、测试结果(要求程序运行截图)1. 测试用例:一个结构体数组a[101],其关键字存有从1到100的乱序排列 2. 测试结果:五、经验体会与不足经验体会:1.要注意交换两个数的函数需要带取地址符,因为是对地址的操作,这样才能实现交换。
数据结构实验报告实验名称:________链表排序___________ 学生姓名:_____________________班级:________________班内序号:_________________________ 学号:________________日期:_______________1.实验要求使用链表实现下面各种排序算法,并进行比较。
排序算法:1、插入排序2、冒泡排序3、快速排序4、简单选择排序5、其他要求:1、测试数据分成三类:正序、逆序、随机数据2、对于这三类数据,比较上述排序算法中关键字的比较次数和移动次数(其中关键字交换计为3次移动)。
3、对于这三类数据,比较上述排序算法中不同算法的执行时间,精确到微秒(选作)4、对2和3的结果进行分析,验证上述各种算法的时间复杂度编写测试main()函数测试排序算法的正确性2. 程序分析2.1 存储结构双向链表2.2 程序流程(或程序结构、或类关系图等表明程序构成的内容,一般为流程图等)2.3 关键算法分析定义节点:struct Node{int data;Node* next;Node* period;};插入排序:void InsertionSort(Node*q,int n){Node*first=q;Node*teq=q;Node*p=q->next;Node*point=p;int w,time=0,compar=0;while(p!=NULL){compar+=1;if(p->data<p->period->data){w=p->data;teq=p->period;while(teq!=NULL){compar+=1;if(teq->data>w){teq->next->data=teq->data;time+=1;if(teq->period==NULL){teq->data=w;time+=1;}}else{teq->next->data=w;time+=1;break;}teq=teq->period;}compar-=1;}p=p->next;}cout<<"插入排序后序列:";while(first!=NULL){cout<<first->data<<" ";first=first->next;}cout<<"\n插入排序比较次数为:"<<compar<<endl;cout<<"插入排序移动次数为:"<<time<<endl;}将链表分为有序区和无序区,分别将无序区的每一个元素插入到有序区的相应位置。
《数据结构与算法设计》实验报告——实验四学院:班级:学号:姓名:一、实验目的1.通过实验实践、巩固线性表的相关操作; 2.熟悉VC 环境,加强编程、调试的练习; 3.用C 语言实现线性表的抽象数据类型,实现线性表构造、插入、取数据等基本操作; 4. 理论知识与实际问题相结合,利用上述基本操作实现三种排序并输出。
二、实验内容从键盘输入10个数,编程实现分别用插入排序、交换排序、选择排序算法进行排序,输出排序后的序列。
三、程序设计1、概要设计为了实现排序的功能,需要将输入的数字放入线性表中,进行进一步的排序操作。
(1)抽象数据类型:ADT SqList{数据对象:D={|,1,2,,,0}i i a a ElemSet i n n ∈=≥数据关系:R1=11{,|,,1,2,,}i ii i a a a a D i n --<>∈= 基本操作:InPut(SqList &L)操作结果:构造一个线性表L 。
OutPut(SqList L)初始条件:线性表L 已存在。
操作结果:按顺序在屏幕上输出L 的数据元素。
InsertSort(SqList &L)初始条件:线性表L 已存在。
操作结果:对L 的数据元素进行插入排序。
QuickSort(SqList &L)初始条件:线性表L 已存在。
操作结果:对L 的数据元素进行快速排序。
SelectSort(SqList &L)初始条件:线性表L 已存在。
操作结果:对L 的数据元素进行选择排序。
}ADT SqList⑵主程序流程由主程序首先调用InPut(L)函数创建顺序表,调用InsertSort(L)函数进行插入排序,调用OutPut(L)函数显示排序结果。
调用QuickSort(L)函数进行交换排序,调用OutPut(L)函数显示排序结果。
调用SelectSort(L)函数进行选择排序,调用OutPut(L)函数显示排序结果。
一、实验目的1.掌握常用的排序方法,并用高级语言实现排序算法。
2.理解排序的定义和各种排序的特点。
3.了解排序过程及依据的原则,并了解各种排序方法的时间复杂度分析。
二、实验任务1.设计一待排序的线性表以顺序存储结构存储,试写出冒泡排序和直接插入排序算法。
三、程序流程图五、总结1.程序特点:最小化、模块化、for循环。
2.直接插入排序特点:双循环,从第二项起执行n-1趟,每趟开始将第i项赋给第0项作为循环终点,每趟最大执行i-1次。
每趟将前i+1项排序3.冒泡排序特点:双循环,从第一项起最大执行n-1趟,每趟开始将循环符号flag置零。
每趟从第一项起,执行n-i次。
每趟将第i大的项移到第n-i+1位。
附录程序清单//直接插入排序#define MAXLEN 100#include <stdio.h>struct sqlisttp{int elem[MAXLEN];int last;};sqlisttp *create(){int i;sqlisttp v;scanf("%d",&st);for(i=1;i<=st;i++)scanf("%d",&v.elem[i]);return &v;}void print(sqlisttp *p){int i;for(i=1;i<=p->last;i++)printf("%d ",p->elem[i]);printf("\n%d\n",p->last);}void insertsort(sqlisttp *p){int i,j;for(i=2;i<=p->last;i++){p->elem[0]=p->elem[i];for(j=i-1;p->elem[0]<p->elem[j];j--)p->elem[j+1]=p->elem[j];p->elem[j+1]=p->elem[0];}} void main(){printf("直接插入排序\n");sqlisttp v=*create();insertsort(&v);print(&v);}//冒泡排序#define MAXLEN 100#include <stdio.h>struct sqlisttp{int elem[MAXLEN];int last;};sqlisttp *create(){int i;sqlisttp v;scanf("%d",&st);for(i=1;i<=st;i++)scanf("%d",&v.elem[i]);return &v;}void print(sqlisttp *p){int i;for(i=1;i<=p->last;i++)printf("%d ",p->elem[i]);printf("\n%d\n",p->last);}void bubblesort(sqlisttp *p){int i,j,x,flag;for(i=1;(i<p->last)&&flag;i++){flag=0;for(j=1;j<=p->last-i;j++) if(p->elem[j]>p->elem[j+1]){x=p->elem[j];p->elem[j]=p->elem[j+1];p->elem[j+1]=x;flag=1;}}}void main(){printf("冒泡排序\n");sqlisttp v=*create();bubblesort(&v);print(&v);}。
数据结构实验报告实验名称:实验4——用简单数组实现排序日期:2009年12月6日1.实验要求使用简单数组实现下面各种排序算法,并进行比较。
排序算法:1、插入排序2、希尔排序3、冒泡排序4、快速排序5、简单选择排序6、堆排序(选作)7、归并排序(选作)8、基数排序(选作)9、其他要求:1、测试数据分成三类:正序、逆序、随机数据2、对于这三类数据,比较上述排序算法中关键字的比较次数和移动次数(其中关键字交换计为3次移动)。
3、对于这三类数据,比较上述排序算法中不同算法的执行时间,精确到微秒(选作)4、对2和3的结果进行分析,验证上述各种算法的时间复杂度编写测试main()函数测试线性表的正确性2.1 存储结构数组:数组下标:0 1 2 3 4 5 6插入到合适位置数组元素2.2 关键算法分析快速排序为代码:1.将i 和j分别指向待排序区域的最左侧记录和最右侧记录的位置;2.重复下述过程,直到i=j2.1右侧扫描,直到记录j的关键码小于基准记录的关键码;2.2 如果i<j,则将r[j]与r[i]交换,并将i++;2.3左侧扫描,直到记录i的关键码大于基准记录的关键码;2.4 如果i<j,则将r[i]与r[j]交换,并将j--;3.退出循环,说明i和j指向了基准记录所在位置,返回该位置;直接顺序排序void InsertSort(int r[], int n){ int ay=0;int ab=0;for (int i=2; i<n; i++){ ab++;r[0]=r[i]; //设置哨兵for (int j=i-1; r[0]<r[j]; j--) //寻找插入位置r[j+1]=r[j]; //记录后移r[j+1]=r[0];ay++;}for(int k=1;k<n;k++)//循环输出数据cout<<r[k]<<" ";cout<<"\n";cout<<"关键字移动次数:"<<3*ay<<endl;cout<<"关键字比较次数:"<<ab<<endl;}希尔排序void ShellSort(int r[], int n){ int by=0;int bb=0;int i;int d;int j;for (d=n/2; d>=1; d=d/2) //以增量为d进行直接插入排序{for (i=d+1; i<n; i++){ bb++;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];by++;}}for(i=1;i<n;i++)//循环输出数据cout<<r[i]<<" ";cout<<"\n";cout<<"关键字移动次数:"<<3*by<<endl;cout<<"关键字比较次数:"<<bb<<endl;}起泡排序void BubbleSort(int r[], int n){int cy=0;int cb=0;int temp;int exchange;int bound;exchange=n-1; //第一趟起泡排序的范围是r[0]到r[n-1]while (exchange) //仅当上一趟排序有记录交换才进行本趟排序{ cb++;bound=exchange;exchange=0;for (int j=0; j<bound; j++) //一趟起泡排序if (r[j]>r[j+1]){temp=r[j];r[j]=r[j+1];r[j+1]=temp;exchange=j; //记录每一次发生记录交换的位置cy++;}}for(int i=0;i<n;i++)//循环输出数据cout<<r[i]<<" ";cout<<"\n";cout<<"关键字移动次数:"<<3*cy<<endl;cout<<"关键字比较次数:"<<(2*n-1-cb)*cb/2<<endl;}快速排序一次划分int Partition(int r[], int first, int end){int i=first; //初始化int temp;while (i<j){while (i<j && r[i]<= r[j])j--; db++; //右侧扫描if (i<j){temp=r[i]; //将较小记录交换到前面r[i]=r[j];r[j]=temp;i++; dy++;}while (i<j && r[i]<= r[j])i++; db++; //左侧扫描if (i<j){temp=r[j];r[j]=r[i];r[i]=temp; //将较大记录交换到后面j--; dy++;}}return i; //i为轴值记录的最终位}//快速排序void QuickSort(int r[], int first, int end){if (first<end){ //递归结束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<n-1; i++) //对n个记录进行n-1趟简单选择排序{ eb++;index=i;for (j=i+1; j<n; j++) //在无序区中选取最小记录if (r[j]<r[index])index=j;if (index!=i){temp=r[i];r[i]=r[index];r[index]=temp;ey++;}}for(i=0;i<n;i++)cout<<r[i]<<" ";cout<<"\n";cout<<"关键字移动次数:"<<3*ey<<endl;cout<<"关键字比较次数:"<<eb*(eb+1)/2<<endl;}3.程序运行结果排序数据直接排序希尔排序起泡排序快速排序简单选择排序程序结束平均情况下快速排序为最优排序4总结排序过程通常要进行下列两种基本操作1.关键码之间的比较2.移动;记录从一个位置移动到另一个位置。
数据结构实验排序算法C++实现实验三排序姓名:班级:学号:1.实验要求1.1实验⽬的通过选择下⾯题⽬,学习、实现、对⽐各种排序算法,掌握各种排序算法的优劣,以及各种算法使⽤的情况。
1.2实验内容使⽤简单数组实现下⾯各种排序算法,并进⾏⽐较。
排序算法:1、插⼊排序2、希尔排序3、冒泡排序4、快速排序5、简单选择排序6、堆排序(选作)7、归并排序(选作)8、基数排序(选作)9、其他要求:1、测试数据分成三类:正序、逆序、随机数据2、对于这三类数据,⽐较上述排序算法中关键字的⽐较次数和移动次数(其中关键字交换计为3次移动)。
3、对于这三类数据,⽐较上述排序算法中不同算法的执⾏时间,精确到微秒(选作)4、对2和3的结果进⾏分析,验证上述各种算法的时间复杂度编写测试main()函数测试线性表的正确性。
2程序分析与关键代码2.1存储结构存储结构:⼀维数组2.2关键算法分析1.直接插⼊排序:数组分为有序区与⽆序区,初始时⾸个元素为有序。
从第⼆个元素开始,每个元素⼀趟,顺序查找获得插⼊点。
⼀趟实现,将待插⼊记录赋值给哨兵r[0],从后向前进⾏顺序查找,元素后移。
{r[0]=r[i]; //待插⼊元素赋值给r[0]r[i]=r[i-1];for(int j=i-2;r[0]r[j+1]=r[j];r[j+1]=r[0];}2.希尔排序:将数组分成两份,将第⼀份数组的元素与哨兵⽐较,若其⼤于哨兵,将其值赋给哨兵,哨兵与第⼆份数组元素⽐较,将较⼤的值赋给第⼆份数组,循环进⾏,将数组拆分。
关键代码for(int i=d+1;i<=n;i++) //⼀趟希尔排序{if(r[i]{r[0]=r[i];int j;for(j=i-d;j>0&&r[0]{r[j+d]=r[j];}r[j+d]=r[0];3.改进的冒泡排序:排序过程分为有序区与⽆序区,⼀趟冒泡排序将⼀个元素由⽆序区添加到有序区,初试有序区为空,将⽆序区由前向后依次将相邻元素关键码进⾏⽐较,正序不变,反序交换,关键码⼤的逐渐后移,重复⽐较,直⾄结尾。
数据结构实验报告实验名称:______二叉排序树___________ 学生姓名:____________________班级:_______________班内序号:_______________________学号:________________日期:________________1.实验要求根据二叉排序树的抽象数据类型的定义,使用二叉链表实现一个二叉排序树。
二叉排序树的基本功能:1.二叉排序树的建立2.二叉排序树的查找3.二叉排序树的插入4.二叉排序树的删除5.二叉排序树的销毁6.其他:自定义操作编写测试main()函数测试二叉排序树的正确性2. 程序分析2.1 存储结构二叉链表2.2 程序流程(或程序结构、或类关系图等表明程序构成的内容,一般为流程图等)2.2.1.2.2.2.伪代码1.从文件读取待建树元素2.建树,若待插入元素比根节点小,向左子树前进并重复比较左子树根节点,若待插入元素比根节点大,向右子树前进并重复比较右子树根节点,直至找到空节点则插入该元素,不断插入直至不剩下元素。
3.用户选择操作。
4.若用户选择查找,则现由用户输入待查找数值。
从根节点开始比较,若较小则移至左子树,若较大则移至右子树,直至关键码相等,则输出节点情况。
5.若用户选择插入,则现由用户输入待插入数值。
从根节点开始比较,若较小则移至左子树,若较大则移至右子树,直至到空节点,则插入该元素。
6.若用户选择删除,则现由用户输入待删除数值。
从根节点开始比较,若较小则移至左子树,若较大则移至右子树,直至关键码相等;1).若该节点为叶子节点,则直接删除;2).若该节点无左子树,则其双亲节点直接与其右子树根节点连接,再删除该节点;3).若该节点有左子树,则其左子树的最右节点数值直接覆盖该节点数值,再删除最后节点。
7.若用户选择销毁,则不断执行删除操作直至不剩余节点。
8.若用户选择退出,则程序结束。
2.3 关键算法分析关键代码即删除操作,代码如下:void Delete(BiNode* &R){BiNode* q=new BiNode;BiNode *s=new BiNode;if(R->lch==NULL){q=R;R=R->rch;delete q;}else if(R->rch==NULL){q=R;R=R->lch;delete q;}else{q=R;s=R->lch;while(s->rch!=NULL){q=s;s=s->rch;}R->data=s->data;if(q!=R)q->rch=s->lch;elseR->lch=s->lch;delete s;}}void Deletedata(BiNode* &R, int key){if(R==NULL) return;if(R->data==key) Delete(R);else if(R->data>key) Deletedata(R->lch,key);else Deletedata(R->rch,key);}首先先要定位到要删除的节点,不断递归调用deletedata这个函数,找到数值与需要删除节点的数值相等的节点时,调用delete这个函数。
数据结构排序实验报告一、实验目的本次数据结构排序实验的主要目的是深入理解和掌握常见的排序算法,包括冒泡排序、插入排序、选择排序、快速排序和归并排序,并通过实际编程和实验分析,比较它们在不同规模数据下的性能表现,从而为实际应用中选择合适的排序算法提供依据。
二、实验环境本次实验使用的编程语言为 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 个元素)的随机整数列表作为测试数据。
2011级数据结构实验报告
实验名称:实验四——排序(MFC实现)
学生姓名:
班级:发邮件到1017431192@附赠MFC源程序一份
班内序号:北邮学生你懂得…..
学号:
日期:
1.实验要求
实验目的:
通过选择下面两个题目之一,学习、实现、对比各种排序算法,掌握各种排序算法的优劣,以及各种算法使用的情况。
实验内容:
使用简单数组实现下面各种排序算法,并进行比较。
排序算法:
1、插入排序
2、希尔排序
3、冒泡排序
4、快速排序
5、简单选择排序
6、堆排序
7、归并排序
8、基数排序(选作)
9、其他
要求:
1、测试数据分成三类:正序、逆序、随机数据
2、对于这三类数据,比较上述排序算法中关键字的比较次数和移动次数(其中关键字交换计为3次移动)。
3、对于这三类数据,比较上述排序算法中不同算法的执行时间,精确到微秒(选作)
4、对2和3的结果进行分析,验证上述各种算法的时间复杂度
编写测试main()函数测试线性表的正确性。
2. 程序分析
2.1 存储结构
使用最简单的一维数组存储待排序的数据。
共使用两个数组,一个用来存储原始数据,一个用来存储待排序数据。
每次排序完毕,用原始数据更新一次待排序数据,保证每一次都
对同一组数据排序。
2.2 关键算法分析
1.直接插入的改进:
在一般的直接插入中,关键码每移动一次就需要比较一次。
在移动的方面,优化是比较困难的,因为对静态线性表的插入必然要带来大量的移动。
但是,我们可以在比较上进行一些优化。
在查找技术一张曾学过的“折半查找法”,在这里就可以照葫芦画瓢地运用。
一趟排序的伪代码如下:
1.如果该元素大于处于其左侧相邻的元素则跳过该元素;
2.low=0,high=i;
3.循环直至low==high
3.1 mid=(low+high)/2;
3.2如果当前元素大于中值high=mid;
3.3否则low=mid+1;
4.当前元素赋值给临时变量;
5.将有序区中处于low位置及其右侧的元素右移;
6.临时变量置于low位置
简单说一下这里的折半查找与一般查找算法的区别。
这里的查找,尤其是对无重复数据和大量数据的处理中,更多的时候是找不到完全相等的项的。
所以忽略这种情况,每次查找都进行到正常查找算法中查找失败的情形。
由于待选插入位置的数量为有序区项数加一,而在比较前加入的判断可将插入位置为有序去最末端(既不需移动)的情况特殊处理,所以实际待选插入位置数量与有序区项数相等,可用最终插入空当的右侧元素下标标记查找位置。
基于这种思想,我们设计了这样的算法。
插入值小于中值时,mid作为新的上限;大于中值时,将mid+1作为新的下限。
这样可以保证待选插入空当一直保持在mid左侧,而且当low==high时恰好可以指向最终插入位置。
该算法时间复杂度为O(n2),空间复杂度O(1)。
2.冒泡排序的改进
在某趟排序中,如果需要进行相邻的连续交换,可以像插入排序那样先集体右移,最后定位原始左侧的数据。
一趟排序的伪代码如下:
1.对无序区元素a i自左至右循环
1.1如果该元素小于处于其右侧相邻的元素则跳过该元素;
1.2当前元素赋值给临时变量;
1.3当前元素右侧相邻元素左移;
1.4 i++;
1.5循环直到临时变量小于或等于当前元素右侧相邻元素或已达序列尾部
1.5.1当前元素右侧相邻元素左移;
1.5.2 i++;
1.6临时变量置于当前位置;
关于以上代码,由于较易理解,这里就不做更多的说明了。
该算法时间复杂度为O(n2),空间复杂度O(1)。
3.快速排序的非递归算法及改进
一般来说,递归算法由于传递参数和返回值的因素会影响效率,而且容易造成系统栈溢出,所以使用非递归算法会较好一些。
另外,一趟排序中的轴值是始终不变的,不需要反复赋值,只需要先存入临时变量,确定位置后再写入即可。
相关伪代码如下:
1.建立两个栈,存储子列头尾,共用栈顶;
2.序列首尾相应入栈;
3.循环直到栈空
3.1栈顶元素出栈,用i,first接受头,j,last接收尾;
3.2首项赋值给轴值;
3.3无条件循环
3.3.1循环直至a j小于轴值或i==j
3.3.1.1 j--;
3.3.2 如果i==j则跳出循环;
3.3.3 a i赋值给a j ;
3.3.4 i++;
3.3.5循环直至a i大于轴值或i==j
3.3.5.1 i++;
3.3.6 如果i==j则跳出循环;
3.3.7 a j赋值给a i;
3.3.8 j--;
3.4轴值赋值给a i;
3.5若轴值左侧子列存在且大于一个元素
3.5.1 first、i-1作为子列头尾入栈;
3.6若轴值右侧子列存在且大于一个元素
3.6.1 i+1、last作为子列头尾入栈;
该算法时间复杂度为O(nlog2n),空间复杂度O(1)。
4.程序运行时间测试函数(可精确到微秒)
long double GetNowTime(void)//获取当前时间
{
LARGE_INTEGER litmp;
LONG64 QPart;
QueryPerformanceCounter(&litmp);
QPart=litmp.QuadPart;
return (long double)QPart;
}
2.3其他.
MFC界面设计
2.3.1.1添加按钮控件“正序数据”,“逆序数据”,“随机数据”分别完成正序,逆序,随机
数据的排序及测试
2.3.1.2 双击相应按钮控件添加代码:“正序数据”按钮控件代码如下:
void C排序性能测试Dlg::OnBnClickedButton1() //正序排序
{
UpdateData(true); //更新数据
N=MAX+1;
UpdateData(false);
long *r=new long[N];
long*r1=new long[N];
for(long i=1;i<N;i++)
r[i]=i;
UpdateData(true);
Insert1=InsertSort(r,N-1); //插入排序
move11=compare;com11=move; //移动和比较次数
Shell1=ShellInsert(r,N-1); //希尔排序
move21=move;com21=compare;
Bubble1=BubbleSort(r,N-1); //起泡排序
move31=move;com31=compare;
compare=0;move=0;
Qsort1=QSORT(r,0,N-1); //快速排序
move41=move;com41=compare;
Select1=SelectSort(r,N-1); //选择排序
move51=move;com51=compare;
compare=0;move=0;
Heap1=Heapsort(r,N-1); //堆排序
move61=move;com61=compare;
Merge1=MergeSort(r,r1,N-1); //归并排序
move71=move;com71=compare;
UpdateData(false);
delete r;
delete r1;
}
2.3.2.1添加数据更新所需编辑框
2.3.2.2为每个编辑框添加变量,类别选择V alue,变量类型选择long,变量名为move11过
程如下截图
测试结果:(规模n=100000)
从以上结果可以对不同的排序算法进行横行和纵向比较.以快速排序算法和起泡排序为例进行比较:
1.在数据有序性比较高时(正序)起泡排序的运行时间是0.002086s远远低于快速排序的运
行时间58.6672869s,但在数据乱序性较高时快速排序只需0.172759s,起泡排序却高达
92.590156s,这样比较可以得出在数据基本有序时用起泡排序要优于快速排序,在乱序性
较高时快速排序远远优于起泡排序.
2.单独看快速排序在正序,逆序,随机数据中,快速排序在随机数据表现出的性能最好.
3.类似比较可以的不同排序算法的优缺点,可以总结出不同排序算法的应用场合.
4.程序流程图:
5. 总结:
这一次程序设计我花了不少时间才完成。
虽然不是很完美,但也收获很多。
设计完成之后我欣喜的发现,我对程序的运用又进了一步,这是一件值得高兴的事情,可以说这次程序设计,我的收获挺大的!
而且这次使用MFC做出可视化界面,不过有之前做C++课设的基础,也就能用对话框做出一个可视化界面。
程序的优化是一个艰辛的过程,如果只是实现一般的功能,将变得容易很多,当加上优化,不论是效率还是结构优化,都需要精心设计。
这次做优化的过程中,学到了不少MFC 的知识和排序的改进算法。
因而以后必须要加强程序优化方面的训练,这样才能在将编程思想和数据结构转换为代码的时候能得心应手。
自己编好程序上机调试运行时,可能有很多你想不到的情况发生,通过解决这些问题,可以逐步提高自己程序开发能力.
同时它让我知道,只要你努力,任何东西都不会太难。
刚开始事物总是难的,只要坚持就会好的。