数据结构预算法第2版课后习题答案+张晓莉编

2.3 课后习题解答

2.3.2 判断题

1．线性表的逻辑顺序与存储顺序总是一致的。（×） 2．顺序存储的线性表可以按序号随机存取。（√）

3．顺序表的插入和删除操作不需要付出很大的时间代价，因为每次操作平均只有近一半的元素需要移动。（×）

4．线性表中的元素可以是各种各样的，但同一线性表中的数据元素具有相同的特性，因此属于同一数据对象。（√）

5．在线性表的顺序存储结构中，逻辑上相邻的两个元素在物理位置上并不一定相邻。（×）

6．在线性表的链式存储结构中，逻辑上相邻的元素在物理位置上不一定相邻。（√） 7．线性表的链式存储结构优于顺序存储结构。（×）

8．在线性表的顺序存储结构中，插入和删除时移动元素的个数与该元素的位置有关。（√）

9．线性表的链式存储结构是用一组任意的存储单元来存储线性表中数据元素的。（√） 10．在单链表中，要取得某个元素，只要知道该元素的指针即可，因此，单链表是随机存取的存储结构。（×）

11．静态链表既有顺序存储的优点，又有动态链表的优点。所以它存取表中第i个元素的时间与i无关。（×）

12．线性表的特点是每个元素都有一个前驱和一个后继。（×）

2.3.3 算法设计题

1．设线性表存放在向量A[arrsize]的前elenum个分量中，且递增有序。试写一算法，将x 插入到线性表的适当位置上，以保持线性表的有序性，并且分析算法的时间复杂度。 【提示】直接用题目中所给定的数据结构（顺序存储的思想是用物理上的相邻表示逻辑上的相邻，不一定将向量和表示线性表长度的变量封装成一个结构体），因为是顺序存储，分配的存储空间是固定大小的，所以首先确定是否还有存储空间，若有，则根据原线性表中元素的有序性，来确定插入元素的插入位置，后面的元素为它让出位置，（也可以从高下标端开始一边比较，一边移位）然后插入x ，最后修改表示表长的变量。 int insert (datatype A[],int *elenum,datatype x) /*设elenum为表的最大下标*/ {if (*elenum==arrsize-1) return 0; /*表已满，无法插入*/ else {i=*elenum;

while (i>=0 && A[i]>x) /*边找位置边移动*/

{A[i+1]=A[i]; i--; }

A[i+1]=x; /*找到的位置是插入位的下一位*/ (*elenum)++;

return 1; /*插入成功*/ } }

时间复杂度为O(n)。

2．已知一顺序表A，其元素值非递减有序排列，编写一个算法删除顺序表中多余的值相同的元素。

【提示】对顺序表A，从第一个元素开始，查找其后与之值相同的所有元素，将它们删除；再对第二个元素做同样处理，依此类推。 void delete(Seqlist *A) {i=0;

while(ilast) /*将第i个元素以后与其值相同的元素删除

*/

{k=i+1; while(k<=A->last&&A->data[i]==A->data[k]) k++; /*使k指向第一个与A[i]不同的元素*/ n=k-i-1; /*n表示要删除元素的个数*/ for(j=k;j<=A->last;j++) A->data[j-n]=A->data[j]; /*删除多余元素*/ A->last= A->last -n; i++; }

}

3．写一个算法，从一个给定的顺序表A中删除值在x~y(x<=y)之间的所有元素，要求以较高的效率来实现。

【提示】对顺序表A，从前向后依次判断当前元素A->data[i]是否介于x和y之间，若是，并不立即删除，而是用n记录删除时应前移元素的位移量；若不是，则将A->data[i]向前移动n位。n用来记录当前已删除元素的个数。 void delete(Seqlist *A,int x,int y) {i=0; n=0;

while (ilast) {if (A->data[i]>=x && A->data[i]<=y) n++; /*若A->data[i] 介于x和y之间，n自增*/ else A->data[i-n]=A->data[i]; /*否则向前移动A->data[i]*/ i++; }

A->last-=n; }

4．线性表中有n个元素，每个元素是一个字符，现存于向量R[n]中，试写一算法，使R中的字符按字母字符、数字字符和其它字符的顺序排列。要求利用原来的存储空间，元素移动次数最小。

【提示】对线性表进行两次扫描，第一次将所有的字母放在前面，第二次将所有的数字放在字母之后，其它字符之前。 int fch(char c) /*判断c是否字母*/ {if(c>='a'&&c<='z'||c>='A'&&c<='Z') return (1); else return (0); }

