数据结构(C语言版)习题答案.doc

《数据结构(C语言版)习题答案.doc》由会员分享，可在线阅读，更多相关《数据结构(C语言版)习题答案.doc（48页珍藏版）》请在三一办公上搜索。

1、数据结构(C语言版)习题答案 第1章 绪论习题1简述下列概念：数据、数据元素、数据项、数据对象、数据结构、逻辑结构、存储结构、抽象数据类型。2试举一个数据结构的例子，叙述其逻辑结构和存储结构两方面的含义和相互关系。3简述逻辑结构的四种基本关系并画出它们的关系图。4存储结构由哪两种基本的存储方法实现？5选择题（1）在数据结构中，从逻辑上可以把数据结构分成（ ）。A动态结构和静态结构 B紧凑结构和非紧凑结构C线性结构和非线性结构 D ）。A存储结构 B存储实现C逻辑结构 D运算实现（3）通常要求同一逻辑结构中的所有数据元素具有相同的特性，这意味着（ ）。A数据具有同一特点B不仅数据元素所包含的数据

2、项的个数要相同，而且对应数据项的类型要一致C每个数据元素都一样D数据元素所包含的数据项的个数要相等（4）以下说法正确的是（ ）。A数据元素是数据的最小单位B数据项是数据的基本单位C数据结构是带有结构的各数据项的集合D一些表面上很不相同的数据可以有相同的逻辑结构（5）以下与数据的存储结构无关的术语是（ ）。A顺序队列 B. 链表 C. 有序表 D. 链栈（6）以下数据结构中，（ ）是非线性数据结构A树 B字符串 C队 D栈6试分析下面各程序段的时间复杂度。（1）x=90; y=100;while(y>0)if(x>100)x=x-10;y-;else x+;（2）for (i=0;

3、i<n; i+)for (j=0; j<m; j+)aij=0;（3）s=0;for i=0; i<n; i+) for(j=0; j<n; j+)s+=Bij;sum=s;（4）i=1;while(i<=n)i=i*3;（5）x=0;for(i=1; i<n; i+)for (j=1; j<=n-i; j+)x+;（6）x=n; /n>1y=0;while(x(y+1)* (y+1)y+; （1）O（1）（2）O（m*n）（3）O（n2）（4）O（log3n）（5）因为x+共执行了n-1+n-2+1= n(n-1)/2，所以执行时间为O（n2）

4、（6）O(n) 第2章 线性表1选择题（1）一个向量第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是（ ）。A110 B108 C100 D120（2）在n个结点的顺序表中，算法的时间复杂度是O(1)的操作是（ ）。A访问第i个结点（1in）和求第i个结点的直接前驱（2in）B在第i个结点后插入一个新结点（1in）C删除第i个结点（1in）D将n个结点从小到大排序（3） 向一个有127个元素的顺序表中插入一个新元素并保持原来顺序不变，平均要移动 的元素个数为（ ）。A8 B63.5 C63 D7（4）链接存储的存储结构所占存储空间（ ）。A分两部分，一部分存放结点值，另一

5、部分存放表示结点间关系的指针B只有一部分，存放结点值C只有一部分，存储表示结点间关系的指针D分两部分，一部分存放结点值，另一部分存放结点所占单元数（5）线性表若采用链式存储结构时，要求 ）。A必须是连续的 B部分地址必须是连续的C一定是不连续的 D连续或不连续都可以（6）线性表在（ ）情况下适用于使用链式结构实现。A需经常修改中的结点值 需不断对进行删除插入C中含有大量的结点 中结点结构复杂（7）单链表的存储密度（ ）。A大于1 B等于1 C小于1 D不能确定（8）将两个各有n个元素的有序表归并成一个有序表，其最少的比较次数是（ ）。An B2n-1 C2n Dn-1（9）在一个长度为n的顺序

6、表中，在第i个元素（1in+1）之前插入一个新元素时须向后移动（ ）个元素。An-i Bn-i+1 Cn-i-1 Di(10) 线性表L=(a1，a2,an)，下列说法正确的是（ ）。A每个元素都有一个直接前驱和一个直接后继B线性表中至少有一个元素C表中诸元素的排列必须是由小到大或由大到小D除第一个和最后一个元素外，其余每个元素都有一个且仅有一个直接前驱和直接后继。(11) 若指定有n个元素的向量，则建立一个有序单链表的时间复杂性的量级是（ ）。AO(1) BO(n) CO(n2) DO(nlog2n) (12) 以下说法错误的是（ ）。A求表长、定位这两种运算在采用顺序存储结构时实现的效率不

7、比采用链式存储结构时实现的效率低B顺序存储的线性表可以随机存取C由于顺序存储要求连续的存储区域，所以在存储管理上不够灵活D线性表的链式存储结构优于顺序存储结构(13) 在单链表中，要将s所指结点插入到p所指结点之后，其语句应为（ ）。As->next=p+1; p->next=s;B(*p).next=s; (*s).next=(*p).next;Cs->next=p->next; p->next=s->next;Ds->next=p->next; p->next=s;(14) 在双向链表存储结构中，删除p所指的结点时须修改指针（ ）。Ap

8、->next->prior=p->prior; p->prior->next=p->next;Bp->next=p->next->next; p->next->prior=p;Cp->prior->next=p; p->prior=p->prior->prior;Dp->prior=p->next->next; p->next=p->prior->prior;(15) 在双向循环链表中，在p指针所指的结点后插入q所指向的新结点，其修改指针的操作是（ ）。Ap-&g

9、t;next=q; q->prior=p; p->next->prior=q; q->next=q;Bp->next=q; p->next->prior=q; q->prior=p; q->next=p->next;Cq->prior=p; q->next=p->next; p->next->prior=q; p->next=q;Dq->prior=p; q->next=p->next; p->next=q; p->next->prior=q; 2算法设计题（1）

10、将两个递增的有序链表合并为一个递增的有序链表。要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。表中不允许有重复的数据。void MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc)pa=La->next; pb=Lb->next;Lc=pc=La; /用La的头结点作为Lc的头结点while(pa && pb)if(pa->data<pb->data) pc->next=pa;pc=pa;pa=pa->next;else if(pa->

11、data>pb->data) pc->next=pb; pc=pb; pb=pb->next; else / 相等时取La的元素，删除Lb的元素pc->next=pa;pc=pa;pa=pa->next;q=pb->next;delete pb ;pb =q;pc->next=pa?pa:pb; /插入剩余段delete Lb; /释放Lb的头结点（2）将两个非递减的有序链表合并为一个非递增的有序链表。要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。表中允许有重复的数据。void union(LinkList& La

12、, LinkList& Lb, LinkList& Lc, ) pa = La->next; pb = Lb->next; / 初始化Lc=pc=La; /用La的头结点作为Lc的头结点Lc->next = NULL; while ( pa | pb ) if ( !pa ) q = pb; pb = pb->next; else if ( !pb ) q = pa; pa = pa->next; else if (pa->data <= pb->data ) q = pa; pa = pa->next; else q =

