练习题第一二章-----数据结构

第1章 绪论

数据：客观事物的符号表示，指所有能输入到计算机并被计算机程序处理的符号的集合。
数据元素：数据的基本单位，在计算机中通常作为整体进行考虑和处理。
数据项：组成数据元素的、有独立含义的、不可分割的最小的单位。
数据对象：性质相同的数据元素的集合。
数据结构：相互之间存在一种或多种相互关系的数据元素的结合，是“带结构”的数据元素的集合。
逻辑结构：从逻辑上描述数据，与数据的存储无关。是独立于计算机的。逻辑结构可以看做是具体问题抽象出来的数据模型。
存储结构：数据对象在计算机中的存储表示，也称为物理结构。
抽象数据类型：由用户定义的，表示应用问题的数据模型，以及定义在这个模型上的操作的总称。具体包括：数据对象、数据对象上的关系的集合和数据对象的基本操作的集合。

4.存储结构由顺序存储和链式存储两种基本的存储方法实现。
5．选择题

（1）在数据结构中，从逻辑上可以把数据结构分成（ C ）。
A．动态结构和静态结构 B．紧凑结构和非紧凑结构
C．线性结构和非线性结构 D．内部结构和外部结构

（2）与数据元素本身的形式、内容、相对位置、个数无关的是数据的（ C ）。
A．存储结构 B．存储实现C．逻辑结构 D．运算实现

（3）通常要求同一逻辑结构中的所有数据元素具有相同的特性，这意味着（ B ）。
A．数据具有同一特点
B．不仅数据元素所包含的数据项的个数要相同，而且对应数据项的类型要一致
C．每个数据元素都一样
D．数据元素所包含的数据项的个数要相等

（4）以下说法正确的是（ D ）。
A．数据元素是数据的最小单位
B．数据项是数据的基本单位
C．数据结构是带有结构的各数据项的集合
D．一些表面上很不相同的数据可以有相同的逻辑结构
解释：数据元素是数据的基本单位，数据项是数据的最小单位，数据结构是带有结构的各数据元素的集合。

（5）算法的时间复杂度取决于（ D ）。
A．问题的规模 B．待处理数据的初态
C．计算机的配置 D．A和B
解释：算法的时间复杂度不仅与问题的规模有关，还与问题的其他因素有关。如某些排序的算法，其执行时间与待排序记录的初始状态有关。为此，有时会对算法有最好、最坏以及平均时间复杂度的评价。

（6）以下数据结构中，（ A ）是非线性数据结构
A．树 B．字符串 C．队列 D．栈

6．试分析下面各程序段的时间复杂度。
（1）x=90; y=100;
while(y>0)
if(x>100)
{x=x-10;y–;}
else x++;
答案：O(1)
解释：程序的执行次数为常数阶。

（2）for (i=0; i<n; i++)
for (j=0; j<m; j++)
a[i][j]=0;
答案：O(mn)
解释：语句a[i][j]=0;的执行次数为mn。

（3）s=0;
for i=0; i<n; i++)
for(j=0; j<n; j++)
s+=B[i][j];
sum=s;
答案：O(n2)
解释：语句s+=B[i][j];的执行次数为n2。

（4）i=1;
while(i<=n)
i=i3;
答案：O(log3n)
解释：语句i=i3;的执行次数为 ëlog3nû。

（5）x=0;
for(i=1; i<n; i++)
for (j=1; j<=n-i; j++)
x++;
答案：O(n2)
解释：语句x++;的执行次数为n-1+n-2+……＋1= n(n-1)/2。

第2章 线性表

1．选择题
（1）顺序表中第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是（ B ）。
A．110 B．108 C．100 D．120
解释：因为顺序表是连续存储的，所以第5个元素的地址为：100+2*( 5 - 1)=108。

