数据结构总复习资料(完整版)
2018数据结构总复习
第一章概论
1.1数据结构的定义和分类
1.数据结构的定义
数据结构是一门研究非数值计算的程序设计问题中计算机的操作对象以及它们之间的关系和操作的学科。
2.数据结构包括的内容
（1）逻辑结构：数据元素之间的逻辑关系。
（2）存储结构：数据元素及其关系在计算机存储器内的表示。
（3）操作：数据的运算（检索、排序、插入、删除、修改）。
1.2为什么学习数据结构
1.学习数据结构的作用
（1）计算机内的数值运算依靠方程式，而非数值运算（如表、树、图等）则要依靠数据结构。
（2）同样的数据对象，用不同的数据结构来表示，运算效率可能有明显的差异。
（3）程序设计的实质是对实际问题选择一个好的数据结构，加之设计一个好的算法。而好的算法在很大程度上取决于描述实际问题的数据结构。
2.电话号码查询问题
（1）要写出好的查找算法，取决于这张表的结构及存储方式。
（2）电话号码表的结构和存储方式决定了查找（算法）的效率。
1.3算法的概念和特点
1.算法的概念和特点
算法是由若干条指令组成的有穷序列，具有以下特点：
（1）输入：具有0个或多个输入的外界量。
（2）输出：至少产生1个输出。
（3）有穷性：每一条指令的执行次数必须是有限的。
（4）确定性：每条指令的含义都必须明确，无二义性。
（5）可行性：每条指令的执行时间都是有限的。
2.算法与程序的区别
（1）一个程序不一定满足有穷性，但算法一定。
（2）程序中的指令必须是机器可执行的，而算法无此限制。
（3）一个算法若用机器可执行的语言来描述，则它就是一个程序。
1.4算法分析
1.时间复杂度
算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n)，使得当n趋近于无穷大时，T(n) / f(n) 的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n)=O(f(n))，称O(f(n)) 为算法的渐近时间复杂度，简称时间复杂度。算法效率的度量，采用时间复杂度。
常见函数的时间复杂度按数量递增排列及增长率：
常数阶O(1)
对数阶O(log2n)
线性阶O(n)
线性对数阶O(n log2n)
平方阶O(n2)
立方阶O(n3)
……
k次方阶O(n k)
指数阶O(2n)
2.空间复杂度
空间复杂度是指算法在计算机内执行时所需存储空间的度量，记作：S(n) = O(f(n))。
3.算法分析的目的
目的在于选择合适算法和改进算法
1.5 例题
例1：
for ( i=1; i y = y+1; //语句1 for ( j=0; j<=(2*n); j++ ) x++; //语句2 } 解：语句1频度为(n-1)；语句2频度为(n-1)*(2n+1)=2n2-n-1，因此时间复杂度T(n)=2n2-2=O(n2)。 例2： i=1; //语句1 while (i<=n) i=i*2; //语句2 解：语句1频度为1；设语句2频度为f(n)，则有2f(n)<=n，即f(n)<=log2n，去极大值，f(n)=log2n，因此时间复杂度T(n)=1+log2n=O(log2n)。 第二章线性表 2.1 线性表的概念和运算 1.线性表的概念 线性表是 n (n≥0) 个类型相同的数据元素组成的有限序列。其中数据元素的个数n为线性表的长度，当n=0时称为空表。 2.线性表的特点 对于非空的线性表，有且仅有一个开始结点和一个终端结点；开始结点没有直接前趋，有且仅有一个直接后继；终端结点没有直接后继，有且仅有一个直接前趋；其余任何结点有且仅有一个直接前趋和一个直接后继。 3.线性表的计算 (1) 置空表 SETNULL(L)：将线性表L置为空表。 (2) 求长度 LENGTH(L)：返回是线性表L中结点的个数。 (3) 取结点 GET(L, i )：当1 ≤ i ≤ LENGTH(L)时，返回线性表L中的第 i 个结点，否则返回NULL。 (4) 定位 LOCATE(L, x)：当线性表L中存在一个值为x的结点时，结果是该结点的位置；若表L中存在多个值为x的结点，则返回首次找到的结点位置；若表L中不存在值为x的结点，则返回一个特殊值表示值为x的结点不存在。 (5) 插入 INSERT(L, x, i)：在线性表L的第i个位置插入一个值为x的新结点。这里1 ≤ i ≤ n+1，n是原表L的长度。 (6) 删除 DELETE(L, i)：删除线性表L的第i个结点。这里1 ≤ i ≤ n，n是原表L的长度。2.2 线性表的存储结构 1.顺序存储： （1）定义：把逻辑上相邻的数据元素存储在物理上相邻的存储单元中的存储结构。简言之，逻辑上相邻，物理上也相邻。 （2）顺序存储方法：用一组地址连续的存储单元依次存储线性表的元素，可通过数组来实现。 （3）地址计算：设首元素a1的存放地址为LOC(a1)（称为首地址），设每个元素占用存储空间（地址长度）为L字节，则地址计算公式：LOC(ai) = LOC(a1) + ( i-1)*L。 （4）结构定义： #define MAXSIZE 1024 //线性表的最大长度 typedef int datatype; //线性表数据元素类型 typedef struct { datatype data[MAXSIZE]; int last; //指示线性表的终端结点在表中的下标值 }sequenlist; 2.链式存储： （1）特点：用一组任意的存储单元存储线性表的数据元素，利用指针实现了用不相邻的存储单元存放逻辑上相邻的元素，每个数据元素ai，除存储本身信息外，还需存储其直接后继的信息。 （2）头指针、头节点、开始节点 头指针是指向链表中第一个结点（或为头结点或开始结点）的指针，单链表可由一个头指针唯一确定。 头结点是在链表的开始结点之前附设的一个结点；数据域内只放空表标志和表长等信息； 开始结点是指链表中存储线性表第一个数据元素a1的结点。 （3）空表的表示 无头结点时，当头指针的值为空时表示空表； 有头结点时，当头结点的指针域为空时表示空表。 （4）结构定义 typedef int datatype; //线性表数据元素类型 typedef struct node { datatype data; //数据域 struct node *next; //指针域 } linklist; 3.存储结构比较 （1）优缺点 顺序存储的优点是存储密度大(＝1)，存储空间利用率高。缺点是插入或删除元素时不方便。适合做查找这样的静态操作。 链式存储的优点是插入或删除元素时很方便，使用灵活。缺点是存储密度小(<1），存储空间利用率低。适合做做插入、删除这样的动态操作。 （2）线性表的顺序存储与链式存储对线性表的运算比较 顺序存储时，相邻数据元素的存放地址也相邻（逻辑与物理统一）；要求内存中可用存储单元的地址必须是连续的。 链式存储时，相邻数据元素可随意存放，但所占存储空间分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针。 （3）时间复杂度和存储密度比较 顺序存储存储密度=1，链式存储<1。顺序表中访问任意一结点的时间复杂度均为O(1)，但是在插入和删除时时间复杂度为O(n)。链表时间复杂度为O(n)。 4.单链表操作 （1）查找 void findValue(Linklist *head ,int x){ Linklist *t; t = head->next; while(t!=NULL && t->data !=x) t=t->next; if(t->data == x) printf("成功找到\n"); else printf("没有找到\n"); } （2）插入 void insert(Linklist *head,int x){ Linklist *t,*p; p = (Linklist*)malloc(sizeof(Linklist)); p->data = x; t = head; while(t->next != NULL && t->next->data < x) t = t->next; if(t == head){ p->next = head->next; head->next = p; }else if(t->next == NULL){ t->next = p; p->next = NULL; }else{ p->next = t->next; t->next = p; } } （3）删除 void dele(Linklist *head){ Linklist p ,q; p=head; while (p->next !=NULL){ if (p->data !=p->next->data) p=p->next; else { q=p->next; p->next=q->next; free(q);} } } （4）逆置 void reverse(Linklist *head){ Linklist *s,*t,*p; p = head; s = p->next; while(s->next != NULL) { t = s->next; s->next = p; p = s; s = t; } s->next = p; head->next->next = NULL; head->next = s; } 2.3 例题 例1：一个一维数组M，下标的范围是0到9，每个数组元素用相邻的5个字节存储。存储器按字节编址，设存储数组元素M[O]的第一个字节的地址是98，则M[3]的第一个字节的地址是 113 。 例2：在一个长度为n的顺序表中向第i个元素（1≤i≤n+1）之前插入一个新元素时，需要向后移动n-i+1 个元素（或删除第i个元素，需要向前移动 n-i 个元素）。 例3：在单链表中，若*p结点不是末尾结点，在其前或后插入*s结点或删除结点的操作是？ 解：在其前插入*s结点：s->next= p->next ; p->next=s; t=p->data; p->data=s->data ; s->data= t ; 在其后插入*s结点：s->next=p->next; p->next=s; 删除其前结点：需要利用遍历 删除其后结点：q = p->next; p->next=q->next; free(q); 删除自身接结点：q=p->next; p->data= q->data ; p->next=q->next ; free(q); 例4：在线性表的下列存储结构中，读取指定序号的元素花费时间最少的是顺序结构。 第三章栈和队列 3.1栈和队列的基本概念 1.栈的概念 栈是只允许在同一端进行插入和删除操作的线性表。允许进行插入和删除的一端叫栈顶(top)，另一端叫栈底(bottum) ，栈中无数据元素时，称为空栈。具有先进后出（FILO）或后进先出（LIFO）的特点。 2.栈的定义 （1）顺序栈 typedef int datatype; # define MAXSIZE 100 typedef struct{ datatype data[MAXSIZE]; int top; } seqstack; seqstack *s; （2）链栈 typedef int datatype; typedef struct node{ datatype data; struct node * next; } linkstack; linkstack * top; top 是栈顶指针，它唯一地确定一个链栈。top=NULL时，该链栈为空栈。链栈中的结点是动态产生的，无需考虑上溢问题。 3.顺序栈操作 （1）判断栈空 int EMPTY(seqstack *s) { return(!s–>top>=0); } （2）置空栈 void SETNULL(seqstack *s) { s–>top=-1; } （3）判断栈满 int FULL(seqstack *s) { return(s–>top==MAXSIZE-1); } （4）进栈 seqstack * PUSH(seqstack *s，datatype x) { if (FULL(s)) { printf(“stack overflow”); return NULL; } s–>top++; s–>data[s–>top]=x; return s; } （5）出栈 datatype POP(seqstack *s) { if (EMPTY(s)) { printf(“stack underflow”); return NULL; } s–>top--; return(s–>data[s–>top+1]); } （6）取栈顶 datatype TOP(seqstack *s) { if (EMPTY(s)) { printf(“stack is empty”); return NULL; } return (s–>data[s–>top]); } 4.链栈操作 （1）进栈 linkstack *PUSHLSTACK(linkstack *top, datatype x) { linkstack *p; p＝(linkstack *)malloc(sizeof(linkstack)); p->data＝x; p->next＝top; return p; /*返回新栈顶指针*/ } （2）出栈 linkstack *POPLSTACK(linkstack *top, datatype *datap) { linkstack *p; if (top==NULL) { printf(“under flow”); return NULL;} datap＝top->data; /*栈顶结点数据存入*datap */ p=top; top＝ top->next; free(p); return top; /*返回新栈顶指针*/ } 5.队列的概念 队列(Queue)也是一种运算受限的线性表。只允许在表的一端进行插入，而在另一端进行删除。允许删除的一端称为队头(front)，允许插入的一端称为队尾(rear)。具有先进先出（FIFO）的特点。 6.队列的定义 （1）顺序队列 #define MAXSIZE 100 typedef struct{ datatype data[MAXSIZE]; int front; int rear; }sequeue; sequeue * sq; （2）链式队列 typedef struct queuenode{ datatype data; struct queuenode *next; }QueueNode; typedef struct{ QueueNode *front; QueueNode *rear; }LinkQueue; 7.循环队列 （1）假上溢 在入队和出队的操作中，头尾指针只增加不减小，致使被删除元素的空间永远无法重新利用。尽管队列中实际的元素个数远远小于向量空间的规模，但也可能由于尾指针巳超出向量空间的上界而不能做入队操作，该现象称为假上溢。 （2）循环队列 为了解决假上溢问题，引入了循环队列的概念。在循环队列中进行出队、入队操作时，头尾指针仍要加1，朝前移动。只不过当头尾指针指向向量上界( MaxSize-1 )时，其加1操作的结果是指向向量的下界0。 （3）队空队满问题 入队时：尾指针向前追赶头指针，出队时：头指针向前追赶尾指针，故队空和队满时头尾指针均相等，无法通过 sq->front= =sq-> rear 来判断队列“空”还是“满”。 解决此问题的方法至少有两种： 1、另设一个布尔变量以区别队列的空和满； 2、少用一个元素空间为代价，入队前，测试尾指针 sq-> rear+1==sq->front ，若相等则认为队满。 （4）常用操作 队空判断：sq->front == sq-> rear 队满判断：sq-> front ==(sq-> rear + 1) % maxSize 入队： sq-> rear = (sq-> rear + 1) % maxSize 出队： sq-> front = (sq-> front + 1) % maxSize 求队长：(sq-> rear - sq-> front+maxSize)%maxSize 8.循环队列操作 （1）入队 ①检查队列是否已满，若队满，则进行溢出错误处理。 ②将队尾指针后移一个位置（即加1），指向下一单元。 ③将新元素赋给队尾指针所指单元。 Status EnQueue (SqQueue *Q, ElemType e){ if ( (Q->rear+1)%MAXQSIZE == Q->front ) return(ERROR); //队满上溢 Q->rear=(Q->rear+1)%MAXQSIZE; Q->data[Q->rear]=e; return(True); } （2）出队 ①检查队列是否为空，若队空，则进行下溢错误处理。 ②将队首指针后移一个位置（即加1）。 ③取队首元素的值。 Status DeQueue (SqQueue *Q) { if (Q->rear== Q->front) return(NULL); //队空下溢 Q->front=(Q->front+1)%MAXQSIZE; return(Q->data[Q->front]); } （3）置空队 Q->front=Q->rear= MAXQSIZE-1; （4）取队头 datatype GetHead(SqQueue *Q ) { if (Q->front==Q->rear) return(NULL); //队空 return (Q->data[(Q->front+1)%MAXQSIZE] ); } （5）判断队空 int QueueEmpty(SqQueue *Q ){ if (Q->front==Q->rear) return (True); else return (False); } 9.链式队列操作 （1）置空 void InitQueue(LinkQueue *Q) { Q.front=Q.rear=(queuenode *)malloc(sizeof(queuenode )); Q.front->next=Q.rear->next=NULL; } （2）判断队空 int QueueEmpty(LinkQueue *Q) { return (Q.front->next= =NULL &&Q.rear->next= =NULL); } （3）入队 void EnQueue(LinkQueue *Q, datatype x){ QueueNode *p; p=(QueueNode * )malloc(sizeof(QueueNode)); p–>data=x; p–>next=NULL; Q->rear–>next=p; Q->rear=p; } （4）出队 DeQueue(linkqueue *Q) { linkqueue *p; datatype x; if (EMPTY(Q)) return NULL; p = Q->front->next; Q->front->next = p–>next; if (p->next==NULL) Q->rear = Q->front; x = p->data; free(p); return x; } 3.2 栈和队列的应用 1.递归函数 递归函数又称为自调用函数，它的特点：在函数内部可以直接或间接地调用函数自己。例如阶乘函数：n!=1, n=1&n*n-1！, n>1，可以被描述为FACT(n)=1, n=1&n*FACTn-1 ！, n>1 C语言描述如下： int FACT(int n) { if (n==1) return (1); else return (n*FACT(n-1)); } 2.算法表达式求值 计算机系统在处理表达式前，先设置两个栈：操作数栈(OPRD)：存放处理表达式过程中的操作数；运算符栈(OPTR)：存放处理表达式过程中的运算符。开始时，在运算符栈中先在栈底压入一个表达式的结束符“#”。 （1）中缀表示法 计算机系统在处理表达式时，从左到右依次读出表达式中的各个符号（操作数或运算符），每读出一个符号ch后，根据运算规则做如下处理： ①如果ch是操作数，则将其压入操作数栈OPRD，并依次读取下一个符号。 ②若ch是运算符，则： A、若读出的运算符的优先级大于OPTR栈顶的运算符优先级，则将其压入OPTR，并依次读下 一个符号。 B、若读出的是“#”，且OPTR栈顶的运算符也是“#”，则表达式处理结束，最后的计算结果 在OPRD的栈顶位置。 C、若读出的是“（”，则将其压入OPTR。 D、若读出的是“）”，则： 若OPTR栈顶不是“(”，则从OPRD连续退出两个操作数，从OPTR中退出一个运算符，然后作相应的运算，并将运算结果压入OPRD，然后返回a)，让ch继续与OPTR栈顶元素进 行比较。 若OPTR栈顶为“(”，则从OPTR退出“(”，依次读下一个符号。 E、若读出的运算符的优先级小于OPTR栈顶运算符的优先级，则从OPRD连续退出两个操作数，从OPTR中退出一个运算符，然后作相应的运算，将运算结果压入OPRD 。返回(2)继续OPTR栈顶元素进行比较。 （2）波兰表示法和逆波兰表示法 以5 + ( 6 – 4 / 2 ) * 3为例，波兰表示法：+ 5 * - 6 / 4 2 3 逆波兰表示法：5 6 4 2 / - 3 * +。 运算时按从左到右的顺序进行，不需要括号。在计算表达式时，可设置一个栈，从左到右扫描后缀表达式，每读到一个操作数就将其压入栈中；每读到一个运算符时，则从栈顶取出两个操作数运算，并将结果压入栈中，一直到后缀表达式读完。最后栈顶就是计算结果。 3.括号匹配 #include #define maxsize 100 typedef int datatype; typedef struct{ datatype data[maxsize]; datatype top; }seqstack; seqstack *s; void build(); void push(); void pop(); int check(char ss[]); void main(){ char ss[maxsize]; build(); printf("请输入要测试的算数表达式:"); scanf("%s",ss); if(check(ss)==-1) printf("算数表达式不匹配!"); else printf("算数表达式匹配!"); } void build(){ s=(seqstack*)malloc(sizeof(seqstack)); s->top=-1; } int check(char ss[]){ int i=0; while(ss[i] != '\0'){ i++; if(ss[i] == '(') push(); else if(ss[i] == ')') pop(); } return s->top; } void push(){ s->top++; } void pop(){ s->top--; } 4.回文串判断 #include #include #include #define maxsize 100 typedef struct { char data[maxsize]; int top; } stack; typedef struct { char data[maxsize]; int front; int rear; } queue; int isempty_queue(queue * stq){ return stq->front == stq->rear; } int isfull_queue(queue *stq){ return stq->rear >= maxsize -1 ; } queue * init_queue(){ queue * tmp = (queue*) malloc(sizeof(queue)); tmp->front = tmp->rear = 0; return tmp; } char dequeue(queue * stq){ if( isempty_queue(stq) ) { printf("队列为空，无法出队\n"); exit(0); } return stq->data[stq->front++]; } void inqueue(queue *stq, char value) { if( isfull_queue(stq) ) { printf("队列已满，无法入队\n"); exit(0); } stq->data[stq->rear++] = value; } stack * init_stack(){ stack * tmp = (stack *) malloc( sizeof(stack) ); tmp->top = 0; return tmp; } int isempty_stack(stack *stk) { return stk->top == 0 ? 1 : 0; } int isfull_stack(stack *stk) { return stk->top >= maxsize -1 ? 1: 0; } char pop(stack *stk) { if( isempty_stack(stk) ) { printf("堆栈为空，无法出栈\n"); exit(0); } return stk->data[--stk->top]; } void push(stack *stk, char value) { if( isfull_stack(stk) ) { printf("堆栈已满，无法入栈\n"); exit(0); } stk->data[stk->top++] = value; } void compare(stack * stk, queue *stq, char str[], int len) { int i; int flag = 0; char temp_stack; char temp_queue; for(i = 0; i < len; i++){ push(stk, str[i]); inqueue(stq, str[i]); } for(i = 0; i < len; i++){ temp_stack = pop(stk); temp_queue = dequeue(stq); if(temp_stack != temp_queue) { printf("不是回文串\n"); flag = 1; break; } } if( !flag ) printf("是回文串\n"); } int main(){ queue * stq = init_queue(); stack * stk = init_stack(); char c[maxsize],s; int i=0; printf("请输入字符序列，以@结束\n"); scanf("%c",&s); while(s!='@'){ c[i]=s; scanf("%c",&s); i++; } c[i]='\0'; compare(stk, stq, c, strlen(c)-1); return 0; } 3.3 例题 例1：栈和队列是特殊的线性表，其特殊性体现在？为什么要引入循环队列？ 解：和普通线性表相比，对插入、删除运算加以限制。一般的一维数组队列的尾指针已经到了数组的上界，不能再有入队操作，但其实数组中还有空位置，为了解决这种问题，就要引入循环队列。 例2：设一个栈的入栈序列为A,B,C,D,则可能的出栈序列有哪些？ 解：共计14种，分别是：ABCD、ACBD、ACDB、ABDC、ADCB、BACD、BADC、BCAD、BCDA、BDCA、CBAD、CBDA、CDBA、DCBA。 例3：有5个元素，其入栈次序为A、B、C、D、E，在各种可能的出栈次序中，以元素C、D最先出栈（C 第一个出栈且D第二个出栈）的次序有哪几种？ 解：共计3种，分别是：CDEBA、CDBEA、CDBAE。 例4：判定一个顺序栈ST（元素个数最多为StackSize）为空/满的条件是。 解：空：ST->top=0，满：ST->top=MAXSIZE-1。 例5：判定一个循环队列Q（存放元素位置：0至QueueSize-1）队满的条件是。 解：sq-> front ==(sq-> rear + 1) % maxSize。 例6：若用一个大小为6的数组来实现环形队列，且当前rear和front的值分别是0和3，当从队列中删除一个元素，再加入两个元素后，rear和front的值分别是 2 和 4 。 第四章串 4.1 串的基本概念 1.串的概念 串(String)是零个或多个字符组成的有限序列。一般记作S=“a1a2a3…an”，其中S 是串名，用双引号括起来的字符序列是串值；ai(1≦i≦n)可以是字母、数字或其它字符；串中所包含的字符个数称为该串的长度。长度为零的串称为空串(Empty String)，它不包含任何字符。 2.主串和子串 串中任意个连续字符组成的子序列称为该串的子串。包含子串的串相应地称为主串。通常将子串在主串中首次出现时的该子串的首字符对应的主串中的序号，定义为子串在主串中的序号（或位置）。 3空白串和空串 通常将仅由一个或多个空格组成的串称为空白串(Blank String)。空白串和空串的不同，如“”和“” 分别表示长度为1的空白串和长度为0的空串。 4.2 串的存储结构 1.顺序存储 #define MAXSTRLEN 256 char s[MAXSTRLEN]; 2.堆分配存储 typedef struct { char *ch; // 若是非空串, 则按串长分配存储区, 否则 ch 为NULL int length; //串长度 } HString ; 这类串操作实现的算法为：先为新生成的串分配一个存储空间，然后进行串值的复制。 （1）求串长 int strlen(HString s) { return s.length; } （2）置空 Status clearstring(HString s) { if (s.ch) { free(s.ch); s.ch=NULL; } s.length=0; } （3）生成堆 //生成一个其值等于串常量chars的串t Status strassign(HString t, char *chars){ if(t.ch) free(t.ch); //释放原空间 i=strlen(chars); //求串长 if (!i) { t.ch=NULL; t.length=0; } //空串 else{ if(!(t.ch=(char *)malloc(i*sizeof(char)))) //申请存储exit(OVERFLOW); for (j=0;j t.length=i; } } （4）比较函数 int strcmp(HString s, HString t) { //S>T, 返回值>0; S==T, 返回值0 ; S for(i=0;i if(s.ch[i]!=t.ch[i]) return(s.ch[i]-t.ch[i]); return s.length-t.length; } （5）拼接函数 // 用T返回由S1和S2联接而成的新串 Status strcat(HString t, HString s1,HString s2) { if(!(t.ch)=(char*)malloc(s1.length+s2.length)*sizeof(char))) exit(OVERFLOW); for(j=0; j< s1.length ; j++) t.ch[j]=s1.ch[j]; for(k=0;k< s2.length ;k++) t.ch[j+k]=s2.ch[k]; t.length=s1.length+s2.length; } （6）求子串 //用Sub返回串S的第pos个字符起长度为len的子串 Status substr(HString sub, HString s, int pos, int len) { if (pos<1 || pos>s.length || len<0 || len>s.length-pos+1) return ERROR; if (sub.ch) free(sub.ch);// 释放旧空间 if (!len) { sub.ch=NULL; sub.length=0; } // 空子串 else{ sub.ch=(char *)malloc(len*sizeof(char)); for(j=0;j sub.ch[j]=s.ch[pos-1+j]; s.length=len; } } 3.链式存储 typedef struct node{ char data; struct node *next; }lstring; 但这种方式存储的密度太低，为了提高存储的密度，使得每个节点能够存储多个字符，因此如下定义：#define CHUNKSIZE 80 // 可由用户定义的块大小，实际中根据需要设置大小 typedef struct Chunk { // 结点结构 char ch[CUNKSIZE]; struct Chunk *next; } Chunk; typedef struct { // 串的链表结构 Chunk *head, *tail; // 串的头和尾指针 int curlen; // 串的当前长度 } LString; 4.3 串的基本运算 1. 串赋值：strassign(S,T)，表示将T串的值赋给S串。 2. 联接：strcat(T1,T2)，表示将T1串和T2串联接起来，组成一个新的T1串。 3. 求串长度：strlen (T)，求T串的长度。 4.子串：substr (S, i, len)，表示截取S串中从第i个字符开始连续len个字符，构成一个新串（显然该新串是S串的子串）。 5. 串比较大小：strcmp(S,T)，比较S串和T串的大小，若S 6. 串插入：strinsert (S,i,T)，在S串的第i个位置插入T串。 7. 串删除：strdelete(S,i,len)，删除串S中从第i个字符开始连续len个字符。 8. 求子串位置：index(S,T)，求T子串在S主串中首次出现的位置，若T串不是S串的子串，则位置为零。 9. 串替换：replace (S,T1,T2)，用串T2替换串S中出现的所有子串T1。 4.4 模式匹配 1.BF算法 （1）算法思想： 将主串的第pos个字符和模式的第1个字符比较，若相等，继续逐个比较后续字符；若不等，从主串的下一字符 (pos+1) 起，重新与第一个字符比较。直到主串的一个连续子串字符序列与模式相等。返回值为S中与T匹配的子序列第一个字符的序号，即匹配成功。否则，匹配失败，返回值 0 。 （2）程序段： int S_index(SString t, SString p, int pos) { int n,m,i,j; m=strlen(t); n=strlen(p); for (i=pos-1; i<=m-n; i++){ for (j=0; j if(j==n) return(i+1); } return(0); } 2. * KMP算法（略） 4.5 例题 例1：若n为主串长，m为子串长，则串的古典（朴素）匹配算法最坏的情况下需要比较字符的总次数为(n-m+1)*m 。 例2：设有两个串s和t，其中t是s的子串，求子串t在主串s中首次出现位置的算法。 解： int S_index(SString s, SString t) { //找到返回下标(>=1)，否则返回0;串类型为SString int n,m,i,j; m=strlen(s); n=strlen(t); for (i=0; i<=m-n; i++){ for (j=0; j if(j==n) return(i+1); } return(0); } 第五章数组和广义表 5.1 数组的定义 在C语言中，一个二维数组类型可以定义为其分量类型为一维数组类型的一维数组类型，也就是说：typedef elemtype array2[m][n]; 等价于： typedef elemtype array1[n]; typedef array1 array2[m]; 数组一旦被定义，它的维数和维界就不再改变。因此，除了结构的初始化和销毁之外，数组只有存取元素和修改元素值的操作。 5.2 数组的存储方式 数组一般采用顺序存储，又分为行优先和列优先。数组的地址计算具有以下前提三要素： ①开始结点的存放地址（即基地址）。 ②维数和每维的上、下界。 ③每个数组元素所占用的单元数 L。 设一般的二维数组是A[c1..d1, c2..d2]，这里c1,c2不一定是0。 行优先存储时的地址公式为：LOC(a ij)=LOC(a c1,c2)+[(i-c1)*(d2-c2+1)+(j-c2)]*L。其中，c1,c2为数组基地址，i-c1为a ij之前的行数，d2-c2+1为总列数，j-c2为a ij本行前面元素个数，L为单个元素长度。 列优先存储的通式为：LOC(a ij)=LOC(a c1,c2)+[(j-c2)*(d1-c1+1)+(i-c1)]*L。 5.3 特殊矩阵 1.对称矩阵 （1）定义 在一个n阶方阵A中，若元素满足下述性质：aij=aji（0≤i, j≤n-1），即元素关于主对角线对称。 （2）存储方式 不失一般性，按“行优先顺序”存储主对角线以下元素，存储空间节省一半，如下所示：a11 a21 a 22 a31 a32 a33 ……………….. a n1 a n2 a n3…a nn 在这个下三角矩阵中，i 行(0≤i 若i≥j，则aij在下三角矩阵中。 aij之前的i行(从第0行到第i-1行)一共有 1+2+…+i=i*(i+1)/2 个元素，在第i行上 aij 之前恰有j个元素(即ai0,ai1,ai2,…,aij-1)，因此：k=i*(i+1)/2+j，0≤k 若i 得到：k=j*(j+1)/2+i，0≤k 令 I=max(i,j), J=min(i,j), 则k和i,j的对应关系统一为： k=I*(I+1)/2+J ，Loc(aij) = Loc(sa[k]) = Loc(sa[0])+k*d 2.三角矩阵 （1）定义 以主对角线划分，三角矩阵有上三角和下三角。上三角矩阵：它的下三角(不包括主对角线)中的元素均为常数。下三角矩阵正好相反，它的主对角线上方均为常数。在大多数情况下，三角矩阵常数为零。 （2）存储方式 三角矩阵中的重复元素c可共享一个存储空间，其余的元素正好有n(n+1)/2个，因此，三角矩阵可压缩存储到向量sa[0..n(n+1)/2]中，其中c存放在向量的最后一个分量中。 上三角矩阵：只存放上三角部分。a00 = sa[0], a01 = sa[1], a02 = sa[2], ……，当i≤j 时，aij在上三角部分中，前面共有i行，共有n+n-1+n-2+…+n-(i-1) = i*n-i*(i-1)/2 =i*(2n-i+1)/2个元素，在第i 行上，aij 前恰好有j-i 个元素。sa[k]和aij对应关系为： 下三角矩阵的存储和对称矩阵用下三角存储类似，a00 =sa[0], a10 =sa[1], a11 = sa[2], …， sa[k]和aij对应关系为： 3.对角矩阵（三对角矩阵为例） （1）定义 对角矩阵中，所有的非零元素集中在以主对角线为中心的带状区域中，即除了主对角线和主对角线相邻两侧的若干条对角线上的元素之外，其余元素皆为零。 （2）存储方式 非零元素仅出现在主对角线(aii, 0≤i≤n-1 )上，紧邻主对角线上面的那条对角线上(aii+1, 0≤i≤n-2)和紧邻主对角线下面的那条对角线上(ai+1 i, 0≤i≤n-2)。显然，当| i-j |>1时，元素aij=0。在一个n*n的三对角矩阵中，只有(n-1)+n+(n-1)个非零元素，故只需3n-2个存储单元，零元已不占用存储单元。 将n*n的三对角矩阵A压缩存放到只有3n-2个存储单元的sa向量中，假设仍按行优先顺序存放 则sa[k]与aij的对应关系为为： 在aij之前有i 行，共有3*i-1个非零元素，在第 i 行，有j-i+1个非零元素，即非零元素aij 的地址为：Loc(aij) = Loc(sa[k]) =LOC(0,0)+[3*i-1+(j-i+1)]*d=LOC(0,0)+(2*i+j)*d。 5.4 稀疏矩阵及存储 1.概念 在实际应用中，经常会遇到另一类矩阵：其矩阵阶数很大，非零元个数较少，零元很多，且非零元的排列无规律可寻，则称这类矩阵为稀疏矩阵。 精确地说，设在的矩阵A中，有s个非零元。令e = s / (m*n)，称e为矩阵A的稀疏因子。通常认为e≤0.05时称矩阵A为稀疏矩阵。 稀疏矩阵由表示非零元的三元组及行列数唯一确定，一个三元组(i, j, aij)唯一确定了矩阵A的一个非零元。 例如：下列三元组表： ( (0,1,12), (0,2,9), (2,0,-3), (2,5,14), (3,2,24), (4,1,18), (5,0,15), (5,3,-7) )，加上(6,7,8) ——矩阵的行数、列数及非零元数便可作为矩阵M的另一种描述： 2.三元组顺序表 假设以顺序存储结构来表示三元组表，则可得到稀疏矩阵的一种压缩存储方法——三元顺序表。其定义如下： #define maxsize 1000 typedef int datatype; typedef struct { int i,j; /* 非零元的行、列下标 */ datatype v; /* 元素值 */ } triplet; typedef struct { triplet data[maxsize]; /* 三元组表 */ int m,n,t; /* 行数、列数、非零元素个数 */ } tripletable; /* 稀疏矩阵类型 */ 因此上面的三元组表的三元组顺序表表示如下： M.data i j v M[0].i=6 0 1 12 M[0].j=7 0 2 9 M[0].t=8 2 0 -3 2 5 14 3 2 24 4 1 18 5 0 15 5 3 -7 显然，三元组顺序表存储会失去随机存取功能。 3.三元组顺序表的转置 一个m×n的矩阵A，它的转置B是一个n×m的矩阵，且a[i][j]=b[j][i]，0≤i 将A转置为B，就是将A的三元组表a.data置换为表B的三元组表b.data，如果只是简单地交换a.data 中i和j的内容，那么得到的b.data将是一个按列优先顺序存储的稀疏矩阵B，要得到按行优先顺序存储的b.data，就必须重新排列三元组的顺序。 解决思路：只要做到：①将矩阵行、列维数互换；②将每个三元组中的i和j相互调换；③重排三元组次序，使mb中元素以N的行(M的列)为主序。 （1）方法一：按M的列序转置 即按mb中三元组次序依次在ma中找到相应的三元组进行转置。为找到M中每一列所有非零元素，需对其三元组表ma从第一行起扫描一遍。由于ma中以M行序为主序,所以由此得到的恰是mb中应有的顺序。 1.以下与数据的存储结构无关的术语是（ c ） C、哈希表 2.一个向量第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是（ B ） B、108 3.假设带头结点的单向循环链表的头指针为head,则该链表为空的判定条件是（C ） C、head–>next= =head 4.若进栈序列为1，2，3，4，5，6，且进栈和出栈可以穿插进行，则不可能出现的出栈序列是（D ） D、2，3，5，1，6，4 5.下列关键字序列中，构成小根堆的是（A ） A、{12，21，49，33，81，56，69，41} 6.下列数据结构中，不属于二叉树的是（A ） A、B树 7.用顺序存储的方法来存储一棵二叉树，存放在一维数组A[1..N]中，若结点A[i]有右孩子，则其右孩子是（C ）。 C、A[2i+1] 8.设树T的高度为4，其中度为1、2、3、4的结点个数分别为4、2、1、1，则T中叶子数为（D ） D、8 9.有数据{53，30，37，12，45，24，96}，从空二叉树开始逐个插入数据来形成二叉排序树，若希望高度最小，则应选择下 面哪个序列输入（B ） B、37，24，12，30，53，45，96 10.对下面有向图给出了四种可能的拓扑序列，其中错误的是（C ） C、5，1，6，3，4，2 11.m阶B-树中所有非终端（除根之外）结点中的关键字个数必须大于或等于( B ) B、[m/2]-1 12.散列文件也称为( C ) B 、索引文件 13.数据结构是（D ） D、相互之间存在一种或多种特定关系的数据元素的集合 14.从逻辑关系来看，数据元素的直接前驱为0个或1个的数据结构只能是（C ） C、线性结构和树型结构 15.设p为指向双向循环链表中某个结点的指针，p所指向的结点的两个链域分别用p→llink和p→rlink表示，则同样表示p 判断： 1.线性表的链式存储结构优于顺序存储错误 2.单链表的每个节点都恰好包含一个指针域错误 3.线性表中的元素都可以是各种各样的，但同一线性表中的数据元素具有相同的特性，因 此属于同一数据对象正确 4.在线性表的顺序存储结构中，逻辑上相邻的两个元素在屋里位置上并不一定紧邻。错 误 5.在线性表的数据结构中，插入和删除元素时，移动元素的个数和该元素的位置有关。正 确 6.顺序存储的线性表可以实现随机存取正确 7.栈一定是顺序存储的线性结构错误 8.一个栈的输入序列为A，B,C,D，可以得到输入序列为C,A,B,D 错误 9.队列是一种后进先出的线性表错误 10.树结构中每个节点最多只有一个直接前驱正确 11.二叉树的前序遍历中，任意一个节点均处于其子树节点的前面正确 12.在栈空的情况下，不能做出出栈操作，否则产生溢出正确 13.在前序遍历二叉树的序列中，任何节点的子树的所有节点都是直接跟在该节点之后正 确 填空： 1.在N个节点的顺序表中删除一个节点平均需要移动（（N-1）/2）个节点，具体的移 动次数取决于（表长N和删除位置） 2.在单链表中除首节点外，任意节点的存储位置都由（直接前驱）节点中的指针指示 3.树中节点的最大层次称为树的（度） 4.由一颗二叉树的前序序列和（中）序列可唯一确定这棵二叉树 5.哈弗曼树的带权路径长度（最小）的二叉树 6.二插排序树任意节点的关键字值（大于）其左子树中各节点的关键字值（小于）其 右子树中的各节点关键字值 7.二分查找法，表中元素必须按（关键字有序）存放 选择： 1.用单链表方式存储的线性表，储存每个节点需要两个域，一个数据域，另一个是（B 指针域） 2.设A1，A2，A3为三个节点；P，10，,2代表地址，则如下的链表存储结构称为（B 单链表） 3.单链表的存储密度（C 小于1） 4.在线性表中（B 中间元素）只有一个直接前驱和一个直接后续 5.两个指针P和Q，分别指向单链表的两个元素P所指元素时Q所指元素前驱的条 件是（D P==Q） 6.在栈中存取数据的原则是（B 后进先出） 7.顺序栈判空的条件是（C top==-1） 8.串是一种特殊的线性表，其特殊性体现在（B 数据元素是一个字符） 9.求字符串T和字符串S中首次出现的位置的操作为（C 串的模式匹配） 10.深度为H的二叉树至多有（B 2H-1）个节点 (A )数据的逻辑结构 (B )数据的存储结构 《数据结构》专升本考试试题 (2015 年 3 月) (C )数据的逻辑结构和存储结构 12.算法分析的两个主要方面是( (A )空间复杂度和时间复杂度 (C )可读性和文档性 (D )数据的逻辑结构、存储结构及其基本操作 )o (B )正确性和简单性 (D )数据复杂性和程序复杂性 一、单项选择题(本大题共 20小题，每小题2分，共40分) 1 ?对于一个算法，当输入非法数据时，也要能作出相应的处理，这种要求称为( (A) 正确性 (B) 可行性 ( C) 健壮性 2 ?设S 为C 语言的语句,计算机执行下面算法时， for(i=n-1 ； i>=0 ； i--) for(j=0 ; jn ext==head (B ) p-> next==NULL (C ) p==NULL (D ) p==head 16. 一个栈的输入序列为： a ，b ，c ，d ，e ，则栈的不可能输出的序列是( )o (A ) a,b,c,d,e (B ) d,e,c,b,a (C ) d,c,e,a,b (D ) e,d,c,b,a 17.设SUBSTR(S,i,k)是求S 中从第i 个字符开始的连续k 个字符组成的子串的操作，则对 5 ?深度为k 的完全二叉树，其叶子结点必在第( (A ) k-1 (B ) k (C ) k-1 和 k (D ) 6?具有60个结点的二叉树，其叶子结点有12个， (A ) 11 ( B ) 13 (C ) 48 ( D 37 利于删除操作 利于随机访问 )层上。 1至k 则度为1的结点数为( 7.图的Depth-First Search(DFS) 遍历思想实际上是二叉树( (A )先序 (B )中序 (C )后序 (D )层序 8 .在下列链队列Q 中，元素a 出队的操作序列为( )遍历方法的推广。 S= ' Beijing&Nanjing '，SUBSTR(S,4,5)=( ) (A )‘iji ng ' (B )' jing& ' (C )' ingNa ' (D ) 'ing&N ' 18.广义表((a),a) 的表尾是( )o (A ) a (B ) (a) (C )() (D ) ((a)) 19. 在一棵具有5层的满二叉树中结点总数为( )o (A ) 31 (B ) 32 (C ) 33 (D ) 16 20. 如果从无向图的任一顶点出发进行一次深度优先搜索即可访问所有顶点，则该图一定是( )o (A )完全图 (B )连通图 (C )有回路 (D ) —棵树 二、填空题(本大题共20个空，每空2分，共40分) Q (A ) (B ) (C ) (D ) p=Q.fr ont->n ext; p->n ext= Q.front->n ext; p=Q.fr ont->n ext; Q.front->n ext=p->n ext; p=Q.rear- >n ext; p->n ext= Q.rear- >n ext; p=Q->n ext; Q->n ext=p->n ext; 1 .逻辑结构决定了算法的 ____________ ，而存储结构决定了算法的 _____________ o 2. _______________________ 栈和队列都是一种 ______________________ 的线性表，栈 和删除只能在 ______________ 进行。 3. 线性表(a 1,a 2,…,a n )的顺序存储结构中，设每个单元的长度为L,元素a i 的存储地址LOC 4. 已知一双向链表如下(指针域名为next 和prior): 9. Huffman 树的带权路径长度WP 等于( (A )除根结点之外的所有结点权值之和 (C )各叶子结点的带权路径长度之和 )域存储后继结点的地址。 (C ) rchild (D ) root )o 10?线索二叉链表是利用( (A ) Ichild (B ) data 11 ?研究数据结构就是研究( (B ) (D ) ) 所有结点权值之和 根结点的值 现将p 所指的结点插入到x 和y 结点之间，其操作步骤为： ________________________ 5 . n 个结点无向完全图的的边数为 ________________________ ， n 个结点的生成树的边 为 ____________________ o 2017年数据结构期末考试题及答案 一、选择题（共计50分，每题2分，共25题） 1 ?在数据结构中，从逻辑上可以把数据结构分为 C 。 A. 动态结构和静态结构B?紧凑结构和非紧凑结构 C.线性结构和非线性结构 D .内部结构和外部结构 2?数据结构在计算机内存中的表示是指 A ° A. 数据的存储结构 B.数据结构 C.数据的逻辑结构 D .数据元 素之间的关系 3.在数据结构中，与所使用的计算机无关的是数据的 A 结构。 A. 逻辑B?存储 C.逻辑和存储 D.物理 4 .在存储数据时，通常不仅要存储各数据元素的值，而且还要存储 C ° A.数据的处理方法B?数据元素的类型 C.数据元素之间的关系 D.数据的存储方法 5. 在决定选取何种存储结构时，一般不考虑 A ° A.各结点的值如何B?结点个数的多少 C?对数据有哪些运算 D.所用的编程语言实现这种结构是否方便。 6. 以下说法正确的是D ° A. 数据项是数据的基本单位 B. 数据元素是数据的最小单位 C. 数据结构是带结构的数据项的集合 D. —些表面上很不相同的数据可以有相同的逻辑结构 7. 在以下的叙述中，正确的是B ° A. 线性表的顺序存储结构优于链表存储结构 B. 二维数组是其数据元素为线性表的线性表 C?栈的操作方式是先进先出 D.队列的操作方式是先进后出 8. 通常要求同一逻辑结构中的所有数据元素具有相同的特性，这意味着 A. 数据元素具有同一特点 B. 不仅数据元素所包含的数据项的个数要相同，而且对应的数据项的类型要一致 C. 每个数据元素都一样 D. 数据元素所包含的数据项的个数要相等 9 ?链表不具备的特点是 A 。 A.可随机访问任一结点 B.插入删除不需要移动元素 C?不必事先估计存储空间 D.所需空间与其长度成正比 10. 若某表最常用的操作是在最后一个结点之后插入一个结点或删除最后一 个结点，则采用 D 存储方式最节省运算时间。 A.单链表B ?给出表头指针的单循环链表 C.双链表D ?带头结点 的双循环链表 11. 需要分配较大空间，插入和删除不需要移动元素的线性表，其存储结构是 B 。 A.单链表B .静态链表 C.线性链表 D .顺序存储结构 12 .非空的循环单链表head的尾结点（由p所指向）满足C 。 A. p—>next 一NULL B. p — NULL C. p—>next == head D. p = = head 13 .在循环双链表的p所指的结点之前插入s所指结点的操作是 D 。 A .p—> prior-> prior=s B .p—> prior-> n ext=s C.s —> prior—> n ext = s D.s —> prior—> prior = s 14 .栈和队列的共同点是C 。 A.都是先进后出 B .都是先进先出 C.只允许在端点处插入和删除元素 D .没有共同点 第二章算法分析 1.算法分析是计算机科学的基础 2.增长函数表示问题（n）大小与我们希望最优化的值之间的关系。该函数表示了该算法的时间复杂度或空间复杂度。增长函数表示与该问题大小相对应的时间或空间的使用 3.渐进复杂度：随着n的增加时增长函数的一般性质，这一特性基于该表达式的主项，即n 增加时表达式中增长最快的那一项。 4.渐进复杂度称为算法的阶次，算法的阶次是忽略该算法的增长函数中的常量和其他次要项，只保留主项而得出来的。算法的阶次为增长函数提供了一个上界。 5.渐进复杂度：增长函数的界限，由增长函数的主项确定的。渐进复杂度类似的函数，归为相同类型的函数。 6.只有可运行的语句才会增加时间复杂度。 7. O() 或者大O记法：与问题大小无关、执行时间恒定的增长函数称为具有O（1）的复杂度。 增长函数阶次 t(n)=17 O(1) t(n)=3log n O(log n) t(n)=20n-4 O(n) t(n)=12n log n + 100n O(n log n) t(n)=3n2+ 5n - 2 O(n2) t(n)=8n3+ 3n2O(n3) t(n)=2n+ 18n2+3n O(2n) 8.所有具有相同阶次的算法，从运行效率的角度来说都是等价的。 9.如果算法的运行效率低，从长远来说，使用更快的处理器也无济于事。 10.要分析循环运行，首先要确定该循环体的阶次n，然后用该循环要运行的次数乘以它。（n 表示的是问题的大小） 11.分析嵌套循环的复杂度时，必须将内层和外层循环都考虑进来。 12.方法调用的复杂度分析： 如：public void printsum(int count){ int sum = 0 ; for (int I = 1 ; I < count ; I++) sum += I ; System.out.println(sun); } printsum方法的复杂度为O（n）,计算调用该方法的初始循环的时间复杂度，只需把printsum方法的复杂度乘以该循环运行的次数即可。所以调用上面实现的printsum方法的复 杂度为O（n2）。 13指数函数增长> 幂函数增长> 对数函数增长 1.什么是最小生成树？简述最小生成树的Prime算法的思想。 答：最小生成树就是构造一棵生成树，使得树上各边的代价之和最小。 普里姆算法(Prim)的基本思想： 从连通网络N = { V, E }中的某一顶点u0 出发，选择与它关联的具有最小权值的边(u0, v)，将其顶点加入到生成树的顶点集合U中。以后每一步从一个顶点在U中，而另一个顶点不在U中的各条边中选择权值最小的边(u, v),把它的顶点加入到集合U中。如此继续下去，直到网络中的所有顶点都加入到生成树顶点集合U中为止。 2.简述AOV网络中为何不能出现回路，如何判断AOV网络是否有回路？ 答：在AOV网络中，如果活动vi必须在vj之前进行，则称为存在有向边；在AOV网络中不能出现有向回路，如果出现了，则意味着某项活动应以自己作为先决条件。 如何检查AOV网是否存在有向环： 检测有向环的一种方法是对AOV网络构造它的拓扑有序序列。即将各个顶点(代表各个活动)排列成一个线性有序的序列，使得AOV网络中所有应存在的前驱和后继关系都能得到满足。（1）这种构造AOV网络全部顶点的拓扑有序序列的运算就叫做拓扑排序。 （2）如果通过拓扑排序能将AOV网络的所有顶点都排入一个拓扑有序的序列中，则该AOV 网络中必定不会出现有向环；相反，如果得不到满足要求的拓扑有序序列，则说明AOV网络中存在有向环，此AOV网络所代表的工程是不可行的。 3.为何需要采用循环队列？n个空间的循环队列，最多存储多少个元素？为什 么？ 答：循环队列以克服顺序队列的"假上溢"现象，能够使存储队列的向量空间得到充分的利用，所以采用循环队列。 n个空间的循环队列，最多存储n-1个元素，那是为了区别循环队列的队空和队满的条件。队空的条件是Q.front==Q.rear，而队满的条件是(Q.rear+1)%N==Q.front(N是数组中单元的总数)，因此，Q.rear所指向的数组单元处于未用状态。所以说，N个单元的数组所存放的循环队列最大长度是N-1。 4.简述堆的删除算法，其删除的是那个值？ 答：堆的删除算法：首先，移除根节点的元素（并把根节点作为当前结点）比较当前结点的两个孩子结点的元素大小，把较大的那个元素移给当前结点，接着把被移除元素的孩子结点作为当前结点，并再比较当前结点的孩子的大小，以此循环，直到最后一个叶子结点的值大于或等于当前结点的孩子结点或孩子结点的位置超过了树中元素的个数，则退出循环。最后把最后叶子结点的元素移给当前结点。 在堆的算法里面，删除的值为根值。 5.线索二叉树中，什么是线索，它是否唯一？可有根据什么顺序得到？ 山东:07年专升本考试数据结构模拟试题1 一、填空题:(每小题2分,共10分 1. 设有数据结构(D,R,其中 D 是数据元素的有限集,R 是的有限集。 2. 深度为 k 的二叉树其结点数至多有个。 3. 栈是一种特殊的线性表,它允许在表的一端进行操作。 4. 通常象交通、道路问题的数学模型是一种称为的数据结构。 5. 哈希表是一种查找表,可以根据哈希函数直接获得。 二、单项选择题:(每小题2分,共10分 对于下列各题,在备选答案中选出一个正确的,并将其编号填在“”位置上。 1. 若线性表最常用的操作是存取第 i 个元素及其前驱元素的值,则采用存储方式最节省运算时间。 A. 单链表 B. 双链表 C. 单循环链表 D. 顺序表 2. 下列排序算法中,算法在进行一趟相应的排序处理结束后不一定能选出一个元素放到其最终位置上。。 A. 直选择排序 B. 冒泡排序 C. 归并排序 D. 堆排序 3. 队列的操作原则是。 A. 先进后出 B. 先进先出 C. 只能进行插入 D. 只能进行删除 4. 在具有 n 个结点的二叉链表中,非空的链域个数为。 A. n-1 B. n C. n+1 D. 不确定 5. 对具有 n 个元素的有序查找表采用折半查找算法查找一个键值,其最坏比较次数的数量级为。 A. O(log2n B. O(n C. O(nlog2n D. O(n2 三、判断题:(每小题2分,共10分 判断下列各题是否正确,若正确,在题后的括号内填“T”,否则填“F”。 1. 在栈为空的情况下不能作出栈处理,否则,将产生下溢出。( 2. 如果有向图 G=(V, E 的拓扑序列唯一,则图中必定仅有一个顶点的入度为0、一个顶点的出度为0。( 3. 在大根堆中,必定满足每个结点的键值大于其左右子树中所有结点的键值。( 4. 在采用线性探测法处理冲突的散列表中所有同义词在表中相邻。( 5. 在索引顺序表中,对索引表既可采用顺序查找,也可采用二分查找。( 四、解答下列各题:(每题10分,共40分 1. 已知线性表 L 采用带头结点的的单向循环链表表示,试给出它的存储结构类型描述及相应的示意图。。 2. 已知一棵二叉树的先序、中序和后序序列如下所示,请填写各序列中空格处的结点,并画出该二叉树的二叉链表存储结构示意图。 先序序列是:_ B _ F _ I C E H _ G;中序序列是:D _ K F I A _ E J C _ ; 后序序列是:_ K _ F B H J _ G _ A 3. 已知数据表为(48,70,33,65,24,56,12,92,86,22,a 写出采用快速排序算法进行排序时第一趟快速划分的详细过程及结果;b 写出按基数排序思想对最低位进行一次分配和收集的结果。 4. 对图1所示的带权无向图,写出它的邻接矩阵和深度优先搜索序列,并按克鲁斯卡算法求其最小生成树(写出求解的详细过程示意图。 图1 带权无向图 五、算法设计题:(前两题必做,每题15分,共30分;第三题为附加题,选做,10分 第一章 1、数据结构是一门研究非数值计算的程序设计问题中计算机的操作对象以及它们之间的关系和操作等的学科。 数据结构(Data Structure)：相互之间存在一种或多种特定关系的数据元素的集合。 2、数据结构的形式定义：二元组Data_Structure=(D,S) 其中，D 是数据元素的有限集，S 是D 上关系的有限集。 3、数据元素之间关系的映像：１、顺序映像(顺序存储结构)：以相对的存储位置表示后继关系。 2、非顺序映像(链式存储结构)：借助指针元素存储地址的指针表示数据元素之间的逻辑关系。 任何一个算法的设计取决于数据(逻辑)结构，其实现取决于物理结构。 4、 算法的定义：对特定问题求解步骤的一种描述，它是指令的有限序列，其中每一条指令表示一个或多个操作。 特性：有穷性、确定性、可行性、输入、输出 5、 算法的评价——衡量算法优劣的标准 正确性(correctness):满足具体问题的需求 可读性(readability)：易读、易理解 健壮性(robustness):当输入数据非法时，算法能够做出反应或进行处理 效率与低存储量:执行时间短、存储空间小 作业的答案：试描述数据结构和抽象数据类型的概念与程序设计语言中数据类型概念的区别。 第二章 1、线性表是一种最简单的线性结构。 线性结构 是一个数据元素的有序（次序）关系 特点：存在唯一的一个“第一个”的数据元素；存在唯一的一个“最后一个”的数据元素；除第一个数据元素外，均有唯一的前驱；除最后一个数据元素外，均有唯一的后继 2、线性表类型的实现——顺序映像 定义：用一组地址连续的存储单元依次存放线性表中的数据元素。 ? 以“存储位置相邻”表示有序对 复习提纲 第一章数据结构概述 基本概念与术语（P3） 1．数据结构是一门研究非数值计算程序设计问题中计算机的操作对象以及他们之间的关系和操作的学科. 2．数据是用来描述现实世界的数字,字符,图像,声音,以及能够输入到计算机中并能被计算机识别的符号的集合 2．数据元素是数据的基本单位 3．数据对象相同性质的数据元素的集合 4．数据结构包括三方面内容:数据的逻辑结构.数据的存储结构.数据的操作. （1）数据的逻辑结构指数据元素之间固有的逻辑关系. （2）数据的存储结构指数据元素及其关系在计算机内的表示 ( 3 ) 数据的操作指在数据逻辑结构上定义的操作算法,如插入,删除等. 5.时间复杂度分析 -------------------------------------------------------------------------------------------------------------------- 1、名词解释：数据结构、二元组 2、根据数据元素之间关系的不同，数据的逻辑结构可以分为 集合、线性结构、树形结构和图状结构四种类型。 3、常见的数据存储结构一般有四种类型，它们分别是___顺序存储结构_____、___链式存储结构_____、___索引存储结构_____和___散列存储结构_____。 4、以下程序段的时间复杂度为___O(N2)_____。 int i,j,x; for(i=0;i 一．是非题 （正确的打“√”，错误的打“×”。） 1. 数据结构可用三元式表示（D，S，P）。其中：D是数据对象，S是D上的关系集， P是对D的基本操作集。× 2. 线性表的链式存储结构具有可直接存取表中任一元素的优点。× 3. 字符串是数据对象特定的线性表。 4. 二叉树是一棵结点的度最大为二的树。× 5．邻接多重表可以用以表示无向图，也可用以表示有向图。× 6．可从任意有向图中得到关于所有顶点的拓扑次序。× 7．一棵无向连通图的生成树是其极大的连通子图。× 8．二叉排序树的查找长度至多为log2ｎ。× 9．对于一棵m阶的B-树.树中每个结点至多有m 个关键字。除根之外的所有非终端结点至少有┌m/2┐个关键字。× 10．对于目前所知的排序方法，快速排序具有最好的平均性能。√ 11. 顺序存储方式的优点是存储密度大，且插入、删除运算效率高。× 12. 二维数组是其数据元素为线性表的线性表。√ 13. 连通图G的生成树是一个包含G的所有n个顶点和n-1条边的子图。× 14. 折半查找不适用于有序链表的查找。√ 15. 完全二叉树必定是平衡二叉树。√ 16. 中序线索二叉树的优点是便于在中序下查找直接前驱结点和直接后继结点。√ 17. 队列是与线性表完全不同的一种数据结构。× 18. 平均查找长度与记录的查找概率有关。√ 19. 二叉树中每个结点有两个子结点，而对一般的树，则无此限制，所以，二叉树是树的特殊情形。× 20. 算法的时间复杂性越好，可读性就越差；反之，算法的可读性越好，则时间复杂性就越差。× 二．选择题 1. 若对编号为1，2，3的列车车厢依次通过扳道栈进行调度，不能得到 (e ) 的序列。 a:1,2,3 b:1,3,2 c:2,1,3 d:2,3,1 e:3,1,2 f:3,2,1 2. 递归程序可借助于( b )转化为非递归程序。 a:线性表 b: 栈 c:队列 d:数组 3. 在下列数据结构中(c)具有先进先出（FIFO）特性，( b )具有先进后出(FILO）特性。 a:线性表 b:栈 c:队列 d:广义表 4. 对字符串s=’data-structure’ 执行操作replace(s,substring(s,6,8),’bas’) 的结果是 ( d ) 。 a: ‘database’ b: ‘data-base’ c: ‘bas’ d: ‘data-basucture’ 《数据结构》专升本考试试题 (2015年3月) 一、单项选择题(本大题共20小题,每小题2分,共40分) 1.对于一个算法,当输入非法数据时,也要能作出相应的处理,这种要求称为( )。 (A) 正确性 (B) 可行性 (C) 健壮性 (D) 输入性 2.设S为C语言的语句,计算机执行下面算法时,算法的时间复杂度为( )。 for(i=n-1;i>=0;i--) for(j=0;j 2005年－2006学年第二学期“数据结构”考试试题（A） 姓名学号(序号)_ 答案隐藏班号 要求：所有的题目的解答均写在答题纸上（每张答题纸上要写清楚姓名、班号和学号），需写清楚题目的序号。每张答题纸都要写上姓名和序号。 一、单项选择题（每小题2分，共20分） 1．数据的运算a 。 A.效率与采用何种存储结构有关 B.是根据存储结构来定义的 C.有算术运算和关系运算两大类 D.必须用程序设计语言来描述 答：A。 2. 链表不具备的特点是 a 。 A.可随机访问任一结点 B.插入删除不需要移动元素 C.不必事先估计存储空间 D.所需空间与其长度成正比 答：参见本节要点3。本题答案为：A。 3. 在顺序表中删除一个元素的时间复杂度为 c 。 A.O(1) B.O(log2n) C.O(n) D.O(n2) 答：C。 4．以下线性表的存储结构中具有随机存取功能的是 d 。 A. 不带头结点的单链表 B. 带头结点的单链表 C. 循环双链表 D. 顺序表 解 D。 5. 一个栈的进栈序列是a，b，c，d，e，则栈的不可能的输出序列是 c 。 A.edcba B.decba C.dceab D.abcde 答：C。 6. 循环队列qu的队空条件是 d 。 A. (qu.rear+1)%MaxSize==(qu.front+1)%MaxSize B. (qu.rear+1)%MaxSize==qu.front+1 C.(qu.rear+1)%MaxSize==qu.front D.qu.rear==qu.front 答：D。 7. 两个串相等必有串长度相等且 b 。 A.串的各位置字符任意 B.串中各位置字符均对应相等 C.两个串含有相同的字符 D.两个所含字符任意 答：B。 8. 用直接插入排序对下面四个序列进行递增排序，元素比较次数最少的是c 。 A.94,32,40,90,80,46,21,69 B.32,40,21,46,69,94,90, 80 C.21,32,46,40,80,69,90,94 D.90,69,80,46,21,32,94, 40 答：C。 9. 以下序列不是堆（大根或小根）的是 d 。 A.{100,85,98,77,80,60,82,40,20,10,66} B.{100,98,85,82,80, 77,66,60,40,20,10} C.{10,20,40,60,66,77,80,82,85,98,100} D.{100,85,40,77,80, 60,66,98,82,10,20} 1. 快速排序在最坏情况下的时间复杂度为（ D ）。 A．O(log 2n) B．O(nlog 2 n) C．O (n) D. O (n2) 2．设一棵二叉树的深度为k，则该二叉树中最多有（ D ）个结点。 A. 2k-1 B. 2k C.2k-1 D. 2k-1 3．二叉树中第i(i≥1)层上的结点数最多有（ C ）个。 A. 2i B. 2i C. 2i-1 D. 2i-1 4．设指针变量p指向单链表结点A，则删除结点A的后继结点B需要的操作为（ A ）。 A. p->next=p->next->next B. p=p->next C. p=p->next->next D. p->next=p 5．设栈S和队列Q的初始状态为空，元素E1、E2、E3、E4、E5和E6依次通过栈S，一个元素出栈后即进入队列Q，若6个元素出列的顺序为E2、E4、E3、E6、E5和E1，则栈S的容量至少应该是（ C ）。 A. 6 B. 4 C. 3 D. 2 6.设有以下四种排序方法，则（ B ）的空间复杂度最大。 A. 冒泡排序 B. 快速排 C. 堆排序 D. 希尔排序7．设结点A有3个兄弟结点且结点B为结点A的双亲结点，则结点B的度数数为（ B ）。 A. 3 B. 4 C. 5 D. 1 8．根据二叉树的定义可知二叉树共有（ B ）种不同的形态。 A. 4 B. 5 C. 6 D. 7 9．对一个算法的评价，不包括如下（ A ）方面的内容。 A．并行性 B．健壮性和可读性 C．正确性 D．时空复杂度10．在二叉排序树中插入一个结点的时间复杂度为（ C ）。 A．O(1) B．O(n) C．O(log 2 n) D．O(n2) 11. 队列是一种（ B ）的线性表。 A．先进后出B．先进先出 C．只能插入D．只能删除 数据结构期末复习题 一、选择题 1.以下说法中不正确的是（D）。 A.数据元素是数据的基本单位 B.数据项是不可分割的最小可标识单位 C.数据可由若干个数据元素构成 D.数据项可由若干个数据元素构成 2.计算机所处理的数据一般具备某种内在联系，这是指（B）。 A.数据和数据之间存在某种关系 B.元素和元素之间存在某种关系 C.元素内部具有某种结构 D.数据项和数据项之间存在某种关系 3.在数据结构中，与所使用的计算机无关的是数据的（A）结构。 A.逻辑 B.存储 C.逻辑和存储 D.物理 4.数据的逻辑结构可以分为（C）两类。 A.动态结构和静态结构 B.紧凑结构和非紧凑结构 C.线性结构和非线性结构 D.内部结构和外部结构 5.数据的逻辑结构是指（A）关系的整体。 A.数据元素之间逻辑 B.数据项之间逻辑 C.数据类型之间 D.存储结构之间 6.以下数据结构中（D）属非线性结构。 A.栈 B.串 C.队列 D.平衡二叉树 7.以下属于逻辑结构的是（C）。 A.顺序表 B.哈希表 C.有序表 D.单链表 8.以下不属于存储结构的是（A）。 A.栈 B.线索二叉树 C.哈希表 D.双链表 9.在计算机中存储数据时，通常不仅要存储个数据元素的值，而且还要存储（C）。 A.数据的处理方法 B.数据元素的类型 C.数据元素之间的关系 D.数据的存储方法 10.数据结构在计算机内存中的表示是指（A）。 A.数据的存储结构 B.数据结构 C.数据的逻辑结构 D.数据元素之间的关系 11.在数据的存储结构中，一个结点通常存储一个（B）。 A.数据项 B.数据元素 C.数据结构 D.数据类型 12.在决定选择何种类型的存储结构时，一般不多考虑（A）。 专升本《数据结构》 一、（共75题,共150分） 1. 数据的基本单位是（）。（2分） A.数据元素 B.记录 C.数据对象 D.数据项 .标准答案：A 2. （）是数据的不可分割的最小单位。（2分） A.数据对象 B.数据元素 C.数据类型 D.数据项 .标准答案：D 3. 算法的空间复杂度是对算法（）的度量。（2分） A.时间效率 B.空间效率 C.可读性 D.健壮性 .标准答案：B 4. （）是限制了数据元素的内部结构仅为一个字符的线性表。（2分） A.栈 B.队列 C.串 D.数组 .标准答案：B 5. 串的长度是指串中所含（）的个数。（2分） A.不同字符 B.不同字母 C.相同字符 D.所有字符 .标准答案：D 6. 采用带头结点双向链表存储的线性表，在删除一个元素时，需要修改指针（）次。（2分） A.1 B.2 C.3 D.4 .标准答案：B 7. 线性表的顺序存储结构是一种（）的存储结构。（2分） A.顺序存取 B.随机存取 C.索引存取 D.Hash存取 .标准答案：B 8. 数组a[1..m]采用顺序存储，a[1]和a[m]地址分别为1024和1150，每个元素占2字节，则m是（）。（2分） A.64 B.32 C.16 D.8 .标准答案：A 9. 深度为h的二叉树，第h层最多有（）个结点。（2分） A.h B.2h-1 C.2h-1 D.2h .标准答案：C 10. m个结点的二叉树，其对应的二叉链表共有（）个非空链域。（2分） A.m B.m+1 C.2m D.m-1 .标准答案：B 11. 下面叙述错误的是（）。（2分） A.顺序表是借助物理单元相邻表示数据元素之间的逻辑关系 B.对于空队列进行出队操作过程中发生下溢现象 C.有向图的邻接矩阵一定是对称的 D.具有相同的叶子个数和具有相同的叶子权值的赫夫曼树不是唯一的 .标准答案：C 12. 以下与数据的存储结构无关的术语是（）。（2分） A.循环队列 B.双向链表 C.哈希表 D.数组 .标准答案：D 13. 在一个长度为n的链式栈中出栈实现算法的时间复杂度为（）。（2分） A.O(1) B.O(log n) C.O(n) D.O(n2) .标准答案：A 14. 在具有k个度数为2的二叉树中，必有（）个叶子结点。（2分） A.k B.k-1 C.2k D.k+1 .标准答案：D 15. 在关键字序列（10,20,30,40,50）中，采用折半法查找20，关键字之间比较需要（）次。（2分） A.1 B.2 C.3 D.4 .标准答案：C 16. 16某二叉树的后序遍历序列和和中序遍历序列均为abcd，该二叉树的前序遍历序列是（）。（2分） A.abcd B.dcba C.acbd D.dbca .标准答案：B 17. n个顶点的无向连通图的生成树，至少有（）个边。（2分） A.n(n-1) B.n(n-1)/2 C.2n D.n-1 .标准答案：D 18. 可以采用（）这种数据结构，实现二叉树的层次遍历运算。（2分） A.队列 B.树 C.栈 D.集合 .标准答案：A 《数据结构》试题（100分） （供2005级信息管理与信息系统本科专业使用） 学号： 姓名： 座号： 系别： 年级： 专业： 总分合计人： 复核人： 说明：本试卷分为两部分，第I 卷（选择题和判断题）必须在“答题卡”上按规定要求填、涂；第II 卷直接在试卷上作答。不按规定答题、填涂，一律无效。 第I 卷 一、试题类型：单项选择题（每小题2分，共40分） （类型说明：在每小题列出的四个选项中只有一个选项是符合题目要求的，请选出正确选项并在“答题卡”的相应位置上涂黑。多涂、少涂、错误均无分。） 1. 算法分析的两个主要方面是： （ ） （A) 空间复杂性和时间复杂性 （B) 正确性和简明性 （C) 可读性和文档性 （D) 数据复杂性和程序复杂性 2. 计算机算法指的是： （ ） （A) 计算方法 （B) 排序方法 （C) 解决问题的有限运算序列 （D) 调度方法 3． 数据在计算机存储器内表示时，物理地址与逻辑地址相同并且是连续的，称为：（ ） （A ）存储结构 （B ）逻辑结构 （C ）顺序存储结构 （D ）链式存储结构 4.一个向量第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是 。 （ ） （A ）110 （B ）108 （C ）100 （D ）120 5. 链接存储的存储结构所占存储空间： （ ） （A ）分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针 （B ）只有一部分，存放结点值 （C ） 只有一部分，存储表示结点间关系的指针 （D ） 分两部分，一部分存放结点值，另一部分存放结点所占单元数 6. 线性表若采用链式存储结构时，要求内存中可用存储单元的地址: （ ） （A ）必须是连续的 （B ）部分地址必须是连续的 （C ）一定是不连续的 （D ）连续或不连续都可以《数据结构》期末复习题答案
数据结构期末考试复习笔记
专升本试题(数据结构)
2017年数据结构期末考试题及答案A
数据结构复习资料,java数据结构期末考试
数据结构 期末考试复习题及答案
山东07年专升本考试数据结构模拟试题.
数据结构期末复习资料[1]
数据结构复习提纲(整理)
数据结构学生期末复习卷习题答案
专升本试题数据结构
数据结构期末考试试题含答案
数据结构-复习资料
(完整word版)数据结构期末复习题
专升本《数据结构》_试卷_答案
数据结构期末考试试题答案详解
- (完整word版)数据结构复习要点(汇总版),推荐文档
- 河北工程大学之数据结构(c语言版)复习资料
- 数据结构复习资料(亲自整理)
- 数据结构复习资料
- 数据结构复习资料java数据结构期末考试
- 复习总结资料(数据结构导论)
- 数据结构(c语言版)复习资料
- 《数据结构(C语言版)》复习重点
- 数据结构总复习资料(完整版)
- 数据结构复习资料
- 西安交通大学数据结构复习资料
- 数据结构C语言版期末考试复习题库
- 数据结构复习要点整理版
- 数据结构(第4版)习题及实验参考答案数据结构复习资料完整版(c语言版)
- 数据结构复习提纲(整理)
- 数据结构复习重点归纳
- 数据结构总复习资料(完整版)
- 数据结构复习要点(整理版).docx
- 数据结构严蔚敏C语言版学习复习提纲
- 数据结构复习重点归纳(适于清华严蔚敏)