13、pb; pb = pb->next; q->next = Lc->next; Lc->next = q; / 插入delete Lb; /释放Lb的头结点（3）已知两个链表A和B分别表示两个集合，其元素递增排列。请设计算法求出A与B的交集，并存放于A链表中。void Mix(LinkList& La, LinkList& Lb, LinkList& Lc, ) pa=la->next;pb=lb->next;设工作指针pa和pb；Lc=pc=La; /用La的头结点作为Lc的头结点while(pa&&pb)if(pa-

14、>data=pb->data)交集并入结果表中。 pc->next=pa;pc=pa;pa=pa->next;u=pb;pb=pb->next; delete u;else if(pa->data<pb->data) u=pa;pa=pa->next; delete u;else u=pb; pb=pb->next; delete u;while(pa) u=pa; pa=pa->next; delete u; 释放结点空间while(pb) u=pb; pb=pb->next; delete u;释放结点空间pc->

15、;next=null;置链表尾标记。delete Lb; 注： 本算法中也可对B表不作释放空间的处理 （4）已知两个链表A和B分别表示两个集合，其元素递增排列。请设计算法求出两个集合A和B 的差集（即仅由在A中出现而不在B中出现的元素所构成的集合），并以同样的形式存储，同时返回该集合的元素个数。void Difference（LinkedList A，B，*n）A和B均是带头结点的递增有序的单链表，分别存储了一个集合，本算法求两集合的差集，存储于单链表A中，*n是结果集合中元素个数，调用时为0p=A->next； p和q分别是链表A和B的工作指针。q=B->next； pre=A；

