谁能提供数不清据结构历年的考试答案

高是什么结构~

高是上下结构
一、晨的读音：gāo
二、汉字释义：
1. 由下到上距离大的，与“低”相对。 　
2. 高度。 　
3. 等级在上的。 　
4. 在一般标准或平均程度之上。 　
5. 声音响亮。 　
6. 敬辞，称别人的事物。 　
7. 热烈、盛大。 　
8. 显贵，道德水平高。 　
9. 宗族中最在上之称。 　
10. 酸根或化合物中比标准酸根多含一个氧原子的。 　
11. 姓。
三、汉字结构：上下结构
四、部首：高
五、相关词组：
高中、升高、高手、高楼、蹦高
扩展资料：
一、汉字笔画：
点、横、竖、横折、横、竖、横折钩、竖、横折、横

二、词语释义：
1、高中
〈动〉旧指科举考试中选，现也用于指考上高等学校。
2、升高
提高地位、程度或水平。
3、高手
在某方面技能突出的人。
晋黄门郎张协诗风流调达，实旷代之高手。
4、高楼
高层的住宅大楼或办公大楼。
5、蹦高
跳跃。

文章的结构，是文章部分与部分、部分与整体之间的内在联系和外部形式的统一。结构则是文章的“骨架”，是谋篇布局的手段，是运用材料反映中心思想的方法。常见的文章结构方式有四种。
1、并列式：文章各部分的内容没有主次轻重之分。例如培根的《轮读书》，三个部分分别谈到了读书的目的、读书的方法、读书的好处，就是采用并列的结构。
2、总分式：先总述，再分说。这种关系还可以演变为“分—总”或“总—分—总”的结构方式。例如《应有格物致知的精神》一文采用的就是“总—分—总”的结构：先总说“格物”“致知”就是指现代学术的基础，即实地的探察，也就是现在所谓的实验。然后先儒家对“格物”“致知”意义的曲解和对“格物”“致知”精神的埋没；再阐述科学发展为什么需要“格物”“致知”的精神。最后从正反两个方面总结“格物”“致知”精神的重要性。
3、对照式：文中两部分内容或进行对比，或用这部分内容烘托另一部分内容。例如鲁迅先生的《中国人失掉自信力了吗》一文，前一部分反面批驳了敌论中的论据不能证明论点，即中国人失掉的是“他信力”，发展的是“自欺力”，而不是“自信力”直接批驳了敌论；后一部分从正面列举事实，提出正确的论点，我们中国人没有失掉自信力，间接地批驳了敌论。
4、递进式：文章几部分内容逐层深入。例如《不求甚解》一文，先从“不求甚解”一词的来历谈起，分析了陶渊明的读书方法，首先要“好读书”，二是主张读书要会意。再从正反两个方面举例说明，读书应当重在读懂书本的精神实质，而不是寻章摘句。最后进一步从正反两个方面论证了读书“不求甚解”的重要性。

扩展资料：
小说结构：
小说结构是小说作品的形式要素，是指小说各部分之间的内部组织构造和外在表现形态。一部小说的结构过程，就是小说家根据自己对生活的认识，按照塑造形象和表现主题的要求，运用各种艺术表现手法，把一系列生活材料、人物、事件分轻重主次合理而匀称的加以组织和安排的过程，包括小说作品情节的处理、人物的配备、环境的安排以及整体的布置等。
参考资料：百度百科-结构方式（文章结构方式）

说明:
1. 本文是对严蔚敏《数据结构(c语言版)习题集》一书中所有算法设计题目的解决方案,主要作者为一具.以下网友:biwier,szm99,siice,龙抬头,iamkent,zames,birdthinking,lovebuaa等为答案的修订和完善工作提出了宝贵意见,在此表示感谢;
2. 本解答中的所有算法均采用类c语言描述,设计原则为面向交流、面向阅读,作者不保证程序能够上机正常运行(这种保证实际上也没有任何意义);
3. 本解答原则上只给出源代码以及必要的注释,对于一些难度较高或思路特殊的题目将给出简要的分析说明,对于作者无法解决的题目将给出必要的讨论.目前尚未解决的题目有: 5.20, 10.40;
4. 请读者在自己已经解决了某个题目或进行了充分的思考之后,再参考本解答,以保证复习效果;
5. 由于作者水平所限,本解答中一定存在不少这样或者那样的错误和不足,希望读者们在阅读中多动脑、勤思考,争取发现和纠正这些错误,写出更好的算法来.请将你发现的错误或其它值得改进之处向作者报告: yi-ju@263.net