（2）在n个结点的顺序表中，算法的时间复杂度是O(1)的操作是（ A ）。
A．访问第i个结点（1≤i≤n）和求第i个结点的直接前驱（2≤i≤n）
B．在第i个结点后插入一个新结点（1≤i≤n）
C．删除第i个结点（1≤i≤n）
D．将n个结点从小到大排序
解释：在顺序表中插入、删除一个结点，平均约移动表中一半元素，时间复杂度为O(n)；顺序表是一种随机存取结构，按位置访问元素可通过数组下标直接定位，时间复杂度是O(1)；（排序的时间复杂度为O(n2)或O(nlog2n)？）。

（3） 向一个有127个元素的顺序表中插入一个新元素并保持原来顺序不变，平均要移动 的元素个数为（ B ）。
A．8 B．63.5 C．63 D．7
解释：平均移动元素个数为n/2

（4）链接存储的存储结构所占存储空间（ A ）。
A．分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针
B．只有一部分，存放结点值
C．只有一部分，存储表示结点间关系的指针
D．分两部分，一部分存放结点值，另一部分存放结点所占单元数

（5）线性表若采用链式存储结构时，要求内存中可用存储单元的地址（ D ）。
A．必须是连续的 B．部分地址必须是连续的
C．一定是不连续的 D．连续或不连续都可以

（6）线性表Ｌ在（ B ）情况下适用于使用链式结构实现。
A．需经常修改Ｌ中的结点值 Ｂ．需不断对Ｌ进行删除插入
C．Ｌ中含有大量的结点 Ｄ．Ｌ中结点结构复杂
解释：链表插入/删除数据只需修改指针不需要移动表中数据，链表适用长度变化大、频繁进行插入/删除操作。

（7）单链表的存储密度（ C ）。
A．大于1 B．等于1 C．小于1 D．不能确定
解释：存储密度是指一个结点数据本身所占的存储空间和整个结点所占的存储空间之比，假设单链表一个结点本身所占的空间为D，指针域所占的空间为N，则存储密度为D/(D+N)，即一定小于1。

（8）将两个各有n个元素的有序表归并成一个有序表，其最少的比较次数是（ ）。
A．n B．2n-1 C．2n D．n-1
答案：A
解释：当第一个有序表中所有的元素都小于（或大于）第二个表中的元素，只需要用第二个表中的第一个元素依次与第一个表的元素比较，总计比较n次，最多比较2n-1次。

（9）在一个长度为n的顺序表中，在第i个元素（1≤i≤n+1）之前插入一个新元素时须向后移动（ B ）个元素。
A．n-i B．n-i+1 C．n-i-1 D．I

(10) 线性表L=(a1，a2,……an)，下列说法正确的是（D ）。
A．每个元素都有一个直接前驱和一个直接后继
B．线性表中至少有一个元素
C．表中诸元素的排列必须是由小到大或由大到小
D．除第一个和最后一个元素外，其余每个元素都有一个且仅有一个直接前驱和直接后继。

(11) 创建一个包括n个结点的有序单链表的时间复杂度是（C ）。
A．O(1) B．O(n) C．O(n2) D．O(nlog2n)
解释：创建单链表的时间复杂度是O(n)，而要建立一个有序的单链表，则每生成一个新结点时需要和已有的结点进行比较 以确定合适的插入位置，所以时间复杂度是O(n2)。

(12) 以下说法错误的是（ ）。
A．求表长、定位这两种运算在采用顺序存储结构时实现的效率不比采用链式存储结构时实现的效率低
B．顺序存储的线性表可以随机存取
C．由于顺序存储要求连续的存储区域，所以在存储管理上不够灵活
D．线性表的链式存储结构优于顺序存储结构
答案：D
解释：链式存储结构和顺序存储结构各有优缺点，有不同的适用场合。

(13) 在单链表中，要将s所指结点插入到p所指结点之后，其语句应为（ ）。
A．s->next=p+1; p->next=s;
B．(*p).next=s; (*s).next=(*p).next;
C．s->next=p->next; p->next=s->next;
D．s->next=p->next; p->next=s;
答案：D