16、 pre为A中p所指结点的前驱结点的指针。while（p!=null && q!=null）if（p->data<q->data）pre=p；p=p->next；*n+； A链表中当前结点指针后移。 else if（p->data>q->data）q=q->next； B链表中当前结点指针后移。else pre->next=p->next； 处理A，B中元素值相同的结点，应删除。 u=p； p=p->next； delete u； 删除结点 （5）设计算法将一个带头结点的单链表A分解为两个具有相同结构的链表B、C

17、，其中B表的结点为A表中值小于零的结点，而C表的结点为A表中值大于零的结点（链表A的元素类型为整型，要求B、C表利用A表的结点）。（6）设计一个算法，通过一趟遍历在单链表中确定值最大的结点。ElemType Max (LinkList L )if(L->next=NULL) return NULL; pmax=L->next; /假定第一个结点中数据具有最大值p=L->next->next;while(p != NULL )/如果下一个结点存在if(p->data > pmax->data) pmax=p;p=p->next;return pma

18、x->data; （7）设计一个算法，通过遍历一趟，将链表中所有结点的链接方向逆转，仍利用原表的存储空间。void inverse(LinkList &L) / 逆置带头结点的单链表 Lp=L->next; L->next=NULL;while ( p) q=p->next; / q指向*p的后继p->next=L->next;L->next=p; / *p插入在头结点之后p = q;（8）设计一个算法，删除递增有序链表中值大于mink且小于maxk的所有元素（mink和maxk是给定的两个参数，其值可以和表中的元素相同，也可以不同 ）。voi

19、d delete(LinkList &L, int mink, int maxk) p=L->next; /首元结点while (p && p->data<=mink) pre=p; p=p->next; /查找第一个值>mink的结点if (p) while (p && p->data<maxk) p=p->next;/ 查找第一个值 maxk 的结点q=pre->next; pre->next=p; / 修改指针while (q!=p) s=q->next; delete q; q=s

20、; / 释放结点空间/if（9）已知p指向双向循环链表中的一个结点，其结点结构为data、prior、next三个域，写出算法change(p),交换p所指向的结点和它的前缀结点的顺序。知道双向循环链表中的一个结点，与前驱交换涉及到四个结点（p结点，前驱结点，前驱的前驱结点，后继结点）六条链。void Exchange（LinkedList p）p是双向循环链表中的一个结点，本算法将p所指结点与其前驱结点交换。 q=p->llink；q->llink->rlink=p； p的前驱的前驱之后继为pp->llink=q->llink； p的前驱指向其前驱的前驱。q-&

21、gt;rlink=p->rlink； p的前驱的后继为p的后继。 q->llink=p； p与其前驱交换p->rlink->llink=q； p的后继的前驱指向原p的前驱p->rlink=q； p的后继指向其原来的前驱算法exchange结束。 （10）已知长度为n的线性表A采用顺序存储结构，请写一时间复杂度为O(n)、空间复杂度为O(1)的算法，该算法删除线性表中所有值为item的数据元素。题目分析 在顺序存储的线性表上删除元素，通常要涉及到一系列元素的移动（删第i个元素，第i+1至第n个元素要依次前移）。本题要求删除线性表中所有值为item的数据元素，并未要求