第一章 绪论
1.16
void print_descending(int x,int y,int z)//按从大到小顺序输出三个数
{
scanf("%d,%d,%d",&x,&y,&z);
if(x<y) x<->y; //<->为表示交换的双目运算符,以下同
if(y<z) y<->z;
if(x<y) x<->y; //冒泡排序
printf("%d %d %d",x,y,z);
}//print_descending
1.17
Status fib(int k,int m,int &f)//求k阶斐波那契序列的第m项的值f
{
int tempd;
if(k<2||m<0) return ERROR;
if(m<k-1) f=0;
else if (m==k-1 || m==k) f=1;
else
{
for(i=0;i<=k-2;i++) temp[i]=0;
temp[k-1]=1;temp[k]=1; //初始化
sum=1;
j=0;
for(i=k+1;i<=m;i++,j++) //求出序列第k至第m个元素的值
temp[i]=2*sum-temp[j];
f=temp[m];
}
return OK;
}//fib
分析: k阶斐波那契序列的第m项的值f[m]=f[m-1]+f[m-2]+......+f[m-k]
=f[m-1]+f[m-2]+......+f[m-k]+f[m-k-1]-f[m-k-1]
=2*f[m-1]-f[m-k-1]
所以上述算法的时间复杂度仅为O(m). 如果采用递归设计,将达到O(k^m). 即使采用暂存中间结果的方法,也将达到O(m^2).
1.18
typedef struct{
char *sport;
enum{male,female} gender;
char schoolname; //校名为'A','B','C','D'或'E'
char *result;
int score;
} resulttype;
typedef struct{
int malescore;
int femalescore;
int totalscore;
} scoretype;
void summary(resulttype result[ ])//求各校的男女总分和团体总分,假设结果已经储存在result[ ]数组中
{
scoretype score[MAXSIZE];
i=0;
while(result[i].sport!=NULL)
{
switch(result[i].schoolname)
{
case 'A':
score[ 0 ].totalscore+=result[i].score;
if(result[i].gender==0) score[ 0 ].malescore+=result[i].score;
else score[ 0 ].femalescore+=result[i].score;
break;
case 'B':
score[ 0 ].totalscore+=result[i].score;
if(result[i].gender==0) score[ 0 ].malescore+=result[i].score;
else score[ 0 ].femalescore+=result[i].score;
break;
…… …… ……
}
i++；
}
for(i=0;i<5;i++)
{
printf("School %d:\n",i);
printf("Total score of male:%d\n",score[i].malescore);
printf("Total score of female:%d\n",score[i].femalescore);
printf("Total score of all:%d\n\n",score[i].totalscore);
}
}//summary
1.19
Status algo119(int a[ARRSIZE])//求i!*2^i序列的值且不超过maxint
{
last=1;
for(i=1;i<=ARRSIZE;i++)
{
a[i-1]=last*2*i;
if((a[i-1]/last)!=(2*i)) reurn OVERFLOW;
last=a[i-1];
return OK;
}
}//algo119
分析:当某一项的结果超过了maxint时,它除以前面一项的商会发生异常.
1.20
void polyvalue()
{
float temp;
float *p=a;
printf("Input number of terms:");
scanf("%d",&n);
printf("Input value of x:");
scanf("%f",&x);
printf("Input the %d coefficients from a0 to a%d:\n",n+1,n);
p=a;xp=1;sum=0; //xp用于存放x的i次方
for(i=0;i<=n;i++)
{
scanf("%f",&temp);
sum+=xp*(temp);
xp*=x;
}
printf("Value is:%f",sum);
}//polyvalue