(14) 在双向链表存储结构中，删除p所指的结点时须修改指针（ ）。
A．p->next->prior=p->prior; p->prior->next=p->next;
B．p->next=p->next->next; p->next->prior=p;
C．p->prior->next=p; p->prior=p->prior->prior;
D．p->prior=p->next->next; p->next=p->prior->prior;
答案：A

(15) 在双向循环链表中，在p指针所指的结点后插入q所指向的新结点，其修改指针的操作是（ ）。
A．p->next=q; q->prior=p; p->next->prior=q; q->next=q;
B．p->next=q; p->next->prior=q; q->prior=p; q->next=p->next;
C．q->prior=p; q->next=p->next; p->next->prior=q; p->next=q;
D．q->prior=p; q->next=p->next; p->next=q; p->next->prior=q;
答案：C

2．算法设计题

（1）将两个递增的有序链表合并为一个递增的有序链表。要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。表中不允许有重复的数据。
[题目分析]
（合并后的新表用一个新的Lc指针。新建一个Lc头指针，pa和pb分别是链表La和Lb的工作指针且初始化为相应链表的第一个结点。从第一个结点开始进行比较，当两个链表La和Lb均未到达表尾结点时，则依次摘取较小元素重新链接在Lc表的后面。其中，如果两个表中的元素相等，只摘取La表中的元素，删除Lb表中的元素（注意释放删除的元素的空间），这样确保合并后表中无重复的元素。当一个表到达表尾结点，为空时，将非空表的剩余元素直接链接在Lc表的最后面。
[算法描述]

void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc){
	//合并链表La和Lb，合并后的新表使用头指针Lc指向
	pa=La->next; pb=Lb->next;
	//pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点
	Lc=pc=La; //用La的头结点作为Lc的头结点
	while(pa && pb){
		if(pa->data<pb->data){
			pc->next=pa;
			pc=pa;
			pa=pa->next;
		}	
		else if(pa->data>pb->data){ //取较小者La中的元素，将pa链接在pc的后面，pa指针后移
			pc->next=pb;
			pc=pb;
			pb=pb->next;
		}	
		else {  //取较小者Lb中的元素，将pb链接在pc的后面，pb指针后移	
				//相等时取La中的元素，删除Lb中的元素
			pc->next=pa;
			pc=pa;
			pa=pa->next;
			q=pb->next;delete pb ;pb =q;（删除记得要释放空间）
			//q=pb;pb=q->next;delete q;
		}
	}
	pc->next=pa?pa:pb; //插入剩余段
	delete Lb; //释放Lb的头结点(La的头结点已赋给了Lc,不需释放)
}

（2）将两个非递减的有序链表合并为一个非递增的有序链表。要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。表中允许有重复的数据。
[题目分析]
合并后的新表使用头指针Lc指向，pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点，从第一个结点开始进行比较，当两个链表La和Lb均为到达表尾结点时，依次摘取其中较小者重新链接在Lc表的表头结点之后，如果两个表中的元素相等，只摘取La表中的元素，保留Lb表中的元素。当一个表到达表尾结点，为空时，将非空表的剩余元素依次摘取，链接在Lc表的表头结点之后（前插法）。
[算法描述]

void MergeList(LinkList& La, LinkList& Lb, LinkList& Lc, ){
	//合并链表La和Lb，合并后的新表使用头指针Lc指向
	pa=La->next; pb=Lb->next;
	//pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点
	Lc=pc=La; //用La的头结点作为Lc的头结点
	Lc->next=NULL;
	while(pa||pb){//只要存在一个非空表，用q指向待摘取的元素
	if(!pa) {q=pb; pb=pb->next;}
	//La表为空，用q指向pb，pb指针后移
	else if(!pb) {q=pa; pa=pa->next;}
	//Lb表为空，用q指向pa，pa指针后移
	else if(pa->data<=pb->data) {q=pa; pa=pa->next;}
	//取较小者（包括相等）La中的元素，用q指向pa，pa指针后移
	else {q=pb; pb=pb->next;}
	//取较小者Lb中的元素，用q指向pb，pb指针后移
	q->next = Lc->next; Lc->next = q;
	//将q指向的结点插在Lc 表的表头结点之后
	}
	delete Lb; //释放Lb的头结点
}

