第一篇：数据结构的作业范文
课时作业(六) 大气圈的组成、结构和受热过程
一、选择题(每小题4分，共60分) 读图，完成1～2题。
1.利用人造烟雾来防御霜冻的原理是(
) A.减弱①
B.增强② C.减弱③
D.增强④
2.人类通过低碳经济和低碳生活，能使图中变化相对明显的是(
) A.①增强
B.②增强 C.③减弱
D.④减弱 3.(2013·珠海调研)下图为某地某日气温实况图，下列叙述正确的是(
)
A.最高气温出现在14：00，原因是太阳高度达到一天中最大 B.最低气温出现在6：00，原因是地面温度达到最低值 C.1：00～2：00降温幅度最大，原因是大气逆辐射最弱 D.9：00～11：00气温不断上升，原因是地面辐射不断增强 (2013·天津模拟)2012年10月12日早，天津出现大雾天气，能见度很低，给道路交通和市民出行带来不便。下图为城区海棠立交在浓雾中若隐若现。回答4～6题。
4.浓雾天气使能见度降低的原因之一是(
) A.浓雾吸收地面辐射，增强大气逆辐射 B.浓雾削弱了地面辐射
C.浓雾对太阳辐射有反射作用 D.浓雾改变了太阳辐射的波长
5.深秋初冬时节也是该地大雾多发期，这其中的道理是(
) A.昼夜温差减小，水汽易凝结，但风力微弱，水汽不易扩散 B.昼夜温差减小，水汽不易凝结，直接悬浮于大气中 C.昼夜温差较大，水汽不易凝结，直接附着在地面上
D.昼夜温差较大，水汽易凝结，且该季节晴好天气多，有利于扬尘的产生
6.读图可以发现此时虽然为浓雾天气，能见度不是很好，但是红绿色的交通信号灯却是很醒目。运用地理原理分析大雾期间红、绿色光仍然很醒目的原因(
) A.红、绿色光不容易被散射 B.红、绿色光最容易被散射 C.红、绿色光不容易被遮挡 D.红、绿色光不容易被吸收
(2013·济宁模拟)读某地近地面和高空四点气压图(单位：hPa)，回答7～8题。 7.若近地面和高空四点构成热力环流，则流动方向为(
) A.P→O→M→N→P B.O→P→M→N→O C.M→N→P→O→M D.N→M→O→P→N 8.在城市与郊区的热力环流中，能表示城市近地面的点是(
) A.M
B.N C.O
D.P (2013·宜宾检测)我国南方某地新建一小型水库，某日两时刻测得水库及其东西两侧气温分布如下图所示，据此回答9～10题。
9.关于水库及其周围地区气温的描述正确的是(
) A.水库中心区的气温日变化最大 B.水库中心区的气温日变化最小
C.一天中水库中心区的气温始终高于东西两侧地区的气温 D.一天中水库中心区的气温始终低于东西两侧地区的气温
10.由于水库与周围地区存在着气温差异，导致水库与周围地区之间形成了热力环流。关于该热力环流的描述正确的是(
) A.热力环流的方向不变
B.水库中心区始终存在上升气流 C.白天风由水库吹向四周 D.晚上风由水库吹向四周 (2013·安徽联考)读亚洲东部某区域某日两个时刻(北京时间)的等压线图(单位：百帕)，回答11～12题。
11.甲、乙两时刻相比，①点处最大气压差接近(
) A.0百帕
B.2百帕
C.4百帕
D.6百帕
12.乙图所示时刻的①②③④地点中，风力比甲图明显加大的是(
) A.①
B.②
C.③
D.④
13.右图示曲线为等压线，且c
) ①如仅考虑气压影响，图中各点气温最低的是d点 ②b、d之间有一低压槽 ③b、d的相对气压大于a、b的相对气压 ④b、d位于高压脊上
A.①②③
B.①③④
C.②③④
D.①②④
下图是水汽含量和温度的关系图，图中的曲线为饱和曲线，甲、乙、丙和丁的箭头方向分别代表大气中的水汽要达到饱和的途径。读图完成14～15题。
14.关于甲、乙、丙、丁四种途径的叙述不正确的是(
) A.甲：温度固定时，增加水汽而达到饱和 B.乙：经升高温度及减少水汽含量而达到饱和 C.丙：水汽含量不变时，降低温度而达到饱和 D.丁：经升高温度及增加水汽而达到饱和
15.关于自然现象“露”的形成，主要是通过下列哪一种途径而达到饱和的(
) A.甲
B.乙
C.丙
D.丁
二、非选择题(共40分) 16.矿物能源的大量使用，会使大气中二氧化碳的浓度不断提高;开发利用新能源，可以减少二氧化碳排放，降低大气中二氧化碳的浓度。下面甲、乙两图反映的是开发利用新能源的两种途径，据此回答下列问题。(16分)
(1)冬季晴天时，在未采用任何取暖设备的条件下，图甲所示“阳光居室”室内的最高温度可达22 ℃。请分析“阳光居室”是如何达到这一保温效果的?(8分)
(2)开发利用新能源，能够减缓全球变暖。请根据“温室效应”的原理，解释其原因。(8分)
17.(探究题)读华北地区某城市2012年11月13日20时的气温(单位：℃)实况图，回答下列问题。(24分)
(1)此图反映了城市所具有的________________效应。在这种效应的作用下，如不考虑其他因素，当晚城郊之间风向应该是________________。(4分) (2)形成此图所示效应的主要原因是(2分)(
) A.城市生产和生活活动释放大量热量 B.城市建筑对太阳辐射的反射率大 C.城市高层建筑的不断增多
D.城市上空云量少，对太阳辐射的削弱作用小
(3)一般而言，城区的降水几率________(大于或小于)郊区，主要是因为________________________________________________________________________。(6分) (4)在下图中画出城区和郊区之间的热力环流。(4分) (5)图中A地能否建水泥厂?为什么?(6分)
(6)试分析在城郊之间建设环境绿地的意义。(2分)
课时作业(六)答案
一、选择题
1.D 2.D 第1题，图中①～④的含义分别为太阳辐射、被大气削弱后的太阳辐射、地面辐射、大气逆辐射。人造烟雾中含有大量的二氧化碳，它能够吸收地面辐射中的红外线，从而增强大气逆辐射。第2题，人类通过低碳经济和低碳生活减少碳排放量，不增加或减少大气中的二氧化碳浓度，使大气逆辐射减弱。
3.D 地面是近地面大气直接的热量来源，9～11时太阳辐射逐渐增强，使地面温度上升，地面辐射不断增强使气温不断升高。太阳高度在地方时12时左右达到最大;能量由太阳辐射传递给地面，再由地面辐射传递给大气，所以地面辐射最高值滞后于太阳辐射最大值，气温最低值滞后于地面辐射最低值。大气逆辐射最弱时应是气温最低时。
4.C 5.D 6.A 第4题，浓雾天气使空气能见度降低主要是由于浓雾对太阳辐射有反射作用。第5题，深秋初冬时节，天气一般晴朗，昼夜温差大，夜晚降温快导致水汽易凝结，形成大雾天气。第6题，由于红绿色光的穿透力较强，不容易被散射，即使在能见度较低的情况下(如大雾天)也容易被看见，不容易发生交通事故，而其他颜色的光在大雾天很容易被散射。
7.B 8.D 第7题，根据图中的海拔可以判断出O、P两点位于近地面;M、N两点位于高空;结合图中的气压高低可以判断出在近地面O为高压，P为低压，风由O吹向P;在高空M为高压，N为低压，风由M吹向N。第8题，在城市与郊区的热力环流中，城市近地面气温高、气压低，应为图中的P点。
9.B 10.C 第9题，从图中看出，3点时水库中心区比东西两侧地区的气温高，15点时水库中心区比东西两侧气温低，因而气温日变化最小。第10题，一天中水库与周围地区热力差异在变化，热力环流的方向也要发生变化;白天水库气温低气压高，风由水库吹向四周;晚上风由四周吹向水库。
11.C 12.D 甲时刻①点气压介于1 008与1 010之间，乙时刻介于1 010与1 012之间，则两时刻最大气压差值接近4百帕。等压线变稠密的地方，风力加大。
13.B 近地面气压低，气温高。在高压中心附近有高压脊出现;在低压中心附近有低压槽的出现。
14.B 15.C 图中显示乙是通过降低温度和减少水汽含量来达到饱和的;自然过程中“露”的形成主要是通过降低温度来实现的。
二、非选择题
16.答案： (1)大部分太阳辐射能透过“阳光居室”的玻璃到达室内地面，地面吸收太阳辐射能而增温，并以长波辐射的形式把热量传递给室内大气，地面长波辐射不能穿透玻璃而被反射回地面，从而将热量保留在居室内。同时，封闭的空间也隔绝了室内外热量的交换，加强了保温效果。
(2)开发利用新能源使大气中二氧化碳减少，大气吸收的地面辐射也会减少，大气逆辐射会变弱，大气的保温作用减弱，使气温增高趋势减缓。
17.解析： 本题以某城市等温线分布图为切入点，考查热力环流的成因及其影响。第(1)题，城区气温高，而郊区温度低，反映了城市具有的热岛效应。第(2)题，形成城市热岛效应的主要原因是城市生产和生活活动释放大量的热量。第(3)题，由于城区空气对流上升运动强烈及烟尘多，导致城区降水几率大于郊区。第(4)题，根据热力环流的原理绘图，城区空气上升，郊区空气下沉，近地面郊区流向城区。第(5)题，主要考虑当地盛行风向及城郊热方环流。第(6)题，城郊之间建设绿地会改善城区大气环境质量。
答案： (1)热岛 由郊区吹向市区 (2)A (3)大于 城区空气对流上升运动;城区凝结核多，水汽容易凝结 (4)略
(5)不能。该地冬季盛行西北风，A位于盛行风的上风向;A地离市区太近，在城郊热力环流圈内，水泥厂的粉尘和污染气体能流向市区。
(6)美化环境，净化流向市内的空气，改善城市的大气质量。
第二篇：南京工业大学 数据结构 作业答案 作业3（推荐）
第三次作业
1.假设正读和反读都相同的字符序列为“回文”，例如，‘abba’和‘abcba’是回文，‘abcde’ 和‘ababab’则不是回文。假设一字符序列已存入计算机，请分析用线性表、堆栈和队列等方式正确输出其回文的可能性?
2. 顺序队的“假溢出”是怎样产生的?如何知道循环队列是空还是满?
3. 设循环队列的容量为40(序号从0到39)，现经过一系列的入队和出队运算后，有
① front=11，rear=19;② front=19，rear=11;问在这两种情况下，循环队列中各有元素多少个?
4. 试将下列递归过程改为非递归过程。
void test(int &sum){
int x;
Sanf(x);
if(x= =0) sum=0;
else {test(sum);sum+=x;}
printf(sum);
}
1.假设正读和反读都相同的字符序列为“回文”，例如，‘abba’和‘abcba’是回文，‘abcde’ 和‘ababab’则不是回文。假设一字符序列已存入计算机，请分析用线性表、堆栈和队列等方式正确输出其回文的可能性?
答：线性表是随机存储，可以实现，靠循环变量(j--)从表尾开始打印输出;
堆栈是后进先出，也可以实现，靠正序入栈、逆序出栈即可;
队列是先进先出，不易实现。
哪种方式最好，要具体情况具体分析。若正文在机内已是顺序存储，则直接用线性表从后往前读取即可，或将堆栈栈顶开到数组末尾，然后直接用POP动作实现。(但堆栈是先减后压还是„„)
若正文是单链表形式存储，则等同于队列，需开辅助空间，可以从链首开始入栈，全部压入后再依次输出。
2. 顺序队的“假溢出”是怎样产生的?如何知道循环队列是空还是满?
答：一般的一维数组队列的尾指针已经到了数组的上界，不能再有入队操作，但其实数组中还有空位置，这就叫“假溢出”。
采用循环队列是解决假溢出的途径。
另外，解决队满队空的办法有三：
① 设置一个布尔变量以区别队满还是队空;
② 浪费一个元素的空间，用于区别队满还是队空。
③ 使用一个计数器记录队列中元素个数(即队列长度)。
我们常采用法②，即队头指针、队尾指针中有一个指向实元素，而另一个指向空闲元素。
判断循环队列队空标志是： f=rear队满标志是：f=(r+1)%N
3. 设循环队列的容量为40(序号从0到39)，现经过一系列的入队和出队运算后，有
① front=11，rear=19;② front=19，rear=11;问在这两种情况下，循环队列中各有元素多少个?
答：用队列长度计算公式：(N+r-f)% N
① L=(40+19-11)% 40=8② L=(40+11-19)% 40=32
4. 参考程序：
void test(int &sum){
Stack S;
int x;
Sanf(x);
InitStack(S);
While(x){
Push(S,x);
Scanf(x);
}
sum=0;
printf(sum);
while(Pop(S,x)){
sum+=x;
printf(sum);
}
}
第三篇：数据结构上机作业
实验一 线性表
一、实验题
线性表的应用———多项式计算
二、程序设计思路
包括每个函数的功能说明，及一些重要函数的算法实现思路一链式存储：
1.void InitPoly(LNode *&p) 初始化多项式 2.void TraversePoly(LNode *&p) 遍历多项式 3.void ClearPoly(LNode *&p) 清除多项式
4.void InsertPoly(LNode *&p, double a, int e) 插入一项 5.void DeletetPoly(LNode *&p,int pos)
删除一项
6.double PolySum(LNode *&p, double x)
多项式求值 7.LNode * PolyAdd(LNode *&p1,LNode *& p2)
多项式相加 顺序存储：
1.void InitPoly1(SeqList &L) 初始化多项式 2.void ClearPoly1(SeqList &L) 清除多项式 3.void TraversePoly1(SeqList L)
遍历多项式
4.bool InsertPoly1(SeqList &L, ElemType item) 插入一项 5.double PolySum1(SeqList L,double x)
多项式求值 6.bool DeleteList1(SeqList &L,int pos)
删除一项
7.SeqList PolyAdd1(SeqList &L1,SeqList& L2)
多项式相加
三、源程序代码
#include #include #include #include "Linkpoly.h" #include "Seqpoly.h" void main() { cout<<"现在进行第一次测试。(链表表示)"<>n; cout<<"请依次输入要测试的各项的系数和指数:"; for(i=0;i>a; cin>>e; InsertPoly(pa, a, e); //插入一项 pa=pa->next; } pa=pa->next; cout<<"该多项式为:"; TraversePoly(pa); //输出多项式 cout<>a; cin>>e; cin>>pos; if(DeletetPoly(pa, a, e, pos)){ cout<<"删除成功!现在多项式为:"; TraversePoly(pa); cout<>x; sum=PolySum(pa, x); cout<<"该多项式的值为:"<>n; cout<<"请输入该多项式的各项系数和指数:"; for(i=0;i>a; cin>>e; InsertPoly(pb, a, e); //插入一项 pb=pb->next; } pb=pb->next; pp=PolyAdd(pa, pb); cout<<"两多项式相加后得到的多项式为:"; TraversePoly(pp); cout<>n; cout<<"请依次输入要测试的各项的系数和指数:"; for(i=0;i>a; cin>>e; InsertPoly1(s, a, e); } cout<<"该多项式为:"; TraversePoly1(s); cout<>a; cin>>e; cin>>pos; if(DeletetPoly1(s, a, e, pos)){ cout<<"删除成功!现在多项式为:"; TraversePoly1(s); cout<>x; sum=PolySum1(s, x); cout<<"该多项式的值为:"<>n; cout<<"请输入该多项式的各项系数和指数:"; for(i=0;i>a; cin>>e; InsertPoly1(t, a, e); //插入一项 } q=PolyAdd1(s, t); cout<<"两多项式相加后得到的多项式为:"; TraversePoly1(q); cout
{ if(pos>1||pos<-1) return false; NodeType *cp=p->next; NodeType *np=p; if(pos==0){ while(cp!=p){ if(cp->coef==a&&cp->exp==e) break; else{ np=cp; cp=cp->next; } } } else if(pos==-1) while (cp!=p){
删除np=cp; cp=cp->next; } np->next=cp->next; delete cp; return true; } double PolySum(NodeType *p, float x) //多项式求值 { int i; double sum=0,item; NodeType *cp=p->next; while(cp!=p){ item=1; for(i=1;i<=cp->exp;i++) item=item*x; sum=sum+item*cp->coef; cp=cp->next; } return sum; } NodeType *PolyAdd(NodeType *p1, NodeType *p2) //多项式相加 { float coef; NodeType *a=p1->next,*b=p2->next,*c,*pc; InitPoly(c); pc=c; while(a!=p1&&b!=p2){ if(a->exp==b->exp){ coef=a->coef+b->coef; if(coef!=0){ InsertPoly(pc, coef, a->exp); pc=pc->next; } a=a->next; b=b->next; } else if(a->expexp){ InsertPoly(pc,a->coef,a->exp); pc=pc->next; a=a->next; } else{ InsertPoly(pc,b->coef,b->exp); pc=pc->next; b=b->next; } } while(a!=p1){ InsertPoly(pc,a->coef,a->exp); pc=pc->next; a=a->next; } while(b!=p2){ InsertPoly(pc,b->coef,b->exp); pc=pc->next; b=b->next; } return c; } Seqploy.h: #define MaxSize 10000 struct ListType{ float *list; int size; }; void InitPoly1(ListType &p) //初始化多项式 { p.list=(float*)malloc(MaxSize*sizeof(float)); if(p.list==NULL){ cout<<"动态可分配的储存空间用完，退出运行!"<0){ cout<<"+"; cout<
输出多项式 } void ClearPoly1(ListType &p) //清除多项式 { if(p.list!=NULL){ delete []p.list; p.list=NULL; } p.size=0; } void InsertPoly1(ListType &p, float a, int e) //项
{ p.list[e]=a; if(p.size
{ int i,n; if(p.size==0){ cout<<"多项式为空,删除无效!"<
插入一if(p.list[e]==a) p.list[e]=0; else if(pos==-1) p.list[p.size]=0; return true; } double PolySum1(ListType p, float x) //值
{ double sum=0,item; int i,j; for(i=0;i<=p.size;i++){ item=1; for(j=1;j<=i;j++) item=item*x; sum=sum+item*p.list[i]; } return sum; } ListType PolyAdd1(ListType p1, ListType p2) //项式相加
{ ListType p; InitPoly1(p); float coef;
多项式求多int i,j; for(i=0;i<=p1.size;i++){ coef=p1.list[i]+p2.list[i]; InsertPoly1(p, coef, i); } if(i<=p1.size) for(j=i;j<=p1.size;j++) InsertPoly1(p, p1.list[j], j); if(i<=p2.size) for(j=i;j<=p2.size;j++) InsertPoly1(p, p2.list[j], j); return p; 四实验结果分析
五.心得体会 对于结构体的认识增加了，对于动态存储也有了更多的认识，也是在不知不觉中提高了。
实验二 字符串的操作
一、实验题目——字符串的操作
二、程序设计思路
采用定长顺序存储表示，由用户创建串s和串t，实现在串s中下标为pos的字符之前插入串t。
三、源程序代码
#define MAXLEN 10 typedef struct {
/*串结构定义*/
char ch[MAXLEN];
int len; }SString; void createstring(SString *s)
/*创建串s*/ { int i,j; char c; printf("input the length of the string:");
scanf("%d",&j);
for(i=0; i
{
printf("input the %d:",i+1);
fflush(stdin);
scanf("%c",&c);
s->ch[i] = c;
} s->len = j; } void output(SString *s)
/*输出串s*/ {
int i; for (i=0;ilen;i++)
printf("%c
",s->ch[i]);
printf(" "); } int StrInsert(SString *s, int pos, SString *t) /*在串s中下标为pos的字符之前插入串t */ {
int i; if (pos<0 || pos>s->len)
/*插入位置不合法*/
return(0);
if (s->len + t->len<=MAXLEN)
/*插入后串长≤MAXLEN*/ {
for (i=s->len + t->len-1;i>=t->len + pos;i--)
s->ch[i]=s->ch[i-t->len]; /*将下标为pos的字符后的元素往后移动t->len个长度*/
for (i=0;ilen;i++)
s->ch[i+pos]=t->ch[i];
/*将串t从下标为pos位置开始插入到串s*/
s->len=s->len+t->len; } else { if (pos+t->len<=MAXLEN) /*插入后串长>MAXLEN,但串t的字符序列可以全部插入*/
{
for (i=MAXLEN-1;i>t->len+pos-1;i--)
s->ch[i]=s->ch[i-t->len];
for (i=0;ilen;i++)
s->ch[i+pos]=t->ch[i];
/*将串t从下标为pos位置开始插入到串s*/
s->len=MAXLEN;
}
else
/*插入后串长>MAXLEN,并且串t的部分字符也要舍弃*/
{
for (i=0;i
s->ch[i+pos]=t->ch[i];
/*直接从下标为pos的位置按顺序插入串t*/
s->len=MAXLEN;
}
return(1);} } void main() {
SString *str1; SString *str2; int i,j,k,pos; int flag=0; str1 = (SString *)malloc(sizeof(SString)); str1->len = 0; printf("creat the string 1: "); createstring(str1); printf("creat the string 2: "); createstring(str2); printf("input the insert local:"); scanf("%d",&pos); flag=StrInsert(str1,pos,str2); if(flag == 0)
printf("insert error!"); else {
printf("after insert: ");
output(str1); } }
四、实验结果
五、实验体会
通过本次实验，我加深了对串数据结构的理解。在串的定长顺序存储结构中，按照预定义的大小，为每个定义的串变量分配一个固定长度的存储区。在存储方式中，结点大小的选择和顺序存储方式的格式选择一样都很重要，它直接影响着串处理的效率。
实验三
一、实验题目——非递归算法对二叉树进行中前序遍历
二、程序设计思路
创建一棵10个节点构造的完全二叉树，并对其进行前、中、后序遍历。
三、源程序代码
#define STUDENT EType #define SType SType
#define HeadEType int
#include #include
//定义数据结构类型
struct STUDENT { char name[8]; int age; char number[15]; char address[20]; };
struct BinaryTreeNode { EType data; BinaryTreeNode *LChild; BinaryTreeNode *RChild; }; typedef BinaryTreeNode BinaryTree;
typedef struct { BinaryTreeNode *ptr; bool status; }SType;
typedef struct { SType *element; int top; int MaxSize; }Stack;
void CreatStack(Stack &S, int MaxStackSize) {// 构造一个最大容量为MaxStackSize 的堆栈
S.MaxSize = MaxStackSize;
S.element = new SType[S.MaxSize];
S.top =-1; }
bool IsEmpty(Stack &S) {// 判断堆栈S是否为空
if (S.top == -1)
return true;
return false; }
bool IsFull(Stack &S) {// 判断堆栈S是否为空
if (S.top == MaxSize-1)
return true;
return false; }
bool Push(Stack &S , SType &x) {// x进s栈，返回进栈后的状态值
if (IsFull(S))
return false;
S.top++;
S.element[S.top] = x;
return true; }
bool Pop(Stack &S , SType &x) {// 将s栈顶的值取至x中，返回出栈后的状态值
if (IsEmpty(S))
return false;
x = S.element[S.top];
S.top--;
return true; }
BinaryTreeNode
*MakeNode(EType &x)
{//构造结点
BinaryTreeNode *ptr;
ptr = new BinaryTreeNode;
if (!ptr) return NULL;
ptr ->data = x ;
ptr -> LChild = NULL;
ptr -> RChild = NULL;
return
ptr; }
void MakeBinaryTree(BinaryTreeNode *root, BinaryTreeNode *left, BinaryTreeNode *right) {// 联接root，left, right所指的结点指针为二叉树
root ->LChild=left;
root ->RChild=right; }
void PreOrderNoRecursive(BinaryTreeNode *BT) {//二叉树前序遍历非递归的算法
Stack S; SType ele; BinaryTreeNode *q=BT; int MaxStackSize=50; //假设堆的空间足够大，即MaxStackSize值足够大
CreatStack(S,MaxStackSize); //产生一个空栈
while(q||!IsEmpty(S)) {
if(q)
{
cout
ele.ptr=q;
Push(S,ele); //节点指针进栈，以后回溯时在退栈
q=q->LChild; //指针指向刚刚被访问的“根”节点的左子树
}
else
//当左子树为空时，利用堆栈回溯
if(!IsEmpty(S))
{
Pop(S,ele); //退栈回溯
q=ele.ptr; //指针重新指向刚刚被访问的“根”节点
q=q->RChild; //指针指向该回溯节点的右子树
} } }
void InOrderNoRecursive(BinaryTreeNode *BT) {//二叉树的中序遍历非递归的算法
Stack S; SType ele; BinaryTreeNode *q=BT; int MaxStackSize=50; //假设堆的空间足够大，即MaxStackSize值足够大
CreatStack(S,MaxStackSize); //产生一个空栈
while(q || !IsEmpty(S)) {
while(q) //找到最左边的子树
{
ele.ptr=q;
Push(S,ele); //指针非空时，将当前的“根”节点指针进栈，用于以后回溯
q=q->LChild; //指针继续指向该“根”节点的左子树
}
if(!IsEmpty(S)) //当左子树为空时，进行退栈回溯
{
Pop(S,ele); //从堆栈中回溯节点指针(节点还未访问)
q=ele.ptr;
cout
q=q->RChild; //指针向回溯的节点右子树推进
} } }
void PostOrderNoRecursive(BinaryTreeNode *BT) {//二叉树的后序遍历非递归的算法
Stack S; SType ele; BinaryTreeNode *q=BT; int MaxStackSize=50; //假设堆的空间足够大，即MaxStackSize值足够大
CreatStack(S,MaxStackSize); //产生一个空栈
while(q || !IsEmpty(S)) {
if(q) //找最左边的子树
{
ele.ptr=q;
ele.status=false; //进栈前标记为第一次进栈
Push(S,ele);
q=q->LChild; //指针继续向左推进
}
else
if(!IsEmpty(S)) //直到左子树为空时，退栈回溯
{
Pop(S,ele); //从堆栈中弹出回溯节点(还未访问)
q=ele.ptr; //q指向当前回溯节点
if(ele.status) //判断节点进栈标志，是否对其进行访问
{
cout
q=NULL; //将q设为空，为了继续退栈
}
else
{
ele.status=true; //改变回溯节点的进栈标记，以便再次进栈
Push(S,ele);
q=q->RChild; //指针向该回溯节点的右孩子推进
}
} } }
//主函数 void main() { BinaryTreeNode *ptr[11];
char Name[][8]={" ","A","B","C","D","E","F","G","H","I","J"}; EType x[11]; for(int i=1;i<11;i++) {
strcpy(x[11-i].name,Name[11-i]);
ptr[11-i]=MakeNode(x[11-i]); //构造10个二叉树节点
}
//将节点链接域填值，构造一个二叉树
//这里构造的是一棵有10个节点的完全二叉树
for(int j=1;j<5;j++) {
MakeBinaryTree(ptr[j],ptr[2*j],ptr[2*j+1]); } MakeBinaryTree(ptr[5],ptr[10],NULL); //该完全二叉树构造完毕
//***********对已构造的完全二叉树进行前序非递归遍历************// cout<<"对该二叉树进行前序遍历结果："<
//***********对已构造的完全二叉树进行中序非递归遍历************// cout<
//***********对已构造的完全二叉树进行中序非递归遍历************// cout<
四、实验结果分析
五、实验总结
二叉树是一种非常重要的数据结构，很多其它数据结构都是基于二叉树的基础演变而来的。对于二叉树，有前序、中序以及后序三种遍历方法。因为树的定义本身就是递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁。而对于树的遍历若采用非递归的方法，就要采用栈去模拟实现。在三种遍历中，前序和中序遍历的非递归算法都很容易实现，非递归后序遍历实现起来相对来说要难一点。
实验四
一、实验题目——深度优先算法实现图的遍历
二、程序设计思路
以邻接矩阵或邻接表为存储结构，以用户指定的顶点为起始点，实现无向连通图的深度优先，并输出遍历的结点序列。首先，根据用户输入的顶点总数和边数，构造无向图，然后以用户输入的顶点为起始点，进行深度优先，并输出遍历的结果。
三、源程序代码
#include #define MaxVerNum 50 struct edgenode { int endver; int inform; edgenode* edgenext;
}; struct vexnode
{ char vertex; edgenode* edgelink; }; struct Graph
{ vexnode adjlists[MaxVerNum]; int vexnum; int arcnum; }; //队列的定义及相关函数的实现 struct QueueNode { int nData; QueueNode* next; }; struct QueueList { QueueNode* front; QueueNode* rear; }; void EnQueue(QueueList* Q,int e) { QueueNode *q=new QueueNode; q->nData=e; q->next=NULL; if(Q==NULL)
return; if(Q->rear==NULL)
Q->front=Q->rear=q; else {
Q->rear->next=q;
Q->rear=Q->rear->next; } } void DeQueue(QueueList* Q,int* e) { if (Q==NULL)
return; if (Q->front==Q->rear) {
*e=Q->front->nData;
Q->front=Q->rear=NULL; } else {
*e=Q->front->nData;
Q->front=Q->front->next; } } //创建图
void CreatAdjList(Graph* G) { int i,j,k; edgenode* p1; edgenode* p2; cout<<"请输入顶点数和边数:"<>G->vexnum>>G->arcnum; cout<<"开始输入顶点表:"
cin>>G->adjlists[i].vertex;
G->adjlists[i].edgelink=NULL; } cout<<"开始输入边表信息:"
cout<<"请输入边对应的顶点:";
cin>>i>>j;
p1=new edgenode;
p1->endver=j;
p1->edgenext=G->adjlists[i].edgelink;
G->adjlists[i].edgelink=p1;
p2=new edgenode;
p2->endver=i;
p2->edgenext=G->adjlists[j].edgelink;
G->adjlists[j].edgelink=p2;
//因为是无向图，所以有两次建立边表的过程
} }
//------------------------------深度优先遍历 void DFS(Graph *G,int i,int visit[]) { cout
DFS(G,p->endver,visit); } } void DFStraversal(Graph *G,char c)//深度优先遍历 { cout<<"该图的深度优先遍历结果为:"
visit[i]=0;//全部初始化为0，即未访问状态
} int m; for (i=0;ivexnum;i++) {
if (G->adjlists[i].vertex==c)//根据字符查找序号
{
m=i;
DFS(G,i,visit);
break;
} } //继续访问未被访问的结点
for(i=0;ivexnum;i++) {
if(visit[i]==0)
DFS(G,i,visit); } cout
int e=0;
DeQueue(Q,&e);
cout
visit[e]=1;
edgenode* p=new edgenode;
p=G->adjlists[e].edgelink;
if(p)
{
int m=p->endver;
if(m==0)
{
EnQueue(Q,m);
while(visit[m]==0)
{
p=p->edgenext;
if(p==NULL)
break;
m=p->endver;
EnQueue(Q,m);
}
}
}
} } void BFStraversal(Graph *G,char c) { cout<<"该图的广度优先遍历结果为:"
visited[i]=0; } int m; for (i=0;ivexnum;i++) {
if (G->adjlists[i].vertex==c)
{
m=i;
BFS(G,i,visited);
break;
} } //继续访问未被访问的结点
for(i=0;ivexnum;i++) {
if(visited[i]==0)
BFS(G,i,visited); } cout<>ch; DFStraversal(G,ch); BFStraversal(G,ch); }
四、实验结果及分析
五、实验总结
本次试验采用的是邻接表的方式实现图的深度优先遍历和。对于深度优先遍历，主要是采用递归的方式。试验本身问题不是太大，但要注意输入的问题，什么时候用空格，什么时候用回车，这一点是需要注意的，因为一旦数据的输入有问题，结果当然也就不可能正确了。只有正确的输入数据，建立图，才能得出正确的遍历结果。
第四篇：《数据结构》上机作业——实验报告(六)
“计算机软件技术基础”课程实验报告
(六)
实验名称：数据库及SQL语言
班级_______ 姓名__________ 学号______实验日期：
实验机时：3 学时实验成绩：
-----------------
一.实验目的：
1、学习数据库设计的一般过程及相关技术;
2、学习access数据库管理系统;
3、掌握数据库的输入、查询、更新操作。
二.实验内容：
1、需求陈述：某校图书馆要建立一个图书数据管理系统。该图书馆的图书(书名、分类号、作者、出版社)存放在不同的借阅室(室名)，读者(姓名、系名、类别)在书架上找到所需图书后，可以到服务台办理借阅(借阅时间)。
设计要求：
分析需求，建立数据库的概念模型;
将概念模型转换为关系模型(注意：是否需要作规范化处理); 写出创建基本表的SQL语句;
写出以下查询要求的SQL语句：
(1)所有“高等数学习题集”书的信息;
(2)读者“李林”借了什么书?
(3)“社会学原理”在哪个借阅室?
2、在access数据库管理系统中建立所设计的关系表;
3、向各表中输入一组实验数据(元组)(注意：关系完整性);
4、对数据库进行查询。
三.实验结果：
1、实体-关系图;
2、数据库表;
3、创建基本表的语句;
4、查询语句。
第五篇：湖州师范学院数据结构DS大作业
求真学院
数据结构课程设计大作业
20142832班
题
目： 专
业： 学生姓名： 学
号 指导教师 完成日期：
排序效率的比较 计算机科学与技术
邵
斌
湖州师院求真学院信息工程系
目
录
一、
二、
三、
四、
五、
六、
七、
实验内容概述 ............................................................................................................................... 1 实验目的概述 ............................................................................................................................... 1 解题思路的描述 ........................................................................................................................... 1 源程序清单 ................................................................................................................................... 1 程序调试及测试结果 ................................................................................................................... 8 结论 ............................................................................................................................................... 9 参考文献 ..................................................................................................................................... 10
I
此处写大作业题目(宋体三号，居中)
【内容摘要】
200至300字左右，楷体BG2312五号
【关键字】XXXX，XXXXX，XXXXX，XXXXX(3到5个) 数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素和集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率，处理各种问题。 该程序是用C语言编写的，它充分体现数据结构的理念与算法的魅力。 该程序植入多种排序方法，这些排序方法的算法各具有特色，利用多种算法达到同一效果，正所谓“条条大路通罗马”。并且，该程序还收集各算法的运行时间，通过对耗时的比较，为用户挑选出两种最优化的排序方法。
关键字：排序 逻辑运算 数据结构 时间复杂度
【Abstract】
中文摘要的翻译，五号，Times New Roman
【Key words】XXXXX，XXXXX，XXXXX，XXXXX Data structure is the way of computer storage and organization data. A data structure is a data element and a set of data elements that have one or more specific relationships between each other. Typically, carefully selected data structures can be brought to a higher running or storage efficiency, processing a variety of problems.
The program is written in C language, it fully reflects the concept of data structure and algorithm charm. The program is implanted in a variety of sorting methods, these sorting algorithms have the characteristics of each algorithm, the use of a variety of algorithms to achieve the same effect, is the so-called "all roads lead to Rome". And, the program also collects the running time of each algorithm, through the time of the comparison, for the user to pick out two kinds of optimization of the sorting method. Keywords: sorting logic operation data structure time complexity
一、 实验内容概述
对于直接插入排序、选择排序、冒泡排序、Shell排序、快速排序和堆排序等几种常见的排序算法进行练习，并且比较各算法在不同长度数据下的优劣。
要求：(1)被排序的对象由计算机随机生成，长度分别取20，100，500三种。
(2)程序中要有对各种排序算法的比较，具体为比较次数和移动次数的统计。
(3)对课设的结果做比较分析
二、 实验目的概述
1. 巩固和加深学生对数据结构算法的理解，提高综合运用所学课程知识的能力;
2. 通过各个排序算法的实现，练习包括文件的读写、动态内存的申请、函数的应用、指针的应用等多种最基本的C语言操作;
3. 锻炼学生的动手能力与培养其独立思考的能力。
三、 解题思路的描述
这是一个算法性能评价的程序，重点在于算法的性能评价上。实现排序功能可以有多种方法，判断一个算法性能好坏的标准主要有时间复杂度和空间复杂度。在当今系统资源相对充足的计算机系统中，时间复杂度便成为最主要的评价标准。
对于每一个排序算法，都应当有两个返回值：比较次数和移动次数。这里采用指针传递地址的方式，通过修改形参的地址从而可以改变实参的值。每个排序算法中除了含被排序对象指针外，还有两个整型变量指针，用于传递算法执行过程中的比较次数和移动次数。
取定一种排序对象的长度，由计算机产生一定量的伪随机数后，主函数调用各个排序子函数，但由于排序对象也是指向一维数组的指针，在调用一次一种排序算法后，通过形参对指针的改变，被排序对象已经是有序的了。当再次调用其他函数时有可能使比较和移动次数达到最大或最小，就失去了比较的意义。因此，本程序中采用了子函数另开辟空间，参数只起到一个复制值的作用，在每个子函数结束前用delete() 来释放申请排序对象的指针，避免程序出现内存耗尽的情况。
四、 源程序清单
主要包括： #include #include #include int a[501],b[501]; int len; //数组长度
void number()
1 { srand(time(0)); int i,t; printf("随机数长度： "); printf(" 1. 长度为20 "); printf(" 2. 长度为100 "); printf(" 3. 长度为500 "); printf("输入序号选择长度:"); scanf("%d",&t); switch(t){ case 1: n=20; for(i=1;i<=n;i++){ a[i]=rand()%1000+1; //1-1000的随机数
}break; case 2: n=100; for(i=1;i<=len;i++){ a[i]=rand()%1000+1; }break; case 3:n=500; for(i=1;i<=len;i++){ a[i]=rand()%1000+1; }break; } for(i=1;i<=len;i++) b[i]=a[i]; printf("随机生成的%d个数如下： ",len); for(i=1;i<=len;i++){ printf("%d ",a[i]); } printf(" "); } typedef struct{ int key; //关键字
}RecordNode; //排序结点类型 typedef struct{ RecordNode *record; int n; //排序对象的大小 //srand函数是初始化随机数的种子
2 }ElemType; //排序对象的类型 直接排序
void InsertSort ( ElemType A[], int n ) { int i, j; ElemType x; for ( i=1; i
x = A[i]; //准备插入第i个元素 for ( j=i-1; j>=0; j-- ) { //从第i-1个开始往前找插入点 if ( x.stn < A[j].stn ) A[j+1]=A[j]; else break; } A[j+1]=x; //插入 } for(i=1;i<=n;i++){ printf("%d ",a[i]); } printf(" "); printf(" "); printf("比较次数：%d次 ",i); printf("移动次数：%d次 ",j); } 直接选择排序
void SelectSort(ElemType A[], int n) { int i, j, k; ElemType x; for ( i=0; i<=n-2; i++ ) { //每一趟选择最小元素并与A[i]交换 k=i; for (j=i+1; j<=n-1; j++) //查找最小元素的下标 if (A[j].stn
3 for(i=1;i<=n;i++){ printf("%d ",a[i]); } printf(" "); printf(" "); printf("比较次数：%d次 ",i); printf("移动次数：%d次 ",j); } } 冒泡排序
void BubbleSort( ElemType A[], int n ) { int i, j, flag; //flag为交换标记 ElemType x; for (i=1; i<=n-1; i++) { // 最多n-1趟排序flag=0; //假设本次没有交换 for (j=n-1; j>=i; j--) //第i 趟 if ( A[j].stn < A[j-1].stn ) { flag=1; //出现交换
x=A[j]; A[j]=A[j-1]; A[j-1]=x; } if (flag==0) return; } for(i=1;i<=n;i++){ printf("%d ",a[i]); } printf(" "); printf(" "); printf("比较次数：%d次 ",i); printf("移动次数：%d次 ",j); } } Shell排序
void ShellSort(ElemType A[ ], int n,int dk)
{
int i,j,temp; ElemType x;
for(i=dk;i=i%dk)&&array[j]>temp;j-=dk)//比较与记录后移同时进行 A[j+dk]= A[j]; if(j!=i-dk) A[j+dk]=temp;//插入 } for(i=1;i<=n;i++){ printf("%d ",a[i]); } printf(" "); printf(" "); printf("比较次数：%d次 ",i); printf("移动次数：%d次 ",j); } }
快速排序
void QuickSort(ElemType A[ ], int s, int t) { //递归算法，对区间 A[s] ～A[t] 进行快速排序 int i=s+1, j=t; ElemType temp, x = A[s]; //第一个为基准元素 while ( i<=j ) { while ( i<=j && A[i].stn <= x.stn ) i++; //从左到右 while ( i<=j && A[j].stn >= x.stn ) j--; //从右到左 if ( i < j ) { temp=A[i]; A[i]=A[j]; A[j]=temp; i++; j--; } for(i=1;i<=n;i++){ printf("%d ",a[i]); } printf(" ");
5 printf(" "); printf("比较次数：%d次 ",i); printf("移动次数：%d次 ",j); } } if (s!=j) { //交换基准元素 A[s]=A[j]; A[j]=x; } if (s
void CreatHeap(ElemType A[], int n) { int i; for( i = (n–2)/2; i >= 0; i--) Sift(A, n, i); //调整A[i..n-1]使之为一个堆 } void Sift(ElemType A[], int n, int i) { // 调整A[i..n-1]成为一个堆(它的左右子树已是一个堆) ElemType x=A[i]; int j = 2 * i + 1; // j为i的左孩子 while (j <= n-1) { // i有左子树 if ( j +1 < n && A[j].stn < A[j+1].stn ) j++; // 使j指向左右孩子中排序码大的孩子
if ( x.stn < A[j].stn) { //使j指向左右孩子中排序码大的孩子 A[i]=A[j]; i=j; j=2*i+1; } else break; } A[i]=x; } void HeapSort(ElemType A[], int n) { //A为待排序表， n为表的长度 int i; ElemType x;
CreatHeap(A, n); // 把A建成一个堆
6 for (i = n - 1; i >= 1; i- -) { x = A[0]; //第0个元素与第i个元素交换 A[0] = A[i]; A[i] = x; Sift(A, i, 0); //调整A[0..i-1]使之为一个堆 } for(i=1;i<=n;i++){ printf("%d ",a[i]); } printf(" "); printf(" "); printf("比较次数：%d次 ",i); printf("移动次数：%d次 ",j); } } Void main() { int i,j,n,N=20; cout<<" 各排序方法选择结果： "; ElemType A[20]; for(j=0;j>A[j]; cout<<"排序前为："<7 cout<
算法的时间复杂度是什么?算法的空间复杂度是什么?为什么? 插入排序：稳定，时间复杂度 O(n^2) O(n2) 选择排序：不稳定，时间复杂度 O(n^2) O(n2) 冒泡排序：稳定，时间复杂度 O(n^2) O(n2) 希尔排序：不稳定，时间复杂度 平均时间 O(nlogn) 最差时间O(n^s) 1
程序调试及测试结果
主要包括：
选择长度为20的随机数，六种方法排序的结果。
从比较次数和移动次数可大致看出各排序方法的效率高低，后三种明显优于前三种
六、 结论
主要包括：
随机数产生方法：srand(time(0)) 就是给这个算法一个启动种子，也就是算法的随机种子数，有这个数以后才可以产生随机数,用1970.1.1至今的秒数，初始化随机数种子。Srand是种下随机种子数，你每回种下的种子不一样，用Rand得到的随机数就不一样。为了每回种下一个不一样的种子，所
9 以就选用Time(0)，Time(0)是得到当前时时间值(因为每时每刻时间是不一样的了)。
进行函数的参数传递时，如果传入一个地址，比传入一个struct效率要高，因为少了一个拷贝过程。 待改进的地方：很多步骤有重复用到，如把数组b赋值给a，定义Ccnt，Rcnt等，可以做个初始化的函数调用，省去重复的代码。可以增加其他排序方法进行效率比较。
七、 参考文献
[1] 唐国民, 王国钧. 数据结构 [M]. 北京:清华大学出版社, 2013: 213-238 [2] 张乃孝. 算法与数据结构——C语言描述[M]. 北京: 高等教育出版社, 2002 [3] 唐国民，王智群. C语言程序设计[M]. 北京:清华大学出版社, 2009:107-115 [4] 唐国民, 王国钧. 数据结构实验教程 [M]. 北京:清华大学出版社, 2013: 195-207 说明：
标为M的是书籍 标为D的为学位论文 标为J的为期刊 标为C的为会议论文
指导教师：邵
斌 日期：2016/6/5 实验成绩：
【数据结构的作业范文】相关文章：
数据结构作业一范文06-16
数据结构作业全范文06-16
东北木帮的组织结构与作业流程09-11
别让MsgBox中断了一些Background的处理作业数据库教程04-24
财务报表分析作业数据10-22
钢结构课程设计作业08-10
数据库基础与应用作业04-21
数据库实验内容与作业02-21
作业二数据库流程图04-09
钢结构设计图文作业08-10