第二章 线性表
2.10
Status DeleteK(SqList &a,int i,int k)//删除线性表a中第i个元素起的k个元素
{
if(i<1||k<0||i+k-1>a.length) return INFEASIBLE;
for(count=1;i+count-1<=a.length-k;count++) //注意循环结束的条件
a.elem[i+count-1]=a.elem[i+count+k-1];
a.length-=k;
return OK;
}//DeleteK
2.11
Status Insert_SqList(SqList &va,int x)//把x插入递增有序表va中
{
if(va.length+1>va.listsize) return ERROR;
va.length++;
for(i=va.length-1;va.elem[i]>x&&i>=0;i--)
va.elem[i+1]=va.elem[i];
va.elem[i+1]=x;
return OK;
}//Insert_SqList
2.12
int ListComp(SqList A,SqList B)//比较字符表A和B,并用返回值表示结果,值为1,表示A>B;值为-1,表示A<B;值为0,表示A=B
{
for(i=1;i<=A.length&&i<=B.length;i++)
if(A.elem[i]!=B.elem[i])
return A.elem[i]>B.elem[i]?1:-1;
if(A.length==B.length) return 0;
return A.length>B.length?1:-1; //当两个字符表可以互相比较的部分完全相同时,哪个较长,哪个就较大
}//ListComp
2.13
LNode* Locate(LinkList L,int x)//链表上的元素查找,返回指针
{
for(p=l->next;p&&p->data!=x;p=p->next);
return p;
}//Locate
2.14
int Length(LinkList L)//求链表的长度
{
for(k=0,p=L;p->next;p=p->next,k++);
return k;
}//Length
2.15
void ListConcat(LinkList ha,LinkList hb,LinkList &hc)//把链表hb接在ha后面形成链表hc
{
hc=ha;p=ha;
while(p->next) p=p->next;
p->next=hb;
}//ListConcat
2.16
见书后答案.
2.17
Status Insert(LinkList &L,int i,int b)//在无头结点链表L的第i个元素之前插入元素b
{
p=L;q=(LinkList*)malloc(sizeof(LNode));
q.data=b;
if(i==1)
{
q.next=p;L=q; //插入在链表头部
}
else
{
while(--i>1) p=p->next;
q->next=p->next;p->next=q; //插入在第i个元素的位置
}
}//Insert
2.18
Status Delete(LinkList &L,int i)//在无头结点链表L中删除第i个元素
{
if(i==1) L=L->next; //删除第一个元素
else
{
p=L;
while(--i>1) p=p->next;
p->next=p->next->next; //删除第i个元素
}
}//Delete
2.19
Status Delete_Between(Linklist &L,int mink,int maxk)//删除元素递增排列的链表L中值大于mink且小于maxk的所有元素
{
p=L;
while(p->next->data<=mink) p=p->next; //p是最后一个不大于mink的元素
if(p->next) //如果还有比mink更大的元素
{
q=p->next;
while(q->data<maxk) q=q->next; //q是第一个不小于maxk的元素
p->next=q;
}
}//Delete_Between
2.20
Status Delete_Equal(Linklist &L)//删除元素递增排列的链表L中所有值相同的元素
{
p=L->next;q=p->next; //p,q指向相邻两元素
while(p->next)
{
if(p->data!=q->data)
{
p=p->next;q=p->next; //当相邻两元素不相等时,p,q都向后推一步
}
else
{
while(q->data==p->data)
{
free(q);
q=q->next;
}
p->next=q;p=q;q=p->next; //当相邻元素相等时删除多余元素
}//else
}//while
}//Delete_Equal
2.21
void reverse(SqList &A)//顺序表的就地逆置
{
for(i=1,j=A.length;i<j;i++,j--)
A.elem[i]<->A.elem[j];
}//reverse
2.22
void LinkList_reverse(Linklist &L)//链表的就地逆置;为简化算法,假设表长大于2
{
p=L->next;q=p->next;s=q->next;p->next=NULL;
while(s->next)
{
q->next=p;p=q;
q=s;s=s->next; //把L的元素逐个插入新表表头
}
q->next=p;s->next=q;L->next=s;
}//LinkList_reverse
分析:本算法的思想是,逐个地把L的当前元素q插入新的链表头部,p为新表表头.
2.23
void merge1(LinkList &A,LinkList &B,LinkList &C)//把链表A和B合并为C,A和B的元素间隔排列,且使用原存储空间
{
p=A->next;q=B->next;C=A;
while(p&&q)
{
s=p->next;p->next=q; //将B的元素插入
if(s)
{
t=q->next;q->next=s; //如A非空,将A的元素插入
}
p=s;q=t;
}//while
}//merge1
2.24
void reverse_merge(LinkList &A,LinkList &B,LinkList &C)//把元素递增排列的链表A和B合并为C,且C中元素递减排列,使用原空间
{
pa=A->next;pb=B->next;pre=NULL; //pa和pb分别指向A,B的当前元素
while(pa||pb)
{
if(pa->data<pb->data||!pb)
{
pc=pa;q=pa->next;pa->next=pre;pa=q; //将A的元素插入新表
}
else
{
pc=pb;q=pb->next;pb->next=pre;pb=q; //将B的元素插入新表
}
pre=pc;
}
C=A;A->next=pc; //构造新表头
}//reverse_merge
分析:本算法的思想是,按从小到大的顺序依次把A和B的元素插入新表的头部pc处,最后处理A或B的剩余元素.
2.25
void SqList_Intersect(SqList A,SqList B,SqList &C)//求元素递增排列的线性表A和B的元素的交集并存入C中
{
i=1;j=1;k=0;
while(A.elem[i]&&B.elem[j])
{
if(A.elem[i]<B.elem[j]) i++;
if(A.elem[i]>B.elem[j]) j++;
if(A.elem[i]==B.elem[j])
{
C.elem[++k]=A.elem[i]; //当发现了一个在A,B中都存在的元素,
i++;j++; //就添加到C中
}
}//while
}//SqList_Intersect
2.26
void LinkList_Intersect(LinkList A,LinkList B,LinkList &C)//在链表结构上重做上题
{
p=A->next;q=B->next;
pc=(LNode*)malloc(sizeof(LNode));
C=pc;
while(p&&q)
{
if(p->data<q->data) p=p->next;
else if(p->data>q->data) q=q->next;
else
{
s=(LNode*)malloc(sizeof(LNode));
s->data=p->data;
pc->next=s;pc=s;
p=p->next;q=q->next;
}
}//while
}//LinkList_Intersect
2.27
void SqList_Intersect_True(SqList &A,SqList B)//求元素递增排列的线性表A和B的元素的交集并存回A中
{
i=1;j=1;k=0;
while(A.elem[i]&&B.elem[j])
{
if(A.elem[i]<B.elem[j]) i++;
else if(A.elem[i]>B.elem[j]) j++;
else if(A.elem[i]!=A.elem[k])
{
A.elem[++k]=A.elem[i]; //当发现了一个在A,B中都存在的元素
i++;j++; //且C中没有,就添加到C中
}
else {i++;j++;}
}//while
while(A.elem[k]) A.elem[k++]=0;
}//SqList_Intersect_True
2.28
void LinkList_Intersect_True(LinkList &A,LinkList B)//在链表结构上重做上题
{
p=A->next;q=B->next;pc=A;
while(p&&q)
{
if(p->data<q->data) p=p->next;
else if(p->data>q->data) q=q->next;
else if(p->data!=pc->data)
{
pc=pc->next;
pc->data=p->data;
p=p->next;q=q->next;
}
}//while
}//LinkList_Intersect_True
2.29
void SqList_Intersect_Delete(SqList &A,SqList B,SqList C)
{
i=0;j=0;k=0;m=0; //i指示A中元素原来的位置,m为移动后的位置
while(i<A.length&&j<B.length&& k<C.length)
{
if(B.elem[j]<C.elem[k]) j++;
else if(B.elem[j]>C.elem[k]) k++;
else
{
same=B.elem[j]; //找到了相同元素same
while(B.elem[j]==same) j++;
while(C.elem[k]==same) k++; //j,k后移到新的元素
while(i<A.length&&A.elem[i]<same)
A.elem[m++]=A.elem[i++]; //需保留的元素移动到新位置
while(i<A.length&&A.elem[i]==same) i++; //跳过相同的元素
}
}//while
while(i<A.length)
A.elem[m++]=A.elem[i++]; //A的剩余元素重新存储。
A.length=m;
}// SqList_Intersect_Delete
分析:先从B和C中找出共有元素,记为same,再在A中从当前位置开始, 凡小于same的
元素均保留(存到新的位置),等于same的就跳过,到大于same时就再找下一个same.
2.30
void LinkList_Intersect_Delete(LinkList &A,LinkList B,LinkList C)//在链表结构上重做上题
{
p=B->next;q=C->next;r=A-next;
while(p&&q&&r)
{
if(p->data<q->data) p=p->next;
else if(p->data>q->data) q=q->next;
else
{
u=p->data; //确定待删除元素u
while(r->next->data<u) r=r->next; //确定最后一个小于u的元素指针r
if(r->next->data==u)
{
s=r->next;
while(s->data==u)
{
t=s;s=s->next;free(t); //确定第一个大于u的元素指针s
}//while
r->next=s; //删除r和s之间的元素
}//if
while(p->data=u) p=p->next;
while(q->data=u) q=q->next;
}//else
}//while
}//LinkList_Intersect_Delete
2.31
Status Delete_Pre(CiLNode *s)//删除单循环链表中结点s的直接前驱
{
p=s;
while(p->next->next!=s) p=p->next; //找到s的前驱的前驱p
p->next=s;
return OK;
}//Delete_Pre
2.32
Status DuLNode_Pre(DuLinkList &L)//完成双向循环链表结点的pre域
{
for(p=L;!p->next->pre;p=p->next) p->next->pre=p;
return OK;
}//DuLNode_Pre
2.33
Status LinkList_Divide(LinkList &L,CiList &A,CiList &B,CiList &C)//把单链表L的元素按类型分为三个循环链表.CiList为带头结点的单循环链表类型.
{

---

数据结构 考试题（你要的算法是只要描述还是要上机可以通过的语句啊????先回答第8题吧。1、38,49,65,97,76,13,27,492、38,49,65,97,76,13,27,493、38,49,65,97,76,13,27,494、38,49,65,76,97,13,27,495、13,38,49,65,76,97,27,496、13,27,38,49,65,76,97,497、13,27,38,49,49,65,76,97完成。)