int fnum(char c) /*判断c是否数字*/ {if(c>='0'&&c<='9') return (1);

else return (0); }

void process(char R[n]) {low=0; high=n-1;

while(low

{while(low

while(low

R[low]=R[high]; R[high]=k; }

}

low=low+1; high=n-1;

while(low

{k=R[low];

R[low]=R[high]; R[high]=k; }

}

}

5．线性表用顺序存储，设计一个算法，用尽可能少的辅助存储空间将顺序表中前m个元素和后n个元素进行整体互换。即将线性表：

（a1, a2, … , am, b1, b2, … , bn）改变为： （b1, b2, … , bn , a1, a2, … , am）。

【提示】比较m和n的大小，若m

void process(Seqlist *L,int m,int n)

{if(m<=n)

for(i=1;i<=m;i++) {x=L->data[0];

for(k=1;k<=L->last;k++) L->data[k-1]=L->data[k]; L->data[L->last]=x; } else for(i=1;i<=n;i++) {x=L->data[L->last]; for(k=L->last-1;k>=0;k- -) L->data[k+1]=L->data[k];

L->data[0]=x; }

} 6．已知带头结点的单链表L中的结点是按整数值递增排列的，试写一算法，将值为x 的结点插入到表L中，使得L仍然递增有序，并且分析算法的时间复杂度。 LinkList insert(LinkList L, int x) {p=L; while(p->next && x>p->next->data) p=p->next; /*寻找插入位置*/ s=(LNode *)malloc(sizeof(LNode)); /*申请结点空间*/ s->data=x; /*填装结点*/ s->next=p->next; p->next=s; /*将结点插入到链表中*/ return(L);

}

7．假设有两个已排序（递增）的单链表A和B，编写算法将它们合并成一个链表C而不改变其排序性。

LinkList Combine(LinkList A, LinkList B)

{C=A; rc=C;

pa=A->next; /*pa指向表A的第一个结点*/ pb=B->next; /*pb指向表B的第一个结点*/ free(B); /*释放B的头结点*/

while (pa && pb) /*将pa、pb所指向结点中，值较小的一个插入到链表C的表尾*/ if(pa->datadata)

{rc->next=pa; rc=pa;

pa=pa->next; } else

{rc->next=pb; rc=pb;

pb=pb->next; }

if(pa) rc->next=pa; else rc->next=pb; /*将链表A或B中剩余的部分链接到链表C的表尾*/ return(C);

}

8．假设长度大于1的循环单链表中，既无头结点也无头指针，p为指向该链表中某一结点的指针，编写算法删除该结点的前驱结点。

【提示】利用循环单链表的特点，通过s指针可循环找到其前驱结点p及p的前驱结点q，然后可删除结点*p。 viod delepre(LNode *s) {LNode *p, *q;

p=s;

while (p->next!=s) {q=p;

p=p->next; }

q->next=s; free(p); }

9．已知两个单链表A和B分别表示两个集合，其元素递增排列，编写算法求出A和B的交集C，要求C同样以元素递增的单链表形式存储。

【提示】交集指的是两个单链表的元素值相同的结点的集合，为了操作方便，先让单链表C带有一个头结点，最后将其删除掉。算法中指针p用来指向A中的当前结点，指针q用来指向B中的当前结点，将其值进行比较，两者相等时，属于交集中的一个元素，两者不等时，将其较小者跳过，继续后面的比较。 LinkList Intersect(LinkList A, LinkList B)

{LNode *q, *p, *r, *s; LinkList C;

C= (LNode *)malloc(sizeof(LNode)); C->next=NULL; r=C; p=A; q=B;

while (p && q )

if (p->datadata) p=p->next; else if (p->data==q->data)

{s=(LNode *)malloc(sizeof(LNode)); s->data=p->data; r->next=s; r=s; p=p->next; q=q->next; }

else q=q->next;

r->next=NULL; C=C->next; return C; }

10．设有一个双向链表，每个结点中除有prior、data和next域外，还有一个访问频度freq域，在链表被起用之前，该域的值初始化为零。每当在链表进行一次Locata(L,x)运算后，令值为x的结点中的freq域增1，并调整表中结点的次序，使其按访问频度的非递增序列排列，以便使频繁访问的结点总是靠近表头。试写一个满足上述要求的Locata(L,x)算法。 【提示】在定位操作的同时，需要调整链表中结点的次序：每次进行定位操作后，要查看所查找结点的freq域，将其同前面结点的freq域进行比较，同时进行结点次序的调整。 typedef struct dnode

本文来源：https://www.bwwdw.com/article/ayrt.html