22、元素间的相对位置不变。因此可以考虑设头尾两个指针（i=1，j=n），从两端向中间移动，凡遇到值item的数据元素时，直接将右端元素左移至值为item的数据元素位置。void Delete（ElemType A ，int n）A是有n个元素的一维数组，本算法删除A中所有值为item的元素。i=1；j=n；设置数组低、高端指针（下标）。while（i<j）while（i<j && Ai!=item）i+； 若值不为item，左移指针。if（i<j）while（i<j && Aj=item）j-；若右端元素值为item，指针左移 if（i<

23、;j）Ai+=Aj-；算法讨论 因元素只扫描一趟，算法时间复杂度为O（n）。删除元素未使用其它辅助空间，最后线性表中的元素个数是j。 第3章 栈和队列习题1选择题（1）若让元素1，2，3，4，5依次进栈，则出栈次序不可能出现在（ ）种情况。A5，4，3，2，1 B2，1，5，4，3 C4，3，1，2，5 D2，3，5，4，1（2）若已知一个栈的入栈序列是1，2，3，n，其输出序列为p1，p2，p3，pn，若p1=n，则pi为（ ）。Ai Bn-i Cn-i+1 D不确定（3）数组用来表示一个循环队列，为当前队列头元素的前一位置，为队尾元素的位置，假定队列中元素的个数小于，计算队列中元素个数的公

24、式为（ ）。Ar-f B(n+f-r)%n Cn+r-f D（n+r-f)%n（4）链式栈结点为：(data,link)，top指向栈顶.若想摘除栈顶结点，并将删除结点的值保存到x中,则应执行操作（ ）。Ax=top->data;top=top->link； Btop=top->link;x=top->link；Cx=top;top=top->link； Dx=top->link；（5）设有一个递归算法如下int fact(int n) /n大于等于0if(n<=0) return 1;else return n*fact(n-1); 则计算fact(

25、n)需要调用该函数的次数为（ ）。A n+1 B n-1 C n D n+2（6）栈在 （ ）中有所应用。A递归调用 B函数调用 C表达式求值 D前三个选项都有（7）为解决计算机主机与打印机间速度不匹配问题，通常设一个打印数据缓冲区。主机将要输出的数据依次写入该缓冲区，而打印机则依次从该缓冲区中取出数据。该缓冲区的逻辑结构应该是（ ）。A队列 B栈 C 线性表 D有序表（8）设栈S和队列Q的初始状态为空，元素e1、e2、e3、e4、e5和e6依次进入栈S，一个元素出栈后即进入Q，若6个元素出队的序列是e2、e4、e3、e6、e5和e1，则栈S的容量至少应该是（ ）。A2 B3 C4 D 6（9

26、）在一个具有n个单元的顺序栈中，假设以地址高端作为栈底，以top作为栈顶指针，则当作进栈处理时，top的变化为（ ）。Atop不变 Btop=0 Ctop- Dtop+（10）设计一个判别表达式中左，右括号是否配对出现的算法，采用（ ）数据结构最佳。A线性表的顺序存储结构 B队列 C. 线性表的链式存储结构 D. 栈（11）用链接方式存储的队列，在进行删除运算时（ ）。A. 仅修改头指针 B. 仅修改尾指针C. 头、尾指针都要修改 D. 头、尾指针可能都要修改（12）循环队列存储在数组A0.m中，则入队时的操作为（ ）。A. rear=rear+1 B. rear=(rear+1)%(m-1)

27、C. rear=(rear+1)%m D. rear=(rear+1)%(m+1)（13）最大容量为n的循环队列，队尾指针是rear，队头是front，则队空的条件是（ ）。A. (rear+1)%n=front B. rear=frontCrear+1=front D. (rear-l)%n=front（14）栈和队列的共同点是（ ）。A. 都是先进先出 B. 都是先进后出C. 只允许在端点处插入和删除元素 D. 没有共同点（15）一个递归算法必须包括（ ）。A. 递归部分 B. 终止条件和递归部分C. 迭代部分 D. 终止条件和迭代部分 （2）回文是指正读反读均相同的字符序列，如“abba

