数据结构导论

数据结构导论const maxsize=顺序表的容量；

typedf struct

{datatype data[maxsize];

int last;

{sqlist;

sqlist L;

顺序表的插入算法：

void insert_sqlist(sqlist L,datetype x,int i)

{

if(https://www.doczj.com/doc/471213446.html,st==maxsize)error(…表潢?)；

if((i<1)||(i>https://www.doczj.com/doc/471213446.html,st+1))error(…非法位置?)；

for(j=https://www.doczj.com/doc/471213446.html,st;j=i;j--)

L.data[j]=L.data[j-1];

L.data[i-1]=X;

https://www.doczj.com/doc/471213446.html,st=https://www.doczj.com/doc/471213446.html,st+1

}

顺序表的删除算法：

void delete_sqlist(sqlist L,int i);

{

if((i<1)||(i>https://www.doczj.com/doc/471213446.html,st)) error(非法位置)；

for(j=i+1;j=https://www.doczj.com/doc/471213446.html,st;j++)

L.data[j-2]=L.data[j-1];

https://www.doczj.com/doc/471213446.html,st=https://www.doczj.com/doc/471213446.html,st-1

}

顺序表的查找算法：

int locate_sqlist(sqlist L,datatype X)

{

i=1;

while((i<=https://www.doczj.com/doc/471213446.html,st)&&(L.data[i-1]!=x))

i++;

if(i<=https://www.doczj.com/doc/471213446.html,st) return(i)

else return(0)

}

单链表类型定义

typedef struct node *pointer;

struct node

{datatype data;

pointer next;

};

typedef pointer lklist;

lklist initiate_lklist()

{

t=malloc(size);

t->next=NULL;

return(t);

}

单链表求表长：

int length_lklist(lklist head)

{

p=head;

j=0;

while(p->next!=null)

{

p=p->next; 单链表插入：

j++; void insert_lklist(lklist head,datatype x,int i) } {

return(j); p=find_lklist(head,i-1);

} if(p= =null)

按序号查找：error(…不存在第i个位置?)

pointer find_lklist(lklist head,int i) else

{ {

p=head;j=0; s=malloc(size);s->data=x;

while(p->next!=null)&&(jnext=p->next;

{ p->next=s;

p=p->next;j++; }

} }

f(i= =j)return(p);

else return(null);

}

单链表查找：单链表删除：

int locate_lklist(lklist head,datatype x) void delete_lklist(lklist head; int i)

{ {

p=head;j=0; p=find_lklist(head,i-1);

while((p->next!=null)&&(p->data!=x)) if((p!=null)&&(p->next!=null))

{ {

p=p->next;j++; q=p->next;

} p->next=q->next;

if p->data= =x return(j); free(q);

else return (0); }

} else error(…不存在第i个结点?)

}

typedef struct dnode *dpointer; 双链表删除：

struct dnode p->prior->next=p->next;

{ datatype data; p->next->prior=p->prior;

dpointer prior,next; 双链表插入：

} 1、q->prior=p; 3、p->next->prior=q; typedef dpointer dlklist; 2、q->next=p->next; 4\p->next=q;

顺序找类型的定义：

#define sqstack_maxsize 6 退桡：

typedef struct sqstack int pop(sqstackTop *sq,DataType *x)

{ DataType data[sqstack_maxsize]; {if (sq->top= =0)

int top; {error(“下溢”); return(0);}

}sqstackTp; else

进桡：{ *x=sq->data[sq->top];

int push(sqstackTp *sq,DataType x) sq->top--;

{ return(1);}

if(sq->top= =sqstack_maxsize-1 );

{error(桡满)；return 0;} 取顶元素：

else {sq->top ++; int GetTop(sqstackTp *sq,DataType *x) sq->data[sq->top]=x; { if(sq->top= =0) return 0;

return (1); esle

} { *x=sq->data[sq->top];

}; return (1);

判桡空：}

int Emptystack(sqStackTp sq) }

{ if(sq.top= =0)

return(1);

else return(0);

}

链桡的类型定义：退桡：

typedef struct node int pop(LstackTp *ls,DataType *x) { {LstackTp *p;

DataType data; if(ls!=null)

Struct node *next; {p=ls;

}LstackTp; *x=p->data;

进桡：ls=ls->next;

void push(LstackTp *ls,DataType x) free(p);

{LstackTp *p; return 1;

p=(LstackTp *)malloc(sizeof(LstackTp)); }else return 0;

p->data=x; }

p->next=ls;

ls=p;

}

写一个算法，借助桡将一个带头结点的单链表倒置。计算阶乘函数的递归算法：Void reverse_list(LinkedListTP *head) long f(int n)

{LStackTP ls,p; { if(n= =0)

DataType x; return (1); IinitStack(&ls); else return(n*f(n-1)); P=head->next; }

While(p!=null)

{ push (&ls,p->data);

p=p->next;}

p=head->next;

while(! EmptyStack(&ls))

{ pop(&ls,&x);

p->data=x;

p=p->next;}

}

基于三元组的稀疏矩阵转置处理算法：

Trans_sparmat(SpMatrixTp a,spMatrixTp *b)

{

(*b).mu=a.nu;(*b).nu=a.mu;(*b).tu=a.tu

if (a.tu)

{

q=1;

for (col=1;co;<=a.nu;col++)

for (p=1;p<=a.tu;p++)

if(a.data[p].j= =col)

{

(*b).data[q].i=a.data[p].j;

(*b).data[q].j=a.data[p].i;

(*b).data[q].v=a.data[p].v;

q++;

}

}

return (1);

}

快速转置算法如下：

Fast_Trans_Sparmat(SpMatrixTp a,SpMatrixTp *b)

{ (*b).mu=a.nu; (*b).nu=a.mu; (*b).tu=a.tu;

if (a..tu)

{ for (col=1;col<=a.nu;col++) num[col]=0;

for(t=1;t<=a.tu;t++) num[a.data[t].j]++;

cpot[1]=1;

for(col=2;col<=a.nu;col++)

cpot[col]=cpot[col-1]+num[col-1];

for(p=1;p<=a.tu;p++)

{col=a.data[p].j;q=cpot[col];

(*b).data[q].i=a.data[p].j;

(*b).data[q].j=a.data[p].i;

(*b).data[q].v=a.data[p].v;

cpot[col]++;

}

}

} 算法的时间复杂度为：O（nu+tu）

先根遍历算法：中根遍历算法：

void preorder(bitreptr r) void preorder(bitreptr r)

{ if(r!=null) { if(r!=null)

{ visit(r); { inorder(r->lchild);

preorder(r->lchild); visit(r);

preorder(r->rchild); inorder(r->rchild);

} }

} }

后根遍历算法：将计算阶乘函数n!的递归算法转换成非递归算法：void preorder(bitreptr r) long f(int n)

{ if(r!=null) {

{ postorder(r->lchild); if(n= =0) return(1)

postorder(r->rchild); else return (n*f(n-1));

visit(r); }

} 写出计算下列斐波那齐函数的递归算法并消除递归：} 0 n=0

计算n!的循环算法：Fib(n)= 1 n=1

int f1(int n) Fib(n-1)+Fib(n-2) n>1

{ y=1; int b(int n)

for(i=1;i<=n;i++) { if(n= =0) return(0);

y=y*i; else if(n= =1) return(1);

return(y); else return(b(n-1)+b(n-2));

} }

先根遍历非递归算法的非形式

while(桡不空)

{ s=桡顶元素；退桡；

while(s!=null)

{ visit(s);

s->rchild 进桡；

s=s->lchild;

}

}

先根遍历的非递归算法：哈夫曼算法：

void preorderl(bitreptr t) void Huffman (int k, float W[t],hftree T)

{ bitreptr stack[stacksize]; { int i,j,x,y;

int top; float m,n;

top=0;stack[top]=t; for (i=0;i<2*k-1;i++)

while(top>=0) { T[i].parent=-1; T[i].lchild=-1; T[i].rchild=-1; { s=stack[top]; if(i

top--; else T[i].wt=0

while(s!=null) }

{ visit(s); for (i=0;i

top++; stack[top]=s->rchild; { x=0;y=0;m=maxint;n=maxint;

s=s->lchild; for(j=0;j

} if((T[j].wt

} { n=m;y=x;m=T[j].wt;x=j;}

} else if((T[j].wt

判定树对应的分类算法如下：{ n=T[j].wt;y=j;}

char classify(float x) T[x].parent=k+i;T[y].parent=k+i;

{ if(x<5) return (…E?); T[k+i].wt=m+n;

else if(x<6) return (…D?); T[k+i].lchild=x;T[k+i].rchild=y;

else if (x<7) return (…C?); }

else if (x<8) return (…B?); }

else return (…A?);

}

无向网邻接矩阵的建立算法：建立邻接表的算法：

void CreatGraph(GraphTp *ga) CreateAdjlist(GraphTp *ga)

{ int i.j,n,e,w; {int n,e,,I,j,k;

char ch; ArcNodeTp *p;

scanf(“%d %d,&n,&e); scanf(“%d %d”,n,e);

ga->vexnum=n; ga->vexnum=n;ga->arcnum=e;

ga->arcnum=e; for(i=0;i

for(i=0;ivexnum;i++) {ga->dajlis[i].vertex=i;

{scanf(“%c”,&ch); {ga->adjlis[i].firstarc=null;

ga->vexs[i]=ch;} for(k=0;k

for(i=0;ivexnum;i++) {scanf(“%d %d,&i,&j”);

for(j=0;jvexnum;j++) p=(ArcNodeTP *)malloc(sizeof(ArcNodeTP));

ga->arcs[i][j]=INT_MAX; p->adjvex=j;

for(k=0;karcnum;k++) p->next=ga->adjlis[i].firstarc;

{ ga->adjlis[i].firstarc=p;

scanf(“%d %d %d”,&i,&j,&w); }

ga->arcs[i][j]=w; }

ga->arcs[j[i]=w;

}

}

连通图的深度优先搜索的算法：邻接表的深度优先搜索算法：

Dfs(GraphTp g, int v) Dfs(GraphTp g, int v)

{ {ArcNodeTp *p;

访问v; printf(“%d”,v);

visited[v]=1; visited[v]=1;

找出g中的v第一个邻接点w; p=g.adjlist[v].firstarc;

while w存在while(p!=null)

{ if w未被访问Dfs(g,w); {if(! Visited[p->adjcex]) Dfs(g,p->adjvex);

w=g中v的下一个邻接点；p=p->nextarc;

} }

} }

若图的存储结构为邻接表，队列采用链队列相应的广度优先搜索算法如下：

Bfs(GraphTp g,int v)

{QueptrTp Q;

ArcNodeTp *p;

InitQueue(&Q);

Printf(“%d”,v);

Visited[v]=1;

EnQueue(&Q,v);

While(!EmptyQueue(Q))

{OutQueue(&Q,&v);

p=g.adjlist[v].firstarc;

while(p!=null)

{if (!visited[p->adjvex])

{printf(“%d”,p->adjvex);

visited[p->adjvex]=1;

EnQueue(&Q,p->adjvex);

}

}

}

以邻接表为存储结构，通过调用深度优先搜索算法实现的计算连通分量的算法：

int visited[vnum]; printf(“共有%d个连通分量\n”,count); Count_Component(GraphTp g) }

{int count;

for(v=0;v

visited[v]=0;

count=0;

for(v=0;v

if(! Visited[v])

{count ++;

printf(“连通分量%包含以下顶点:”,count);

Dfs(g,v);

Printf(“\n”);

}

prim算法（求最小生成树）

数据结构定义如下：

struct{ int adjvex; v=j;}

int lowcost; printf(“%d %d\n”,closedge[v].adjvex,v);

{ closedge[Vnum] closedge[v].lowcost=MAX_INT;

算法如下：for(j=0,j

prim(GraphTp g,int u) if(g.adjlist[v][j]

{int v,k,j,min; {closedge[j].lowcost=g.adjlist[v][j];

for(v=0;v

if(v!=u) }

{closedge[v].adjvex=u; }

closedge[v].lowcost=g.adjlist[u,v]; } prim算法的时间复杂度为O（n2）}

closedge[u].lowcost=INT_MAX;

for(k=0;k

{min=closedge[k].lowcost;

v=k;

for(j=o;j

if(closedge[j].lowcost

{min=closedge[j].lowcost;

拓朴排序算法如下：

Top_sort(GraphTp g) if(m

ArcNodeTp *p; 时间复杂度为：O（n+e）

int m,i,v;

InitStack(S);

for(i=0;i

if(g.adjlist[i].in= =0)

push(s,i);

m=0;

while(! EmptyStack(S))

{Pop(S,&v);

printf(“%d”,v);

m++;

p=g.adjlist[i].firstarc;

while(p!=null)

{(g.adjlist[p->adjvex].in --;

if(g.adjlist[p->adjvex].in= =0)

push(S,p->adjvex);

p=p->nextarc;

}

}

二分查找算法：

int binsearch(sqtable R,keytype K)

{ low=1; hig=R.n;

while(low<=hig)

{ mid=(low+hig)/2;

switch

{ case K= =R.item[mid].key: return(mid);

case K

case K>R.item[mid].key: low=low+1;break;

}

}

return(0);

}

二叉排序树上的查找：

bitreptr search-bst(bitreptr t, keytype k )

{ if(t= =null)return(null);

else switch

{ case t->key= =k:return(t);

case t->key>k:return(search-bst(t->lchild,k));

case t->keyrchild,k));

}

}

二叉排序树的插入：

bitreptr insert-bst(keytype k,bitreptr t)

{ if(t= =null)

{ p=malloc(sizeof(btnode));

p->key=k;

p->lchild=null;

p->rchild=null;

return(p);

}

else switch

{ case t->key= =k; return(t);

case t->key>k: t->lchild=insert-bst(k,t->lchild);

return(t);

case t->keyrchild=insert-bst(k,t->rchild);

return(t);

}

}

开散列表的类型定义：插入：

typedef struct tagnode void insert-openhash(keytype k,openhash HP) { keytype key; { if(research-openhash(K,HP)= =null) struct tagnode *next; { i=H(K);

……q=malloc(size) q->key=k;

}* pointer,node; q->next=HP[i]=q;

typedef pointer openhash[n]; }

查找：}

pointer research-openhash(kettype k,openhash HP)

{ i=H(K);

p=HP[i];

while((p!=null)&&(p->key!=k))p=p->next;

return(p);

}

删除：

void delete-openhash(keytype k,openhash HP)

{ i=H(K);

if(HP[i]= =null) return; 直接插入排序算法：

p=HP[i]; void straightsort(list r);

if(p->key= =k) {

{ HP[i]=p->next; free(p);return; for(i=2;i=n;i++)

while(p->next!=null) {

{ q=p;p=p->next; [r[0]=r[i]];

if(p->key= =k) j=i-1;

{ q->next=p->next;delete(p);return; } while(r[0].key

} {

} r[j+1]=r[j];

闭散列表查找：j- -;

int search-closehash(kteytype K,closehash HL) }

{ d=H(K); r[j+1]=r[0];

i=d; }

while(HL[i].key!=K)&&(i!=d-1)) }

i=(i+1)/m;

if(HL[I].key= =K) return(i);

else return(-1);

}

目泡排序算法：

void bubblesort(int n,list r) { } { flag=0; } for(i=1;i=n-1,i++) p=r[j]

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

flag=1; r[j+1]=p;

for(j=1;j=n-i;j++) }

if(r[j+1].key

快速排序算法：完整的快速排序可写成递归算法：void quickpass(list r,int h,int p,int i) void quicksort(list r,int s,int t)

{ {

i=h;j=p;x=r[i]; if(s

while(i

{ quickpass(r,s,t,i);

while((r[j].key>=x.key)&&(i

j--; quickpass(r,i+1,t);

if(i

{ }

r[i]=r[j];i++;

while((r[i].key<=x.key)&&(i

i++; void heapsort(list r)

if(i

{ for(i=n/2;i=1;i--)

r[j]=r[i];j--; sift(r,i,n);

} for(i=n;i=2;i--)

} {

} swap(r[1],r[i]);

r[i]=x; sift(r,1,i-1)

} }

直接选择排序算法：}

void select(list r,int n)

{

for(i=1;i=n-1;i++) 二路归并排序算法：

{ void msort(list a,int n)

k=i; {

for(j=i+1;j=n;j++) h=1;

if(r[j].key

k=j; {

if(k!=i) mpass(a,b,n,h);

swap(r[k].r[i]); h*=2;

} mpass(b,a,n,h);

} h*=2;

}

}

全国自学考试数据结构导论试题及答案(4套)

全国2011年1月自学考试数据结构导论试题 课程代码：02142 一、单项选择题(本大题共15小题，每小题2分，共30分) 在每小题列出的四个备选项中只有一个是符合题目要求的，请将其代码填写在题后的括号内。错选、多选或未选均无分。 1.在顺序表中查找第i个元素，时间效率最高的算法的时间复杂度为( ) A.O(1) B.O(n) C.O(log2n) D.O(n) 2.树形结构中，度为0的结点称为( ) A.树根 B.叶子 C.路径 D.二叉树 3.已知有向图G=(V,E)，其中V={V1,V2,V3,V4,V5,V6,V7}，E={，，，，,，，,，}，则图G的拓扑序列是 ( ) A.V1,V3,V4,V6,V2,V5,V7 B.V1,V3,V2,V6,V4,V5,V7 C.V1,V3,V4,V5,V2,V6,V7 D.V1,V2,V5,V3,V4,V6,V7 4.有关图中路径的定义，表述正确的是( ) A.路径是顶点和相邻顶点偶对构成的边所形成的序列 B.路径是不同顶点所形成的序列 C.路径是不同边所形成的序列 D.路径是不同顶点和不同边所形成的集合 5.串的长度是指( ) A.串中所含不同字母的个数 B.串中所含字符的个数 C.串中所含不同字符的个数 D.串中所含非空格字符的个数 6.组成数据的基本单位是( ) A.数据项 B.数据类型 C.数据元素 D.数据变量 7.程序段 i=n；x=0； do{x=x+5*i；i--；}while （i>0）； 的时间复杂度为( ) A.O（1） B.O（n） C.O（n2） D.O(n3) 8.与串的逻辑结构不同的 ．．．数据结构是( ) A.线性表 B.栈 C.队列 D.树

自考数据结构导论复习资料

数据结构导论复习 第一章概论 1．数据：凡能被计算机存储、加工处理的对象。 2．数据元素：是数据的基本单位，在程序中作为一个整体而加以考虑和处理 3．数据项：又叫字段或域，它是数据的不可分割的最小标识单位。 4．逻辑结构需要注意的几点： ①逻辑结构与数据元素本身的内容无关 ②逻辑结构与数据元素相对位置无关 ③逻辑结构与所有结点的个数无关 5．数据元素间逻辑关系是指数据元素之间的关联方式或称“领接关系”。 6．四类基本逻辑结构（集合、线性结构、树形结构和图形结构）的不同特点？ 答：集合中任何两个结点之间都没有逻辑关系，组织形式松散； 线性结构中结点按逻辑关系依次排列形成一条“锁链”； 树形结构具有分支、层次特性，其形态有点像自然界中的树； 图状结构最复杂，其中的各个结点按逻辑关系互相缠绕，任何两个结点都可以领接。 7．运算是在逻辑结构层次上对处理功能的抽象

8．基本运算的含义？ 答：假如是S上的一些运算的集合，是的一个子集，使得中每一运算都可以“归约”为中的一个或多个运算，而中任一运算不可归约为别的运算，则称中运算为基本运算 9．数据结构是指由一个逻辑结构S和S上的一个基本运算集构成的整体（S ，）。 10．数据结构涉及数据表示和数据处理两个方面 11．存储结构的含义和四种基本存储方式的基本思想？ 答：存储结构是指按照逻辑结构的要求建立的数据的机内表示称为存储结构。 一个存储结构应包含三个主要的部分：存储结点、机内表示和附加设施。 存储结构包括四种存储方式，顺序存储方式、链式存储方式、索引存储方式和散列存储方式。 12．运算实现与运算的联系与区别？ 答：运算指的是数据在逻辑结构S上的某种操作，运算只描述处理功能，不包括处理步骤和方法；而运算实现是指一个完成该运算功能的程序，运算实现的核心是处理步骤的规定，即算法设计。 13．算法的概念和分类？ 答：算法是指规定了求解给定类型问题所需的所有“处理步骤”及其执行顺序，使得给定类型的任何问题能在有限时间内被

数据结构导论串讲笔记

数据结构导论串讲笔记

1）已知出栈序列，写出可能的入栈序列并分析操作过程。 2）已知入栈序列，写出可能的出栈序列并分析操作过程。 [2004/1]如下图所示，输入元素为（A，B，C），在栈的输出端得到一个输出序列ABC，求出在栈的输入端所有可能的输入序列。 AB 输输 栈 【分析】A，B，C三个字符排成的序列可以有：ABC、ACB、BAC、BCA、CAB、CBA 六种，按堆栈操作的先进后出（或后进先出）的原则，只有输入序列为BCA时，输出无法得到ABC。因为输入序列为BCA时，要想先输出A，必须BCA均入栈，但这样只能得到序列ACB。其余五种输入序列都可在输出端得到序列ABC。 【解答】ABC、ACB、BAC、CAB、CBA

2．队列的操作 分析顺序队中元素入队出队操作及队列的状态。（考过） [2003/10]设有一顺序队列sq ，容量为5，初始状态时sq ．front=sq ．rear=0，画出做完下列操作后队列及其头尾指针的状态变化情况，若不能入队，请简述其理。 （1） d ，e ，b 入队 （2） d ，e 出队 （3） i ，j 入队 （4） b 出队 （5） n ，o ，p 入队 【解答】队列及其头尾指针的状态变化情况如下图所示 Sq.f Sq.r b e d Sq.f b Sq.f Sq.r j b i Sq.f Sq.r j i Sq.f Sq.r

（a ）初态 （b ）d ，e ，b 入队 （c ） d ，e 出队 （d ） i ，j 入队 （e ）b 出队 第5步操作无法进行，因队列已满。 3．二叉树的存储结构 1） 给出一棵二叉树，画出二叉链表示意图及顺序存储示意图。（[2000/10] [2003/10] [2004/10]考过） [2003/10]画出下列二叉树的二叉链表表示图。 【解答】二叉树的二叉链表表示 B E D F H G A C B B ∧ ∧ A D ∧ C G ∧ ∧ F H ∧ ∧ E ∧ ∧

自考02142《大数据结构导论》串讲笔记

第一概论 1.1 引言 两项基本任务：数据表示，数据处理 软件系统生存期：软件计划，需求分析，软件设计，软件编码，软件测试，软件维护 由一种逻辑结构和一组基本运算构成的整体是实际问题的一种数学模型，这种数学模型的建立，选择和实现是数据结构的核心问题。 机外表示------逻辑结构------存储结构 处理要求-----基本运算和运算-------算法 1.2 数据，逻辑结构和运算 数据：凡是能够被计算机存储，加工的对象通称为数据 数据元素：是数据的基本单位，在程序中作为一个整体加以考虑和处理。又称元素，顶点，结点，记录。 数据项：数据项组成数据元素，但通常不具有完整确定的实际意义，或不被当做一个整体对待。又称字段或域，是数据不可分割的最小标示单位。 1.2.2 数据的逻辑结构 逻辑关系：是指数据元素之间的关联方式，又称“邻接关系” 逻辑结构:数据元素之间逻辑关系的整体称为逻辑结构。即数据的组织形式。 四种基本逻辑结构： 1 集合：任何两个结点间没有逻辑关系，组织形式松散 2 线性结构：结点按逻辑关系依次排列成一条“锁链” 3 树形结构：具有分支，层次特性，形态像自然界中的树 4. 图状结构：各个结点按逻辑关系互相缠绕，任何两个结点都可以邻接。 注意点: 1.逻辑结构与数据元素本身的形式，容无关。 2.逻辑结构与数据元素的相对位置无关 3.逻辑结构与所含结点个数无关。 运算：运算是指在任何逻辑结构上施加的操作，即对逻辑结构的加工。 加工型运算：改变了原逻辑结构的“值”，如结点个数，结点容等。 引用型运算:不改变原逻辑结构个数和值，只从中提取某些信息作为运算的结果。 引用：查找，读取 加工：插入，删除，更新 同一逻辑结构S上的两个运算A和B, A的实现需要或可以利用B，而B的实现不需要利用A，则称A可以归约为B。 假如X是S上的一些运算的集合，Y是X的一个子集，使得X中每一运算都可以规约为Y中的一个或多个运算，而Y中任何运算不可规约为别的运算，则称Y中运算（相对于X）为基本运算。 将逻辑结构S和在S上的基本运算集X的整体（S,X）称为一个数据结构。数据结构包括逻辑结构和处理方式。

自考数据结构导论

全国2014年4月高等教育自学考试 数据结构导论试题 课程代码：02142 请考生按规定用笔将所有试题的答案涂、写在答题纸上。 选择题部分 注意事项： 1.答题前，考生务必将自己的考试课程名称、姓名、准考证号用黑色字迹的签字笔或钢笔填写在答题纸规定的位置上。 2.每小题选出答案后，用2B铅笔把答题纸上对应题目的答案标号涂黑。如需改动，用橡皮擦干净后，再选涂其他答案标号。不能答在试题卷上。 一、单项选择题(本大题共15小题，每小题2分，共30分) 在每小题列出的四个备选项中只有一个是符合题目要求的，请将其选出并将“答题纸”的相应代码涂黑。错涂、多涂或未涂均无分。 1.下列几种算法时间复杂度中，最小的是( A ) A.O(log2n) B.O(n) C.O(n2) D.O(1) 2.数据的存储方式中除了顺序存储方式和链式存储方式之外，还有( D ) A.索引存储方式和树形存储方式 B.线性存储方式和散列存储方式 C.线性存储方式和索引存储方式 D.索引存储方式和散列存储方式 3.表长为n的顺序表中做删除运算的平均时间复杂度为( C ) A.O(1) B.O(log2n) C.O(n) D.O(n2) 4.顺序表中定位算法(查找值为x的结点序号最小值)的平均时间复杂度为( C ) A.O(1) B.O(log2n) C.O(n) D.O(n2) 5.元素的进栈次序为A，B，C，D，E，出栈的第一个元素为E，则第四个出栈的元素为( C ) A.D B.C C.B D.A 6.带头结点的链队列中，队列头和队列尾指针分别为front和rear，则判断队列空的条件为( A ) A.front==rear B.front!=NULL C.rear!==NULL D.front==NULL 7.深度为5的二叉树，结点个数最多为( A )

数据库和应用串讲笔记(珍藏版)

数据库及其应用串讲笔记(珍藏版) 第一章数据库基础知识 第一节数据库的基本概念 ［填空］数据管理技术与计算机硬件、软件和计算机的应用围有着密切的联系，其发展主要经历了人工管理方式、文件系统方式和数据库系统方式等三个阶段。 ［简答］数据库技术的特点： （1）数据结构化。 （2）数据共享。 （3）数据冗余小。 （4）有较高的数据独立性。 （5）数据库系统为用户提供了使用方便的用户接口。 （6）增加了系统的灵活性。 ［简答］简述数据独立性的含义及其作用。 数据独立性是指应用程序与数据库的数据结构之间的相互独立，是数据库系统努力追求的目标。数据独立性有两层含义，如果数据库物理结构改变时，不影响数据库的整体逻辑结构、用户的逻辑结构和应用程序，这样我们就认为数据库达到了“物理数据独立性”；如果在整体逻辑结构改变时，不影响用户的逻辑结构及应用程序，那么我们就认为数据库达到了“逻辑数据独立性”。 ［选择］数据库的基本术语： 数据库：是指长期存储在计算机的、有组织的、统一管理的相关数据的集合。 数据库系统：是实现有组织地、动态地存储大量关联数据，方便多用户访问的计算机硬件、软件和数据资源组成的系统，实际上是指采用了数据库技术后的整个计算机系统。 ［简答］DBMS是数据库系统中专门用来管理数据的软件，它位于用户与操作系统（Operating System,简记为OS）之间，是用户使用数据库的接口，为用户提供了访问DB的方法，包括DB的建立、查询、更新和各种数据控制。 ［填空］DBMS总是基于某种数据模型，主要有关系型、层次型、网状型和面向对象型等。 第二节数据描述 ［填空］联系是指实体之间的关系。与一个联系有关的实体集的个数，称为联系的元数。 ［选择、填空］二元联系的三种类型： （1）一对一联系（简记为1∶1） 对于不同型实体集A和B，如果A中的一个实体最多只与B中的一个实体有联系，反之亦然，则称A和B两实体为1∶1联系。例如，一夫一妻制社会中，“丈夫”与“妻子”两实体集之间为1∶1联系。 （2）一对多联系（简记为1∶n） 如果实体集A中至少有一个实体与实体集B中多于一个的实体有联系（可以是零个、一个或多个），则称A对B为1∶n联系。例如，“母亲”和“子女”

全国数据结构导论10月高等教育自学考试试题与答案

全国20XX 年10月高等教育自学考试 数据结构导论试题 课程代码：02142 一、单项选择题(本大题共15小题，每小题2分，共30分) 在每小题列出的四个备选项中只有一个是符合题目要求的，请将其代码填写在题后的括号内。错选、多选或未选均无分。 1.在表长为n 的顺序表上做插入运算，平均要移动的结点数为（ C ） A.n/4 B.n/3 C.n/2 D.n 2.顺序表中有19个元素，第一个元素的地址为200，且每个元素占一个字节，则第14个元素的存储地址为（ B ）b+(i-1)l A.212 B.213 C.214 D.215 3.由顶点V 1，V 2，V 3构成的图的邻接矩阵为???? ??????010100110，则该图中顶点V 1的出度为（ C ） A.0 B.1 C.2 D.3 4.元素的进栈次序为A ，B ，C ，D ，E ，则退栈中不可能．．． 的序列是（ C ） A.A ，B ，C ，D ，E B.B ，C ，D ，E ，A C.E ，A ，B ，C ，D D.E ，D ，C ，B ，A 5.由带权为9，2，5，7的四个叶子结点构造一棵哈夫曼树，该树的带权路径长度为（C ） A.23 B.37 C.44 D.46 6.在已知尾指针的单循环链表中，插入一个新结点使之成为首结点，其算法的时间复杂度为（ A ） A.O （1） B.O （log 2n ） C.O （n ） D.O (n 2) 7.已知一个有序表为（13，18，24，35，47，50，62，83，90，115，134），当二分查找值为90的元素时，查找成功时需比较的次数为（ B ） A.1 B.2 C.3 D.4 8.在查找顺序表各结点概率相等的情况下，顺序按值查找某个元素的算法时间复杂度为 （ B ） A.O (1) B.O (n) C.O (n ) D.O (log 2n)

2010年1月自考数据结构导论真题

全国2010年1月自学考试数据结构导论试题 课程代码：02142 一、单项选择题(本大题共15小题，每小题2分，共30分) 在每小题列出的四个备选项中只有一个是符合题目要求的，请将其代码填写在题后的括号内。错选、多选或未选均无分。 1.下述文件中适合于磁带存储的是（） A.顺序文件 B.索引文件 C.散列文件 D.多关键字文件 2.某二叉树的后根遍历序列为dabec，中根遍历序列为debac，则先根遍历序列为（） A.acbed B.becab C.deabc D.cedba 3.含有n个结点的二叉树用二叉链表表示时，空指针域个数为( ) A.n-1 B.n C.n+1 D.n+2 4.在一个图中，所有顶点的度数之和与图的边数的比是( ) A.1∶2 B.1∶1 C.2∶1 D.4∶1 5.长度为n的链队列用单循环链表表示，若只设头指针，则出队操作的时间复杂度为( ) A.O(1) B.O(1og2n) C.O(n) D.O(n2) 6.下述几种排序方法中，要求内存量最大的是( ) A.插入排序 B.快速排序 C.归并排序 D.选择排序 7.对n个不同值进行冒泡排序，在元素无序的情况下比较的次数为( ) A.n-1 B.n C.n+1 D.n(n-1)／2 8.对线性表进行二分查找时，要求线性表必须( ) A.以顺序方式存储 B.以链式方式存储 C.以顺序方式存储，且结点按关键字有序排列 D.以链接方式存储，且结点按关键字有序排列 9.在表长为n的顺序表上做删除运算，其平均时间复杂度为( ) A.O(1) B.O(n)

C.O(nlog2n) D.O(n2) 10.当利用大小为n的数组顺序存储一个队列时，该队列的最大容量为( ) A.n-2 B.n-1 C.n D.n+1 11.有关插入排序的叙述，错误的 ．．．是( ) A.插入排序在最坏情况下需要O(n2)时间 B.插入排序在最佳情况可在O(n)时间内完成 C.插入排序平均需要O(nlog2n)时间 D.插入排序的空间复杂度为O(1) 12.有关树的叙述正确的是( ) A.每一个内部结点至少有一个兄弟 B.每一个叶结点均有父结点 C.有的树没有子树 D.每个树至少有一个根结点与一个叶结点。 13.循环队列存储在数组元素A[0]至A[m]中，则入队时的操作为( ) A.rear=rear+1 B.rear=(rear+1)％(m-1) C.rear=(rear+1)％m D.rear=(rear+1)％(m+1) 14.关于串的的叙述，不正确 ．．．的是( ) A.串是字符的有限序列 B.空串是由空格构成的串 C.替换是串的一种重要运算 D.串既可以采用顺序存储，也可以采用链式存储 15.对称矩阵A[N][N]，A[1][1]为首元素，将下三角(包括对角线)元素以行优先顺序存储到一维数组元素T[1]至T[N(N+1)／2]中，则任一上三角元素A[i][j]存于T[k]中，下标k为( ) A.i(i-1)／2+j B.j(j-1)／2+i C.i(j-i)／2+1 D.j(i-1)／2+l 二、填空题(本大题共13小题，每小题2分，共26分) 请在每小题的空格中填上正确答案。错填、不填均无分。 16.下列程序段的时间复杂度为____________。 for(i=1；i<=n；i++) for(j=1；j<=n；j++) for(k=1；k<=n；k++) s=i+j+k； 17.在数据结构中，各个结点按逻辑关系互相缠绕，任意两个结点可以邻接的结构称为____________。

自考02142《数据结构导论》串讲笔记

第一张概论 1.1 引言 两项基本任务：数据表示，数据处理 软件系统生存期：软件计划，需求分析，软件设计，软件编码，软件测试，软件维护 由一种逻辑结构和一组基本运算构成的整体是实际问题的一种数学模型，这种数学模型的建立，选择和实现是数据结构的核心问题。 机外表示------逻辑结构------存储结构 处理要求-----基本运算和运算-------算法 1.2 数据，逻辑结构和运算 数据：凡是能够被计算机存储，加工的对象通称为数据 数据元素：是数据的基本单位，在程序中作为一个整体加以考虑和处理。又称元素，顶点，结点，记录。 数据项：数据项组成数据元素，但通常不具有完整确定的实际意义，或不被当做一个整体对待。又称字段或域，是数据不可分割的最小标示单位。 1.2.2数据的逻辑结构 逻辑关系：是指数据元素之间的关联方式，又称“邻接关系” 逻辑结构:数据元素之间逻辑关系的整体称为逻辑结构。即数据的组织形式。 四种基本逻辑结构： 1 集合：任何两个结点间没有逻辑关系，组织形式松散 2 线性结构：结点按逻辑关系依次排列成一条“锁链” 3 树形结构：具有分支，层次特性，形态像自然界中的树 4. 图状结构：各个结点按逻辑关系互相缠绕，任何两个结点都可以邻接。 注意点: 1.逻辑结构与数据元素本身的形式，内容无关。 2.逻辑结构与数据元素的相对位置无关 3.逻辑结构与所含结点个数无关。 运算：运算是指在任何逻辑结构上施加的操作，即对逻辑结构的加工。 加工型运算：改变了原逻辑结构的“值”，如结点个数，结点内容等。 引用型运算:不改变原逻辑结构个数和值，只从中提取某些信息作为运算的结果。 引用：查找，读取 加工：插入，删除，更新 同一逻辑结构S上的两个运算A和B, A的实现需要或可以利用B，而B的实现不需要利用A，则称A可以归约为B。 假如X是S上的一些运算的集合，Y是X的一个子集，使得X中每一运算都可以规约为Y中的一个或多个运算，而Y中任何运算不可规约为别的运算，则称Y中运算（相对于X）为基本运算。 将逻辑结构S和在S上的基本运算集X的整体（S,X）称为一个数据结构。数据结构包括逻辑结构和处理方式。

自考02142《数据结构导论》串讲笔记

： 第一张概论 引言 两项基本任务：数据表示，数据处理 软件系统生存期：软件计划，需求分析，软件设计，软件编码，软件测试，软件维护 由一种逻辑结构和一组基本运算构成的整体是实际问题的一种数学模型，这种数学模型的建立，选择和实现是数据结构的核心问题。 机外表示------逻辑结构------存储结构 ~ 处理要求-----基本运算和运算-------算法 数据，逻辑结构和运算 数据：凡是能够被计算机存储，加工的对象通称为数据 数据元素：是数据的基本单位，在程序中作为一个整体加以考虑和处理。又称元素，顶点，结点，记录。 数据项：数据项组成数据元素，但通常不具有完整确定的实际意义，或不被当做一个整体对待。又称字段或域，是数据不可分割的最小标示单位。 — 1.2.2 数据的逻辑结构 逻辑关系：是指数据元素之间的关联方式，又称“邻接关系” 逻辑结构:数据元素之间逻辑关系的整体称为逻辑结构。即数据的组织形式。 四种基本逻辑结构： 1 集合：任何两个结点间没有逻辑关系，组织形式松散 2 线性结构：结点按逻辑关系依次排列成一条“锁链” 3 树形结构：具有分支，层次特性，形态像自然界中的树 { 4. 图状结构：各个结点按逻辑关系互相缠绕，任何两个结点都可以邻接。 注意点: 1.逻辑结构与数据元素本身的形式，内容无关。 2.逻辑结构与数据元素的相对位置无关 3.逻辑结构与所含结点个数无关。 运算：运算是指在任何逻辑结构上施加的操作，即对逻辑结构的加工。 。 加工型运算：改变了原逻辑结构的“值”，如结点个数，结点内容等。 引用型运算:不改变原逻辑结构个数和值，只从中提取某些信息作为运算的结果。 引用：查找，读取 加工：插入，删除，更新 同一逻辑结构S上的两个运算A和B, A的实现需要或可以利用B，而B的实现不需要利用A，则称A可以归约为B。

数据结构导论填空题目汇总

2004----01 16下列程序段的时间复杂性量级是____0(n*i)_________。 for (i=1;i top ++_________ sq -> data[sq -> top]=x 19链队列实际上是一个同时带有头指针和尾指针的单链表，尾指针指向该单链表的______队尾结点_______。 20设有k个结点在用哈夫曼算法构造哈夫曼树的过程中若第i次合并时已找到权最小的结点x和权次小的结点y用Tx.wt表示结点x的权值已知Tx.wt=m,Ty.wt=n则合并成新的二叉树后给新根结点的权值赋值的语句为____m+n_________。 21在下列树中结点H的祖先为_____F________。 22顶点数为n、边数为n(n-1)/2的无向图称为___无向完全图__________。 任何两点之间都有的边的无向图称为无向完全图；边数(n(n-1)/2) 任何两点之间都有弧的有向图称为有向完全图；弧数(n*(n-1)) 23动态查找表在开散列表上通常采用___线性探测法和链地址法__________来解决冲突问题。 24对于有10个元素的有序表采用二分查找需要比较3次方可找到其对应的键值则该元素在有序表中的位置可能是___1,3,6,9___________。 25查找表的逻辑结构与线性结构、树型结构等相比根本区别在于____数据元素之间无逻辑关系__________。 27在排序方法中依次将每个记录插入到一个有序的子序列中去即在第i(i≥1)遍整理时r1,r2,…,r i-1已经是排好顺序的子序列取出第i个元素r i在已排好序的子序列里为r i找到一个合适的位置并把它插到该位置上。这种排序方法被称为____直接插入排序_______。 28快速排序法在待排序数据____已基本有序_________的情况下最不利于发挥其长处。2004---10 16.从数据结构的观点，数据通常可分为三个层次，即：数据、数据元素和____数据项_______。 18.对顺序表执行插入操作，其插入算法的平均时间复杂性为____ O(n)_______。 19.在具有n个单元、且采用顺序存储的循环队列中，队满时共有_____ n-1______个元素。 20.若front和rear分别表示循环队列Q的头指针和尾指针，m0表示该队列的最大容量，则循环队列为空的条件是___Q·front==Q·rear ________。

02142数据结构导论份真题及答案.doc

2012年10月高等教育自学考试全国统一命题考试 数据结构导论试题 课程代码：02142 请考生按规定用笔将所有试题的答案涂、写在答题纸上。 选择题部分 注意事项： 1. 答题前，考生务必将自己的考试课程名称、姓名、准考证号用黑色字迹的签字笔或钢笔填写在答题纸规定的位置上。 2. 每小题选出答案后，用2B铅笔把答题纸上对应题目的答案标号涂黑。如需改动，用橡皮擦干净后，再选涂其他答案标号。不能答在试题卷上。 一、单项选择题(本大题共15小题，每小题2分，共30分) 在每小题列出的四个备选项中只有一个是符合题目要求的。错选、多选或未选均无分。 1.下面几种算法时间复杂度阶数中，值最大的是 A.O(nlog2n) B.O(n2) C.O(n) D.O(2n) 2.即使输入非法数据，算法也能适当地做出反应或进行处理，不会产生预料不到的运行结果，这种算法好坏的评价因素称为 A.正确性 B.易读性 C.健壮性 D.时空性 3.设顺序表的长度为100，则在第40个元素之后插入一个元素所需移动元素的个数为 A.40 B.60 C.61 D.100 4.设带头结点的单循环链表的头指针为head，则判断该链表是否为空的条件是 A. head->next==head B. head->next==NULL C. head!=NULL D. head==NULL 5.在链栈的运算中，不需要 ．．．判断栈是否为空的是 A.出栈 B.进栈 C.取栈顶元素 D.求链栈的元素个数 6.一个队列的输入序列是A，B，C，D，则该队列的输出序列是 A.A，B，C，D B.B，C，D，A C.D，C，B，A D.C，D，B，A 7.以行序为主序的二维数组a［3］［5］中，第一个元素a［0］［0］的存储地址是100，每个元素占2个存储单元，则a［1］［2］的存储地址是 A.100 B.108 C.114 D.116 8.对任何一棵二叉树T，若叶结点数为5个，则度为2的结点个数为 A.4 B.5 C.6 D.无法确定 9.m个叶结点的哈夫曼树中，其结点总数为 A.m B.2m+1

数据结构导论

数据结构导论复习大纲 第1章概论 一、程序设计的实质（计算机专业人员必须完成的两项基本任务）： 数据表示：机外表示->逻辑结构->存储结构 数据处理：处理要求->基本运算和运算->算法 数据表示和数据处理是密切相关的，数据处理方式总是与数据的某种表示形式相联系。 二、“数据”分成三个不同的层次，即数据、数据元素和数据项。 凡能被计算机存储、加工的对象通称为数据。 数据元素是数据的基本单位，又被称为元素、结点、顶点或记录。 数据项是数据不可分割的最小单位。 三、数据的逻辑结构 数据的逻辑结构就是数据的组织形式。所谓逻辑关系是指数据元素之间的关联方式或称“邻接关系”。 通常有集合、线性结构、树形结构、图状结构。 ＊逻辑结构与数据元素本身的形式、内容、相对位置、结点个数无关 四、运算是指在任何逻辑结构上施加的操作，即对逻辑结构的加工。分为两种基本类型： 1. 加工型运算：插入、删除、更新 2. 引用型运算：读取、查找 五、存储实现的基本目标是建立数据的机内表示。数据的机内表示称为数据的存储结构。包括三个主要部分： 1. 存储结点。每个结点存放一个数据元素 2. 数据元素之间关联方式的表示，也就是逻辑结构的机内表示 3. 附加设施。 存储结构的主要部分是数据元素之间关联方式的表示。由于每个存储结点存放一个数据元素，数据元素之间的关联方式便由存储结点之间的关联方式间接地表达。通常有四种基本存储方式： 1. 顺序存储方式 2. 链式存储方式 3. 索引存储方式 4. 散列存储方式 六、运算实现 运算的实现是指一个完成该运算功能的程序。运算实现的核心是算法设计。 算法分为三类： （1）运行终止的程序 （2）伪语言算法 （3）非形式算法 七、算法质量的评价： （1）正确性：算法应能正确地实现预定的功能 （2）易读性：算法应易于阅读和理解。 （3）健壮性：当环境发生变化时，算法能适当地做出反应或进行处理 （4）高效性：达到所需要的时空性能。 算法在所有输入下的计算量的最大值称为算法的最坏情况时间复杂性或最坏情况时间复杂度

数据结构导论

数据结构导论const maxsize=顺序表的容量； typedf struct {datatype data[maxsize]; int last; {sqlist; sqlist L; 顺序表的插入算法： void insert_sqlist(sqlist L,datetype x,int i) { if(https://www.doczj.com/doc/471213446.html,st==maxsize)error(…表潢?)； if((i<1)||(i>https://www.doczj.com/doc/471213446.html,st+1))error(…非法位置?)； for(j=https://www.doczj.com/doc/471213446.html,st;j=i;j--) L.data[j]=L.data[j-1]; L.data[i-1]=X; https://www.doczj.com/doc/471213446.html,st=https://www.doczj.com/doc/471213446.html,st+1 } 顺序表的删除算法： void delete_sqlist(sqlist L,int i); { if((i<1)||(i>https://www.doczj.com/doc/471213446.html,st)) error(非法位置)； for(j=i+1;j=https://www.doczj.com/doc/471213446.html,st;j++) L.data[j-2]=L.data[j-1]; https://www.doczj.com/doc/471213446.html,st=https://www.doczj.com/doc/471213446.html,st-1 } 顺序表的查找算法： int locate_sqlist(sqlist L,datatype X) { i=1; while((i<=https://www.doczj.com/doc/471213446.html,st)&&(L.data[i-1]!=x)) i++; if(i<=https://www.doczj.com/doc/471213446.html,st) return(i) else return(0) } 单链表类型定义 typedef struct node *pointer; struct node {datatype data; pointer next; }; typedef pointer lklist;

“数据结构导论”的学习方法

我想在自考将要来临之际,为各位正在忙碌复习当中的自考学友们,提供一点复习思路,以便能顺利通过10月份的考试.下面就是我的一点复习心得和总结,希望能对你有所帮助! "如果你想通过数据结构导论这门课,至少得看两遍书吧?" 第一遍就是粗略的看一下,这样你心里也就有了底,也就大概的了解了数据结构导论 这门课所讲的内容,并且那里是考点在头脑里也就都有了大致的把握,这样,你就可以带着相应的重点,去重点把握你觉得重要的东西了!不过其实你到现在如果连一遍也没看过呢,也没关系,我下面的总结就是希望能对这些还没看过书的人,有所帮助! 下面就列出一些我觉得是重点的东西: 1,线性表,这一章整个都比较重要,因为这一章中关于线性表的顺序实现和链接实现及在上面的基本运算,在最后考试中很有可能以多种形式的考法出现(如:选择,填空,应用及程序设计等).并且由于这一章是整本书的基础,所以考试时占的比重会比较大,最后的程序设计题很可能就从这一章里出一道甚至两道都从这章里出(一道程序设计题6分).这一点是我在作过大量模拟试题和分析了历年试卷的基础上得出的结论,应当比较有参考价值.在这一章中有一个知识点应引起大家的注意,就是链式存储结构,因为这种存储结构在以后的各章中对于各种结构的实现(如:树,图等)都比较有用且实用.所以对于它的掌握应当达到"综合应用"的等级!(一点建议:如果你在第一次看的时候遇到了自己不懂的问题,可以先尝试着跳过去看后面的,等后面的看完了,再回过头看不会的这一段,问题就可能迎刃而解了!^>,中国水利水电出版社,宁郑元主编一书)只要知道它的各种运算及结果就可以了(考试时也就这么考了:--P) 如:DELETE ("ACABA",3,3)=? 结果为:"AC" 又如:SUBSTR("ABBCA",2,2)=? 结果为:"BB" 2,栈,队列和数组:这一章里你要掌握的东西就比较简单了(如果你掌握了上一章的内容对于这一章来讲,基本上就没有难题了)这一章里你要牢记两个概念:关于栈和队列的修改原则:(1),栈,后进先出,所有操作都是在栈顶进行的.(2),队列,先进先出,插入运算只能在对尾进行,删除运算只能在对头进行!且注意对头指针指示对头元素在数组中实际位置的前一个位置;实现递归调用属于栈的应用! 再附上关于栈和队列的几道例题如下: 1,运算(*作)是数据结构的一个重要方面,试举一例,说明两个数据结构的.逻辑结构和存储方式完全相同,只是对于运算(*作)的定义不同,因而两个结构具有显著不同的特性,是两个不同的结构.

数据结构导论-实践设计报告-1

实践考核题第一题设计报告书 学生姓名学生学号 所在地区泰安市提交日期（年/月）2014/6 实践题目利用队的结构解决实际问题 需求分析 (1)、置空 setnull ( queue ) 将队列 queue 置成空队列 调用setnull(queue)函数把队列queue的顶端指针和低端指针指向同一块地址，这样就把队列置空。当队列中的数据元素不用或者必须要清楚的时候，就必须调用该函数把队列中的数据清空才能在插入新的数据供用户操作使用。 (2)、入队 enqueue ( queue ， x ) 将元素 x 插入队列 queue 的尾部 调用函数enqueue(queue,x),通过移动首指针找到要入队的数据，直到把队列的空间占满。有 数据要进入队列时，调用该函数把数据元素x插入到队列中，先判断队列是否已满让后才能把数据元素插入到队尾。 (3)、出队 dequeue ( queue ) 删除队列 queue 的队头元素，函数返回被删除元素的值 通过移动首指针把队首的指针往下移动一个地址，这样就把一个元素数据出队了。当要出队时，队列是从头指针开始一系列操作。先判断该队列是否为空队列，如果不是的话，在进行出队操作把头指针往上移一个地址，这样就把数据出队了。 （4）、判队空isempty ( queue ) 若栈stack 为空，函数返回0 ，否则返回1 判断队列的为空的条件是（queue.rear==queue.front）如果为空返回数值1，否则返回0。当出队操作时，需要判断队列是否为空，调用该函数。 概要设计 这三个函数置空、入队和出队，使用的都是顺序循环存储结构。

队列是有限个同类型数据元素的线性序列，是一种先进先出（First In First Out）的新型表，新加入的数据元素插在队列的尾端，出队列的数据元素在队列首部被删除。 顺序存储实现的队列称为顺序队列，它由一个一维数组（用于存储队列中元素）及两个分别指示队列首和队列尾元素的变量组成，这两个变量分别称为“队列首指针”和“队列尾指针”。 （1）、队列是有限的数据元素的集合，要定义一个常量说明该队列的大小； （2）、定义顺序队列的类型包括一个数据域和两个指针域（首指针和尾指针），并声明一个该类型的变量以便于操作； （3）、根据需求分析写出每个函数的功能： 置空函数：根据函数的形参，即传递进来的队列指针，调用它的首指针和尾指针让两个指针相等，就把队列中的元素全部清空。 入队函数：首先判断该队列是否已满，如果队列已满，就退出操作。否则，执行入队操作的语句，由于是循环队列所以在移动尾指针时，要把尾指针的位置取余运算（queue.rear=(queue.rear+1)%maxsize;），然后把数据元素赋给尾指针(queue,data[queue.rear]=x;)。 出队函数：当有数据元素要出队时，首先判断该队列是否为空，如果为空时，元素出队列失败。否则，当队列不为空时，执行出队操作（queue.front=(queue.front+1)%maxsize;）返回数值1，说明出队成功。判空函数：该函数是用来判断队列是否为空的，是被别的函数调用作为判断条件用，若果为空的话就返回数值0，标志不能继续执行下面的语句。判断为空的条件是：queue.rear==queue.front；如果为空返回值为1，否则返回值为0。 详细设计 对于队列的操作首先需要把队列置空，然后插入数据元素，在插入元素时需要判断是否队列已满，在数据元素出队时需要先对队列判断是否为空，如果为空时结束程序继续执行，否则继续执行出队操作。（1）定义结构体 Typedef struct seqqueue //定义结构体类型seqqueue

02142数据结构导论201410试题及答案

2014年10月高等教育自学考试全国统一命题考试 数据结构导论试卷 (课程代码02142) 本试卷共5页，满分l00分，考试时间l50分钟。 考生答题注意事项： 1．本卷所有试题必须在答题卡上作答。答在试卷上无效，试卷空白处和背面均可作草稿纸。2．第一部分为选择题。必须对应试卷上的题号使用2B铅笔将“答题卡"的相应代码涂黑。3．第二部分为非选择题。必须注明大、小题号，使用0.5毫米黑色字迹签字笔作答。4．合理安排答题空间，超出答题区域无效。 第一部分选择题 一、单项选择题(本大题共l5小题，每小题2分，共30分) 在每小题列出的四个备选项中只有一个是符合题目要求的。请将其选出并将“答题卡”的相应代码涂黑。未涂、错涂或多涂均无分。 1．下列算法的时间复杂度为B 2．根据数据元素之间关系的不同特性，通常将数据结构分为四类基本结构，即 A．集合、顺序结构、树形结构、图结构 B．集合、线性结构、链式结构、图结构 C．集合、线性结构、树形结构、图结构 D．线性结构、顺序结构、链式结构、图结构 3．在表长为101的顺序表中做删除运算，平均移动元素的次数为 A．25 B．50 C．5l D．100 4．在表长为n的顺序表中做插入运算的时间复杂度为A 5．单链表与顺序表相比，其特点是 A．运算算法实现简单 B．便于随机存取数据 C．不需要预先分配存储空间 D．结点个数受到限制 6．关于链栈的说法，正确的是 A．链栈不用预先考虑容量的大小 B．链栈出栈时不需要判断栈空 C．链栈进栈时需要判断栈满 D．链栈出栈时需要判断栈满 7．循环队列存储在数组A[m]中，则入队列操作中队列尾指针rear的变化为 A．rear=rear+1 B．rear=(rear+1)％(m一1)

自考网络注册学习加分科目介绍

自考网络注册学习加分科目介绍

一、什么是网络注册学习？ 为建立和完善高等教育自学考试，经湖北省教育考试院批准（鄂自考[ ] 11号文件），在湖北省内开展自学考试网络助学班综合评价项目。考生参加"课程网络助学"的学习，可取得过程性评价成绩，过程性评价成绩以30%的比例计入总分。即经过网上课程学习，能够把网上学习的成绩按30%比例计入考试总分，大大提高考试经过率！ 二、成绩评定 a) 参加课程网络助学的考生在学习过程结束后，可取得过程性评价成绩。过程性评价成绩经湖北省教育考试院审核确认以后以30%的比例计入总分，即自考课程成绩 = 过程性评价成绩 ×30% + 国家统考笔试成绩×70%。 b) 例一考生小明《资产评估》课程的国家统考笔记成绩为52分，因参加了课程网络助学，获得了过程行评价成绩96.02分，折算后，她的最终成绩为65分。具体换算：过程性评价成绩96.02分× 30% + 国家统考笔试成绩52分× 70% =最终成绩65.206分，约等于65分。（对于想考学位的同学而言，是不是很轻松就能获得？） c) 过程性评价成绩在一年内均有效。即一年内，每次报考该课程均可获得30%的网络平台的平时成绩! “过程性评价成绩”即“平时成绩”；简单理解网络注册学习折算下最多来能够加：17分（按照要求可100%获得）。 三、学习形式与流程 网络助学采用"网络+面授"混合式的助学模式，为考生提供线上线下学习支持服务。即经过学习在网上看视频教程，做相关知识点测评，及相关辅导老师的线下辅导，学习结束后评估出考生过程性评价成绩，即平时成绩，过程性评价成绩湖北省教育考试院审核确认后可与国家统考笔试成绩进行合并。 四、报考学习 1、报考资格：所有湖北地区自考人员均可报考 2、报考类型：提供网络注册学习账户，直接在网络进行学习，加考前串讲面授，大大提高经过率。

数据结构导论2142复习资料

第一章概论 1，数据表示：将数据从机外表示转化为机内表示。变化过程：机外表示->逻辑结构->存储结构。 2，数据处理：计算机执行对机内表示的数据的各种操作从而实现处理要求，得到所需结果。 过程：处理要求->基本运算和运算->算法 3，计算机专业人员的两项基本任务：数据表示和数据处理。 4，从数据结构观点看，通常的数据分为三个层次：数据、数据元素、数据项。 5，凡能被计算机存储、加工的对象通称为数据。 6，数据元素是数据的基本单位，具有完整确定的实际意义，又称为元素，结点，顶点或记录。 7，数据项是数据的不可分割的最小单位，不具备完整确定的实际意义，又称字段、域。数据元素由数据项组成。8，逻辑关系是指数据元素之间的关联方式或称邻接关系 9，数据元素之间逻辑关系的整体称为逻辑结构。数据的逻辑结构就是数据的组织形式。 10，数据逻辑结构四种基本形式：集合、线性结构、树形结构、图状结构。 11，集合：任何两个结点之间都没有逻辑关系，组织形式松散。 12，线性结构：结点按逻辑关系依次排列成一条锁链。 13，树形结构：具有分支、层次特点，其形态类似自然界中的树。 14，图状结构：各个结点按逻辑关系相互缠绕，任何两个结点都可以邻接。 15逻辑结构与数据元素本身形式、内容无关。逻辑结构与数据元素相对位置无关。逻辑结构与结点个数无关。 16，在数据的逻辑结构上规定的某种操作称为运算。运算是指在任何逻辑结构上施加的操作，即对逻辑结构的加工。这种加工以一个或多个逻辑结构及其他有关参数为对象，以经过修改的逻辑结构或从原逻辑结构中提取的有关信息为结果。 17，运算两种基本类型：加工型运算和引用型运算。查找：找出满足某条件的结点在逻辑结构中的位置。 读取：读出某逻辑结构中指定位置的结点的内容。插入：在某逻辑结构中指定位置增加一个新结点。 删除：撤销某逻辑结构中指定位置的结点。更新：修改某逻辑结构中指定位置的结点内容。 18，数据结构中将数据的组织形式（逻辑结构）和对数据的操作方式（基本运算）作为一个整体来看待。 19，存储实现的目的是建立数据的机内表示。建立的数据的机内表示称为数据的存储结构。 20，一个存储结构分为三个部分：存储节点，数据元素之间的关联方式，附加设施。 21，四种基本存储结构：顺序存储结构，链式存储结构，索引存储结构，散列存储结构。（理解四种形式） 22，算法是计算机科学的一个基本概念，也是程序设计的一个核心概念。一个算法规定了求解给定问题所需要的所有处理步骤及其执行顺序，使得给定类型的任何问题都能在有限时间内被机械的求解。 23，任何算法都是用某种语言加以描述的。三类：程序（计算机语言描述算法），伪语言算法，非形式算法。 24，非形式算法：用自然语言同时可能还使用了程序设计语言或伪语言描述的算法。 25，评价算法的4个方面：正确性，易读性，健壮性，高效性。高效性是指算法的时间性能和空间性能。