（3）已知两个链表A和B分别表示两个集合，其元素递增排列。请设计算法求出A与B的交集，并存放于A链表中。
[题目分析]
只有同时出现在两集合中的元素才出现在结果表中,合并后的新表使用头指针Lc指向。pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点，从第一个结点开始进行比较，当两个链表La和Lb均为到达表尾结点时，如果两个表中相等的元素时，摘取La表中的元素，删除Lb表中的元素；如果其中一个表中的元素较小时，删除此表中较小的元素，此表的工作指针后移。当链表La和Lb有一个到达表尾结点，为空时，依次删除另一个非空表中的所有元素。
[算法描述]

void Mix(LinkList& La, LinkList& Lb, LinkList& Lc){ 
	pa=La->next;pb=Lb->next;
	//pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点
	Lc=pc=La; //用La的头结点作为Lc的头结点
	while(pa&&pb){
	if(pa->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->next=null;∥置链表尾标记。
	delete Lb; //释放Lb的头结点
}

（4）已知两个链表A和B分别表示两个集合，其元素递增排列。请设计算法求出两个集合A和B 的差集（即仅由在A中出现而不在B中出现的元素所构成的集合），并以同样的形式存储，同时返回该集合的元素个数。
[题目分析]
求两个集合A和B的差集是指在A中删除A和B中共有的元素，即删除链表中的相应结点,所以要保存待删除结点的前驱，使用指针pre指向前驱结点。pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点，从第一个结点开始进行比较，当两个链表La和Lb均为到达表尾结点时，如果La表中的元素小于Lb表中的元素，pre置为La表的工作指针pa删除Lb表中的元素；如果其中一个表中的元素较小时，删除此表中较小的元素，此表的工作指针后移。当链表La和Lb有一个为空时，依次删除另一个非空表中的所有元素。
[算法描述]

void Difference（LinkList& La, LinkList& Lb,int *n）{
	//差集的结果存储于单链表La中，*n是结果集合中元素个数，调用时为0
	pa=La->next; pb=Lb->next;
	//pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点
	pre=La; ∥pre为La中pa所指结点的前驱结点的指针
	while（pa&&pb）{
		if（pa->data<q->data）{
			pre=pa;pa=pa->next;*n++;
		}
		// A链表中当前结点指针后移
		else if（pa->data>q->data）q=q->next; ∥B链表中当前结点指针后移
		else {pre->next=pa->next; ∥处理A，B中元素值相同的结点，应删除
		u=pa; pa=pa->next; delete u;} ∥删除结点
	}
}

（5）设计算法将一个带头结点的单链表A分解为两个具有相同结构的链表B、C，其中B表的结点为A表中值小于零的结点，而C表的结点为A表中值大于零的结点（链表A中的元素为非零整数，要求B、C表利用A表的结点）。
[题目分析]
B表的头结点使用原来A表的头结点，为C表新申请一个头结点。从A表的第一个结点开始，依次取其每个结点p，判断结点p的值是否小于0，利用前插法，将小于0的结点插入B表,大于等于0的结点插入C表。
[算法描述]

void DisCompose(LinkedList A){
	B=A;
	B->next= NULL; ∥B表初始化
	C=new LNode;∥为C申请结点空间
	C->next=NULL; ∥C初始化为空表
	p=A->next; ∥p为工作指针
	while(p!= NULL){ 
		r=p->next; ∥暂存p的后继
		if(p->data<0){p->next=B->next; B->next=p; }	//将小于0的结点链入B表,前插法
		else {p->next=C->next; C->next=p; }	//将大于等于0的结点链入C表,前插法
		p=r;	//p指向新的待处理结点。
	}
}