28、”和“abdba”均是回文，但“good”不是回文。试写一个算法判定给定的字符向量是否为回文。(提示：将一半字符入栈)根据提示，算法可设计为：/以下为顺序栈的存储结构定义#define StackSize 100 /假定预分配的栈空间最多为100个元素typedef char DataType;/假定栈元素的数据类型为字符typedef structDataType dataStackSize;int top;SeqStack; int IsHuiwen( char *t)/判断t字符向量是否为回文，若是，返回1，否则返回0SeqStack s;int i , len;char temp;In

29、itStack( &s);len=strlen(t); /求向量长度 for ( i=0; i<len/2; i+)/将一半字符入栈Push( &s, ti);while( !EmptyStack( &s)/ 每弹出一个字符与相应字符比较temp=Pop (&s);if( temp!=Si) return 0 ;/ 不等则返回0else i+;return 1 ; / 比较完毕均相等则返回 1（3）设从键盘输入一整数的序列：a1, a2, a3，an，试编写算法实现：用栈结构存储输入的整数，当ai-1时，将ai进栈；当ai=-1时，输出栈顶整数并出栈。算法

30、应对异常情况（入栈满等）给出相应的信息。#define maxsize 栈空间容量void InOutS(int smaxsize)/s是元素为整数的栈，本算法进行入栈和退栈操作。int top=0; /top为栈顶指针，定义top=0时为栈空。for(i=1; i<=n; i+) /n个整数序列作处理。scanf(“%d”,&x); /从键盘读入整数序列。if(x!=-1) / 读入的整数不等于-1时入栈。if(top=maxsize-1)printf(“栈满n”);exit(0);else s+top=x; /x入栈。 else /读入的整数等于-1时退栈。if(top=0)

31、printf(“栈空n”);exit(0); else printf(“出栈元素是%dn”,stop-)；/算法结束。 （4）从键盘上输入一个后缀表达式，试编写算法计算表达式的值。规定：逆波兰表达式的长度不超过一行，以$符作为输入结束，操作数之间用空格分隔,操作符只可能有+、-、*、/四种运算。例如：234 34+2*$。题目分析逆波兰表达式(即后缀表达式)求值规则如下：设立运算数栈OPND,对表达式从左到右扫描(读入)，当表达式中扫描到数时，压入OPND栈。当扫描到运算符时，从OPND退出两个数，进行相应运算，结果再压入OPND栈。这个过程一直进行到读出表达式结束符$，这时OPND栈中只有一

32、个数，就是结果。float expr( )/从键盘输入逆波兰表达式，以$表示输入结束，本算法求逆波兰式表达式的值。 float OPND30; / OPND是操作数栈。init(OPND); /两栈初始化。float num=0.0; /数字初始化。 scanf (“%c”,&x);/x是字符型变量。while(x!=$)switchcase0<=x<=9:while(x>=0&&x<=9)|x=.) /拼数 if(x!=.) /处理整数num=num*10+（ord(x)-ord(0)）;scanf(“%c”,&x);else /处理小