数据结构 考试题（你要的算法是只要描述还是要上机可以通过的语句啊???? 先回答第8题吧。 1、38,49,65,97,76,13,27,49 2、38,49,65,97,76,13,27,49 3、38,49,65,97,76,13,27,49 4、38,49,65,76,97,13,27,49 5、13,38,49,65,76,97,27,49 6、13,27,38,49,65,76,97,49 7、13,27,38,49,49,65,76,97 完成。)

数据结构考试 急 谢谢!（二叉树中结点的度可以为0,1,2。 16题 错误。 17题 错误。根节点没有右子树。 18题 正确。 19题 错误。非线性数据结构可以顺序存储,比如图的邻接矩阵存储。 20题 错误。如果图中有结点的自回路,则邻接矩阵主对角线上有数据。 有一些问题有争议,还可以讨论,关于广义表的问题,没...)

数据结构考试题（选A1入栈2入栈3入栈3出栈2出栈4入栈5入栈5出栈6入栈6出栈4出栈1出栈就得出325641)

数据结构考题（next>next; 4、数据结构DS(Data Struct)可以被形式地定义为DS=(D,R),其中D是(B)有限集合,R是D上的关系有限集合。A算法B数据元素C数据操作D数据对象 5、不带头结点的单链表head为空的判定条件是(A)。Ahead= =NULLBhead>next= =NULLChead>next= =headDhead!=N...)