33、数部分。scale=10.0; scanf(“%c”,&x);while(x>=0&&x<=9)num=num+(ord(x)-ord(0)/scale;scale=scale*10; scanf(“%c”,&x); /elsepush(OPND,num); num=0.0;/数压入栈，下个数初始化case x= :break; /遇空格，继续读下一个字符。case x=+:push(OPND,pop(OPND)+pop(OPND);break;case x=-:x1=pop(OPND);x2=pop(OPND);push(OPND,x2-x1);b

34、reak;case x=*:push(OPND,pop(OPND)*pop(OPND);break;case x=/:x1=pop(OPND);x2=pop(OPND);push(OPND,x2/x1);break;default: /其它符号不作处理。/结束switchscanf(“%c”,&x);/读入表达式中下一个字符。/结束while（x！=$）printf(“后缀表达式的值为%f”,pop(OPND);/算法结束。算法讨论假设输入的后缀表达式是正确的，未作错误检查。算法中拼数部分是核心。若遇到大于等于0且小于等于9的字符，认为是数。这种字符的序号减去字符0的序号得出数。对于整

35、数，每读入一个数字字符，前面得到的部分数要乘上10再加新读入的数得到新的部分数。当读到小数点，认为数的整数部分已完，要接着处理小数部分。小数部分的数要除以10（或10的幂数）变成十分位，百分位，千分位数等等，与前面部分数相加。在拼数过程中，若遇非数字字符，表示数已拼完，将数压入栈中，并且将变量num恢复为0，准备下一个数。这时对新读入的字符进入+、-、*、/及空格的判断，因此在结束处理数字字符的case后，不能加入break语句。 （5）假设以I和O分别表示入栈和出栈操作。栈的初态和终态均为空，入栈和出栈的操作序列可表示为仅由I和O组成的序列，称可以操作的序列为合法序列，否则称为非法序列。下面

36、所示的序列中哪些是合法的？A. IOIIOIOO B. IOOIOIIO C. IIIOIOIO D. IIIOOIOO通过对的分析，写出一个算法，判定所给的操作序列是否合法。若合法，返回true，否则返回false（假定被判定的操作序列已存入一维数组中）。 A和D是合法序列，B和C 是非法序列。 设被判定的操作序列已存入一维数组A中。int Judge(char A)/判断字符数组A中的输入输出序列是否是合法序列。如是，返回true，否则返回false。i=0; /i为下标。j=k=0; /j和k分别为I和字母O的的个数。while(Ai!=0) /当未到字符数组尾就作。switch(Ai)

37、caseI: j+; break; /入栈次数增1。caseO: k+; if(k>j)printf(“序列非法n”)；exit(0); i+; /不论Ai是I或O，指针i均后移。if(j!=k) printf(“序列非法n”)；return(false);else printf(“序列合法n”)；return(true);/算法结束。算法讨论在入栈出栈序列（即由I和O组成的字符串）的任一位置，入栈次数（I的个数）都必须大于等于出栈次数（即O的个数），否则视作非法序列，立即给出信息，退出算法。整个序列（即读到字符数组中字符串的结束标记0），入栈次数必须等于出栈次数（题目中要求栈的初态和终

38、态都为空），否则视为非法序列。(6）假设以带头结点的循环链表表示队列，并且只设一个指针指向队尾元素站点(注意不设头指针) ，试编写相应的置空队、判队空 、入队和出队等算法。算法如下：/先定义链队结构:typedef struct queuenodeDatatype data;struct queuenode *next;QueueNode; /以上是结点类型的定义 typedef structqueuenode *rear;LinkQueue; /只设一个指向队尾元素的指针 (1)置空队void InitQueue( LinkQueue *Q) /置空队：就是使头结点成为队尾元素 QueueN

39、ode *s;Q->rear = Q->rear->next;/将队尾指针指向头结点while (Q->rear!=Q->rear->next)/当队列非空，将队中元素逐个出队 s=Q->rear->next;Q->rear->next=s->next;free(s);/回收结点空间 (2)判队空int EmptyQueue( LinkQueue *Q) /判队空/当头结点的next指针指向自己时为空队return Q->rear->next->next=Q->rear->next; (3)入队vo

40、id EnQueue( LinkQueue *Q, Datatype x) /入队/也就是在尾结点处插入元素QueueNode *p=(QueueNode *) malloc (sizeof(QueueNode);/申请新结点 p->data=x; p->next=Q->rear->next;/初始化新结点并链入Q-rear->next=p;Q->rear=p;/将尾指针移至新结点 (4)出队Datatype DeQueue( LinkQueue *Q)/出队,把头结点之后的元素摘下Datatype t; QueueNode *p;if(EmptyQueue

41、( Q )Error("Queue underflow");p=Q->rear->next->next; /p指向将要摘下的结点x=p->data; /保存结点中数据if (p=Q->rear)/当队列中只有一个结点时，p结点出队后，要将队尾指针指向头结点Q->rear = Q->rear->next; Q->rear->next=p->next;elseQ->rear->next->next=p->next;/摘下结点pfree(p);/释放被删结点return x;（7）假设以数组Qm存放循环队列中的元素, 同时设置一个标志tag，以tag = 0和tag = 1来区别在队头指针(front)和队尾指针(rear