数据结构考试试题（去百度文库,查看完整内容> 内容来自用户:廖德娟_2011 数据结构辅导试题一 一、简答问题: 1.四类数据结构 2.线性结构与非线性结构有何差别? 3.简述算法的定义与特性。 4.设有1000个无序元素,仅要求找出前10个最小元素,在下列排序方法中(归并排序、基数排序、快速排序、堆排序、...)

求“数据结构”的考试重点!（普及组的话栈与队列这种线性数据结构,图这种的只要知道Floyd、dijkstra这=几=个算法,还有拓扑排序吧 )

关于数据结构考试的问题!急急急!!!（2.2 1100 计算过程:((3*7+5)1)*4+1000 2.3 O(m*n) 3.1 void delete(node *head,elemtype min,elemtype max) { node *p,*q,*r; if(head==NULL) return; else { p=head>next; while(p!=NUll&&p>data<=min) { q=p; p=p>next; } while(p!=NULL&&p>data<=max) { r=...)

数据结构考题（next; 4、数据结构DS(Data Struct)可以被形式地定义为DS=(D,R),其中D是(B)有限集合,R是D上的关系有限集合。 A算法 B数据元素 C数据操作 D数据对象 5、不带头结点的单链表head为空的判定条件是(A)。 Ahead= =NULL Bhead>next= =NULL Chead>next= =head Dhead!=NUL...)