第二章线性表
2.1描述以下三个概念的区别：头指针，头结点，首元结点（第一个元素结点）。
并说明头指针和头结点的作用。
答：头指针是一个指针变量，里面存放的是链表中首结点的地址，并以此来标识一个链表。如链表H，链表L等，表示链表中第一个结点的地址存放在H、L中。头结点是附加在第一个元素结点之前的一个结点，头指针指向头结点。当该链表表示一个非空的线性表时，头结点的指针域指向第一个元素结点，为空表时，该指针域为空。
开始结点指第一个元素结点。
头指针的作用是用来惟一标识一个单链表。
头结点的作用有两个：一是使得对空表和非空表的处理得以统一。二是使得在链表的第一个位置上的操作和在其他位置上的操作一致，无需特殊处理。
2.2填空题
1、在顺序表中插入或删除一个元素，需要平均移动（表中一半）元素，具体移动的元素个数与（表长和该元素在表中的位置）有关。
2、顺序表中逻辑上相邻的元素的物理位置（必定）相邻。单链表中逻辑上相邻的元素的物理位置（不一定）相邻。
3、在单链表中，除了首元结点外，任一结点的存储位置由（其直接前驱结点的链域的值）指示。
4、在单链表中设置头结点的作用是（插入和删除元素不必进行特殊处理）。
2.3何时选用顺序表、何时选用链表作为线性表的存储结构为宜?
答：在实际应用中，应根据具体问题的要求和性质来选择顺序表或链表作为线性表的存储结构，通常有以下几方面的考虑：
1.基于空间的考虑。当要求存储的线性表长度变化不大，易于事先确定其大小时，为了节约存储空间，宜采用顺序表；反之，当线性表长度变化大，难以估计其存储规模时，采用动态链表作为存储结构为好。
2.基于时间的考虑。若线性表的操作主要是进行查找，很少做插入和删除操作时，采用顺序表做存储结构为宜；反之，若需要对线性表进行频繁地插入或删除等的操作时，宜采用链表做存储结构。并且，若链表的插入和删除主要发生在
表的首尾两端，则采用尾指针表示的单循环链表为宜。
2.10 Status DeleteK(SqList &a,int i,int k)//删除线性表a中第i个元素起的k个元素
{
if(i<1||k<0||i+k-1>a.length) return INFEASIBLE;
for(count=1;i+count-1<=a.length-k;count++) //注意循环结束的条件
a.elem[i+count-1]=a.elem[i+count+k-1];
a.length-=k;
return OK;
}//DeleteK
2.11设顺序表中的数据元素递增有序，试写一算法，将X插入到顺序表的适当位置上，以保持该表的有序性。
答：因已知顺序表L是递增有序表，所以只要从顺序表终端结点（设为i位置元素）开始向前寻找到第一个小于或等于x的元素位置i后插入该位置即可。
在寻找过程中，由于大于x的元素都应放在x之后，所以可边寻找，边后移元素，当找到第一个小于或等于x的元素位置i时，该位置也空出来了。
算法如下：
//顺序表存储结构如题2.7
void InsertIncreaseList( Seqlist *L , Datatype x )
{
int i;
if ( L->length>=ListSize)
Error(“overflow");
for ( i=L -> length ; i>0 && L->data[ i-1 ] > x ; i--)
L->data[ i ]=L->data[ i-1 ] ; // 比较并移动元素
L->data[ i ] =x;
L -> length++;
}
2.12 int ListComp(SqList A,SqList B)//比较字符表A和B,并用返回值表示结果,值为正,表示A>B;值为负,表示A { for(i=1;A.elem[i]||B.elem[i];i++) if(A.elem[i]!=B.elem[i]) return A.elem[i]-B.elem[i]; return 0; }//ListComp 2.13试写一算法在带头结点的单链表上实现线性表操作LOCATE（L，X）。Listnode *LocateNode(Linklist head,DataType key) { ListNode *p=head->next; While(p&&p->data!=key) p=p->next; return p; } 2.14试写一算法在带头结点的单链表结构上实现线性表操作规程LENGTH（L）。 #include"stdio.h" #define Maxsize 20 typedef int elemtype; typedef struct node{ elemtype data; struct node *next; }lnode; typedef lnode * linklist; int length_list(linklist head) {lnode *p=head; int j=0; if(!p){ printf("error");exit(0);} while(p->next) {p=p->next;j++;} return j; } 2.15已知L1和L2分别指向两个单链表的头结点，且已知其长度分别为m和n。试写一算法将这两个链表连接在一起，请分析你的算法的时间复杂度。 解： 分析： 由于要进行的是两单链表的连接，所以应找到放在前面的那张表的表尾结点，再将后表的开始结点链接到前表的终端结点后即可。该算法的主要时间消耗是用在寻找第一张表的终端尾结点上。这两张单链表的连接顺序无要求，并且已知两表的表长，则为了提高算法效率，可选表长小的单链表在前的方式连接。 具体算法如下： LinkList Link( LinkList L1 , LinkList L2，int m,int n ) {//将两个单链表连接在一起 ListNode *p , *q, *s ; //s指向短表的头结点,q指向长表的开始结点，回收长表头结点空间 if (m<=n) {s=L1;q=L2->next;free(L2);} else {s=L2;q=L1->next;free(L1);} p=s; while ( p->next ) p=p->next; //查找短表终端结点 p->next = q; //将长表的开始结点链接在短表终端结点后 return s; } 本算法的主要操作时间花费在查找短表的终端结点上，所以本算的法时间复 杂度为： O(min(m,n)) 2.16见书后答案. 2.17 Status Insert(LinkList &L,int i,int b)//在无头结点链表L的第i个元素之前插入元素b { p=L;q=(LinkList*)malloc(sizeof(LNode)); q.data=b; if(i==1) { q.next=p;L=q; //插入在链表头部 } else { while(--i>1) p=p->next; q->next=p->next;p->next=q; //插入在第i个元素的位置 } }//Insert 2.18 Status Delete(LinkList &L,int i)//在无头结点链表L中删除第i个元素 { if(i==1) L=L->next; //删除第一个元素 else { p=L; while(--i>1) p=p->next; p->next=p->next->next; //删除第i个元素 } }//Delete 2.19 Status Delete_Between(Linklist &L,int mink,int maxk)//删除元素递增排列的链表L中值大于mink且小于maxk的所有元素 { p=L; while(p->next->data<=mink) p=p->next; //p是最后一个不大于mink的元素 if(p->next) //如果还有比mink更大的元素 { q=p->next; while(q->data p->next=q; } }//Delete_Between 2.20 Status Delete_Equal(Linklist &L)//删除元素递增排列的链表L中所有值相同的元素 { p=L->next;q=p->next; //p,q指向相邻两元素 while(p->next) { if(p->data!=q->data) { p=p->next;q=p->next; //当相邻两元素不相等时,p,q都向后推一步 } else { while(q->data==p->data) { free(q); q=q->next; } p->next=q;p=q;q=p->next; //当相邻元素相等时删除多余元素 }//else }//while }//Delete_Equal 2.21试分别用顺序表作为存储结构，实现将线性表(a0,a1,...an-1)就地逆置的操作，所谓"就地"指辅助空间应为O(1)。 答： 要将该表逆置，可以将表中的开始结点与终端结点互换，第二个结点与倒数第二个结点互换，如此反复，就可将整个表逆置了。算法如下： // 顺序表结构定义同上题 void ReverseList( Seqlist *L) { DataType temp ; //设置临时空间用于存放data int i; for (i=0;i<=L->length/2;i++)//L->length/2为整除运算 { temp = L->data[i]; //交换数据 L -> data[ i ] = L -> data[ L -> length-1-i]; L -> data[ L -> length - 1 - i ] = temp; } } 2.22试写一算法，对单链表实现就地逆置。 答：链表： 分析： 可以用交换数据的方式来达到逆置的目的。但是由于是单链表，数据的存取不是随机的，因此算法效率太低。可以利用指针改指来达到表逆置的目的。具体情况入下： (1)当链表为空表或只有一个结点时，该链表的逆置链表与原表相同。 (2)当链表含2个以上结点时，可将该链表处理成只含第一结点的带头结点链表和一个无头结点的包含该链表剩余结点的链表。然后，将该无头结点链表中的所有结点顺着链表指针，由前往后将每个结点依次从无头结点链表中摘下，作为第一个结点插入到带头结点链表中。这样就可以得到逆置的链表。算法是这样的： 结点结构定义如下： typedef char DataType; //假设结点的数据域类型的字符 typedef struct node{ //结点类型定义 DataType data; //结点的数据域 struct node *next;//结点的指针域 }ListNode; typedef ListNode *LinkList; ListNode *p; LinkList head; LinkList ReverseList( LinkList head ) {// 将head 所指的单链表(带头结点)逆置 ListNode *p ,*q ;//设置两个临时指针变量 if( head->next && head->next->next) { //当链表不是空表或单结点时 p=head->next; q=p->next; p -> next=NULL; //将开始结点变成终端结点 while (q) { //每次循环将后一个结点变成开始结点 p=q; q=q->next ; p->next = head-> next ; head->next = p; } return head; } return head; //如是空表或单结点表，直接返回head } 2.23 void merge1(LinkList &A,LinkList &B,LinkList &C)//把链表A和B合并为C,A和B的元素间隔排列,且使用原存储空间 { p=A->next;q=B->next;C=A; while(p&&q) { s=p->next;p->next=q; //将B的元素插入 if(s) { t=q->next;q->next=s; //如A非空,将A的元素插入 } p=s;q=t; }//while }//merge1 2.24假设有两个按元素值递增有序排列的线性表A和B，均以单链表作为存储结构，请编写算法将A和B表归并成一个按元素值递减有序（即非递增有序，允许表中含有相同的元素）排列的线性有C，并要求利用原表（即A表和B表）的结点空间构造C表。 解： void reverse_merge(LinkList &A,LinkList &B,LinkList &C)//把元素递增排列的链表A和B合并为C,且C中元素递减排列,使用原空间 { pa=A->next;pb=B->next;pre=NULL; //pa和pb分别指向A,B的当前元素 while(pa||pb) { if(pa->data { pc=pa;q=pa->next;pa->next=pre;pa=q; //将A的元素插入新表} else { pc=pb;q=pb->next;pb->next=pre;pb=q; //将B的元素插入新表} pre=pc; } C=A;A->next=pc; //构造新表头 }//reverse_merge 分析:本算法的思想是,按从小到大的顺序依次把A和B的元素插入新表的头部pc处,最后处理A或B的剩余元素. 2.25 void SqList_Intersect(SqList A,SqList B,SqList &C)//求元素递增排列的线性表A和B的元素的交集并存入C中 { i=1;j=1;k=0; while(A.elem[i]&&B.elem[j]) { if(A.elem[i] if(A.elem[i]>B.elem[j]) j++; if(A.elem[i]==B.elem[j]) { C.elem[++k]=A.elem[i]; //当发现了一个在A,B中都存在的元素, i++;j++; //就添加到C中 } }//while }//SqList_Intersect 2.26 void LinkList_Intersect(LinkList A,LinkList B,LinkList &C)//在链表结构上重做上题 { p=A->next;q=B->next; pc=(LNode*)malloc(sizeof(LNode)); while(p&&q) { if(p->data else if(p->data>q->data) q=q->next; else { s=(LNode*)malloc(sizeof(LNode)); s->data=p->data; pc->next=s;pc=s; p=p->next;q=q->next; } }//while C=pc; }//LinkList_Intersect 2.27 void SqList_Intersect_True(SqList &A,SqList B)//求元素递增排列的线性表A和B 的元素的交集并存回A中 { i=1;j=1;k=0; while(A.elem[i]&&B.elem[j]) { if(A.elem[i] else if(A.elem[i]>B.elem[j]) j++; else if(A.elem[i]!=A.elem[k]) { A.elem[++k]=A.elem[i]; //当发现了一个在A,B中都存在的元素 i++;j++; //且C中没有,就添加到C中 } }//while while(A.elem[k]) A.elem[k++]=0; }//SqList_Intersect_True 2.28 void LinkList_Intersect_True(LinkList &A,LinkList B)//在链表结构上重做上题{ p=A->next;q=B->next;pc=A; while(p&&q) { if(p->data else if(p->data>q->data) q=q->next; else if(p->data!=pc->data) { pc=pc->next; pc->data=p->data; p=p->next;q=q->next; } }//while }//LinkList_Intersect_True 2.29 void SqList_Intersect_Delete(SqList &A,SqList B,SqList C) { i=0;j=0;k=0;m=0; //i指示A中元素原来的位置,m为移动后的位置 while(i { if(B.elem[j] else if(B.elem[j]>C.elem[k]) k++; else { same=B.elem[j]; //找到了相同元素same while(B.elem[j]==same) j++; while(C.elem[k]==same) k++; //j,k后移到新的元素 while(i A.elem[m++]=A.elem[i++]; //需保留的元素移动到新位置 while(i } }//while while(i A.elem[m++]=A.elem[i++]; //A的剩余元素重新存储。 A.length=m; }// SqList_Intersect_Delete 分析:先从B和C中找出共有元素,记为same,再在A中从当前位置开始, 凡小于same的 元素均保留(存到新的位置),等于same的就跳过,到大于same时就再找下一个same. 2.30 void LinkList_Intersect_Delete(LinkList &A,LinkList B,LinkList C)//在链表结构上重做上题 { p=B->next;q=C->next;r=A-next; while(p&&q&&r) { if(p->data else if(p->data>q->data) q=q->next; else { u=p->data; //确定待删除元素u while(r->next->data if(r->next->data==u) { s=r->next; while(s->data==u) { t=s;s=s->next;free(t); //确定第一个大于u的元素指针s }//while r->next=s; //删除r和s之间的元素 }//if while(p->data=u) p=p->next; while(q->data=u) q=q->next; }//else }//while }//LinkList_Intersect_Delete 2.31假设在长度大于1的单循环链表中，既无头结点也无头指针。s为指向链表中某个结点的指针，试编写算法删除结点*s的直接前趋结点。 解： 已知指向这个结点的指针是*s，那么要删除这个结点的直接前趋结点，就只要找到一个结点，它的指针域是指向*s的直接前趋，然后用后删结点法，将结点*s的直接前趋结点删除即可。 算法如下： void DeleteNode( ListNode *s) {//删除单循环链表中指定结点的直接前趋结点 ListNode *p, *q; p=s; while( p->next->next!=s) p=p->next; //删除结点 q=p->next; p->next=q->next; free(p); //释放空间 } 注意： 若单循环链表的长度等于1，则只要把表删空即可。 2.32已知有一个单向循环链表，其每个结点中含三个域：prior、data和next，其中data为数据域，next为指向后继结点的指针域，prior也为指针域，但它的值为空，试编写算法将此单向循环链表改为双向循环链表，即使prior成为指向前驱结点的指针域。 Status DuLNode_Pre(DuLinkList &L)//完成双向循环链表结点的pre域 { for(p=L;!p->next->pre;p=p->next) p->next->pre=p; return OK; }//DuLNode_Pre 2.33已知由单链表表示的线性表中，含有三类字符的数据元素(如：字母字符、数字字符和其它字符)，试编写算法构造三个以循环链表表示的线性表，使每个表中只含同一类的字符，且利用原表中的结点空间作为这三个表的结点空间，头结点可另辟空间。 解： 要解决这样的问题，只要新建三个头结点，然后在原来的单链表中依次查询， 找到一类字符结点时，就摘下此结点链接到相应头结点指明的新链表中就是了。 算法如下： //设已建立三个带头结点的空循环链表A,B,C且A、B、C分别是尾指针. void DivideList( LinkList L, LinkList A, LinkList B, LinkList C) { ListNode *p=L->next, *q; while ( p ) { if ( p->data>='a' &&p->data<='z'|| p->data>='A' &&p->data<='Z') { q=p->next; p=p->next;//指向下一结点 q->next=A->next;//将字母结点链到A表中 A->next=q;A=q; } else if( p->data>='0' && p->data<='9') { // 分出数字结点 q=p->next; p=p->next;//指向下一结点 q->next=B->next;//将数字结点链到B表中 B->next=q;B=q; } else { //分出其他字符结点 q=p->next; p=p->next;//指向下一结点 q->next=C->next;//将其他结点链到C表中 C->next=q;C=q; } } } 2.34 void Print_XorLinkedList(XorLinkedList L)//从左向右输出异或链表的元素值{ p=L.left;pre=NULL; while(p) { printf("%d",p->data); q=XorP(p->LRPtr,pre); pre=p;p=q; //任何一个结点的LRPtr域值与其左结点指针进行异或运算即得到其右结点指针 } }//Print_XorLinkedList 2.35 Status Insert_XorLinkedList(XorLinkedList &L,int x,int i)//在异或链表L的第i个元素前插入元素x { p=L.left;pre=NULL; r=(XorNode*)malloc(sizeof(XorNode)); r->data=x; if(i==1) //当插入点在最左边的情况 { p->LRPtr=XorP(p.LRPtr,r); r->LRPtr=p; L.left=r; return OK; } j=1;q=p->LRPtr; //当插入点在中间的情况 while(++j { q=XorP(p->LRPtr,pre); pre=p;p=q; }//while //在p,q两结点之间插入 if(!q) return INFEASIBLE; //i不可以超过表长 p->LRPtr=XorP(XorP(p->LRPtr,q),r); q->LRPtr=XorP(XorP(q->LRPtr,p),r); r->LRPtr=XorP(p,q); //修改指针 return OK; }//Insert_XorLinkedList 2.36 Status Delete_XorLinkedList(XorlinkedList &L,int i)//删除异或链表L的第i个元素{ p=L.left;pre=NULL; if(i==1) //删除最左结点的情况 { q=p->LRPtr; q->LRPtr=XorP(q->LRPtr,p); L.left=q;free(p); return OK; } j=1;q=p->LRPtr; while(++j { q=XorP(p->LRPtr,pre); pre=p;p=q; }//while //找到待删结点q if(!q) return INFEASIBLE; //i不可以超过表长 if(L.right==q) //q为最右结点的情况 { p->LRPtr=XorP(p->LRPtr,q); L.right=p;free(q); return OK; } r=XorP(q->LRPtr,p); //q为中间结点的情况,此时p,r分别为其左右结点 p->LRPtr=XorP(XorP(p->LRPtr,q),r); r->LRPtr=XorP(XorP(r->LRPtr,q),p); //修改指针 free(q); return OK; }//Delete_XorLinkedList 2.37 void OEReform(DuLinkedList &L)//按1,3,5,...4,2的顺序重排双向循环链表L中的所有结点 { p=L.next; while(p->next!=L&&p->next->next!=L) { p->next=p->next->next; p=p->next; } //此时p指向最后一个奇数结点 if(p->next==L) p->next=L->pre->pre; else p->next=l->pre; p=p->next; //此时p指向最后一个偶数结点 while(p->pre->pre!=L) { p->next=p->pre->pre; p=p->next; } p->next=L; //按题目要求调整了next链的结构,此时pre链仍为原状 for(p=L;p->next!=L;p=p->next) p->next->pre=p; L->pre=p; //调整pre链的结构,同2.32方法 }//OEReform 分析:next链和pre链的调整只能分开进行.如同时进行调整的话,必须使用堆栈保存偶数结点的指针,否则将会破坏链表结构,造成结点丢失. 2.38 DuLNode * Locate_DuList(DuLinkedList &L,int x)//带freq域的双向循环链表上的查找 { p=L.next; while(p.data!=x&&p!=L) p=p->next; if(p==L) return NULL; //没找到 p->freq++;q=p->pre; while(q->freq<=p->freq) q=q->pre; //查找插入位置 if(q!=p->pre) { p->pre->next=p->next;p->next->pre=p->pre; q->next->pre=p;p->next=q->next; q->next=p;p->pre=q; //调整位置 } return p; }//Locate_DuList 2.39 float GetValue_SqPoly(SqPoly P,int x0)//求升幂顺序存储的稀疏多项式的值 { PolyTerm *q; 第2章线性表 班级学号__________-姓名 一、判断正误 （×）1. 链表的每个结点中都恰好包含一个指针。 链表中的结点可含多个指针域，分别存放多个指针。例如，双向链表中的结点可以含有两个指针域，分别存放指向其直接前趋和直接后继结点的指针。 （×）2. 链表的物理存储结构具有同链表一样的顺序。 链表的存储结构特点是无序，而链表的示意图有序。 （×）3. 链表的删除算法很简单，因为当删除链中某个结点后，计算机会自动地将后续的各个单元向前移动。 链表的结点不会移动，只是指针内容改变。 （×）4. 线性表的每个结点只能是一个简单类型，而链表的每个结点可以是一个复杂类型。 混淆了逻辑结构与物理结构，链表也是线性表！且即使是顺序表，也能存放记录型数据。 （×）5. 顺序表结构适宜于进行顺序存取，而链表适宜于进行随机存取。 正好说反了。顺序表才适合随机存取，链表恰恰适于“顺藤摸瓜” （×）6. 顺序存储方式的优点是存储密度大，且插入、删除运算效率高。 前一半正确，但后一半说法错误，那是链式存储的优点。顺序存储方式插入、删除运算效率较低，在表长为n的顺序表中，插入和删除一个数据元素，平均需移动表长一半个数的数据元素。 （×）7. 线性表在物理存储空间中也一定是连续的。 线性表有两种存储方式，顺序存储和链式存储。后者不要求连续存放。 （×）8. 线性表在顺序存储时，逻辑上相邻的元素未必在存储的物理位置次序上相邻。 线性表有两种存储方式，在顺序存储时，逻辑上相邻的元素在存储的物理位置次序上也相邻。 （×）9. 顺序存储方式只能用于存储线性结构。 顺序存储方式不仅能用于存储线性结构，还可以用来存放非线性结构，例如 完全二叉树是属于非线性结构，但其最佳存储方式是顺序存储方式。（后一节介绍） （×）10. 线性表的逻辑顺序与存储顺序总是一致的。 理由同7。链式存储就无需一致。 二、单项选择题 （C ）1．数据在计算机存储器内表示时，物理地址与逻辑地址相同并且是连续的，称之为：（A）存储结构（B）逻辑结构（C）顺序存储结构（D）链式存储结构（ B ）2. 一个向量第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是（A）110 （B）108 （C）100 （D）120 （ A ）3. 在n个结点的顺序表中，算法的时间复杂度是O（1）的操作是： （A）访问第i个结点（1≤i≤n）和求第i个结点的直接前驱（2≤i≤n） （B）在第i个结点后插入一个新结点（1≤i≤n） （C）删除第i个结点（1≤i≤n） （D）将n个结点从小到大排序 （ B ）4. 向一个有127个元素的顺序表中插入一个新元素并保持原来顺序不变，平均要移动个元素（A）8 （B）63.5 （C）63 （D）7 （ A ）5. 链式存储的存储结构所占存储空间： 第二章线性表 一、填空题 1、数据逻辑结构包括线性结构、树型结构、图型结构这三种类型，树形结构和图形结构合称为非线性结构。 2、在线性结构中，第一个结点没有前驱结点，其余每个结点有且只有个前驱结点，最后一个结点没有后续结点，其余每个结点有且只有一个后续结点。 3、在顺序表中插入或删除一个元素，需要平均移动一半元素，具体移动的元素个数与插入或删除的位置有关。 4、在顺序表中，逻辑上相邻的元素，其物理位置一定相邻。在单链表中，逻辑上相邻的元素，其物理位置不一定相邻。 5、在带头结点的非空单链表中，头结点的存储位置由头指针指示，首元素结点的存储位置由头结点的next域指示，除首元素结点外，其它任一元素结点的存储位置由其直接前趋结点的next域指示。 6、阅读下列算法，并补充所缺内容。 void purge_linkst( ListNode *& la ) { // 从头指针为 la 的有序链表中删除所有值相同的多余元素，并释放被删结点空间ListNode *p,*q; if(la==NULL) return; q=la; p = la->link; while (p) { if (p && ___(1)p->data!=q->data___) {q=p; p = p->link;} else { q->link= ___(2)p->link___; delete(p); p=___(3)q->link___; } }//while }// purge_linkst 二、选择题 1、在数据结构中，从逻辑上可以把数据结构分成 C。 A、动态结构和静态结构 B、紧凑结构和非紧凑结构 C、线性结构和非线性结构 D、内部结构和外部结构 2、线性表的逻辑顺序与存储顺序总是一致的，这种说法 B。 A、正确 B、不正确 3、线性表若采用链式存储结构时，要求内存中可用存储单元的地址D。 A、必须是连续的 B、部分地址必须是连续的 C、一定是不连续的 D、连续或不连续都可以 4、在以下的述叙中，正确的是B。 A、线性表的线性存储结构优于链表存储结构 B、二维数组是其数据元素为线性表的线性表 C、栈的操作是先进先出 D、队列的操作方式是先进后出 三、综合题 1、已知L是无表头结点的单链表，且P结点既不是首元结点，也不是尾元结点，试从下列提供的答案中选择合适的语句序列。 A、在P结点后插入S结点的语句序列是（（4）、（1））； B、在P结点前插入S结点的语句序列是（（7）、（11）、（8）、（4）、（1））； C、在表首插入S结点的语句序列是（（5）、（12））； 第2章线性表 一、选择题 1.表长为N 的顺序表，当在任何位置上插入或删除一个元素的概率相等时，插入一个元素所需移动元素的平均次数为（），删 除一个元素需要移动的元素个数为（）。【＊＊，★】 A. (N-1)/2 B. N C. N+1 D. N-1 E. N/2 F. (N+1)/2 G. (N-2)/2 2.线性表是具有N 个（）的有限序列。【＊】 A、表元素 B、字符 C、数据元素 D、数据项 E、信息 3.“线性表的逻辑顺序和物理顺序总是一致的。”这个结论是（）。【＊】 A、正确的 B、错误的 C、不一定，与具体结构有关。 4.线性表采用链式存储结构时，要求内存中可用存储单元的地址（）。【＊，★】 A、必须是连续的 B、部分地址必须是连续的 C、一定是不连续的 D、连续或不连续都可以。 5.带头结点的单链表为空的判定条件是（）。【＊】 A、head==NULL B、head->next==NULL C、head->next==head D、head!=NULL 6.不带头结点的单链表head 为空的判定条件是（）。【＊】 A、head==NULL B、head->next==NULL C、head->next==head D、head!=NULL 7.非空的循环单链表head 的尾结点P 满足（）。（注:带头结点）【＊】 A、P->NEXT=NULL B、p=NULL C、p->next==head D、p==head 8.在一个具有n 个结点的有序单链表中插入一个新结点并仍然有序的时间复杂度是（）。【＊，★】 A、O(1) B、O(n) C、O(n2) D、O(nlog2n) 9.在一个单链表中，若删除P 所指结点的后继结点，则执行（）。【＊，★】 A、p->next=p->next->next B、p=p->next;p->next=p->next->next C、p->next=p->next; D、p=p->next->next; 10.在一个单链表中，若在Ｐ所指结点之后插入Ｓ所指结点，则执行（）。【＊，★】 第 2 章线性表 课后习题讲解 1. 填空 ⑴在顺序表中，等概率情况下，插入和删除一个元素平均需移动（）个元素，具体移动元素的个数与（）和（）有关。 【解答】表长的一半，表长，该元素在表中的位置 ⑵顺序表中第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的存储地址是（）。【解答】108 【分析】第5个元素的存储地址=第1个元素的存储地址＋(5－1)×2=108 ⑶设单链表中指针p 指向结点A，若要删除A的后继结点（假设A存在后继结点），则需修改指针的操作为（）。 【解答】p->next=(p->next)->next ⑷单链表中设置头结点的作用是（）。 【解答】为了运算方便 【分析】例如在插入和删除操作时不必对表头的情况进行特殊处理。 ⑸非空的单循环链表由头指针head指示，则其尾结点（由指针p所指）满足（）。 【解答】p->next=head 【分析】如图2-8所示。 ⑹在由尾指针rear指示的单循环链表中，在表尾插入一个结点s的操作序列是（）；删除开始结点的操作序列为（）。 【解答】s->next =rear->next; rear->next =s; rear =s; q=rear->next->next; rear->next->next=q->next; delete q; 【分析】操作示意图如图2-9所示： ⑺一个具有n个结点的单链表，在指针p所指结点后插入一个新结点的时间复杂度为（）；在给定值为x的结点后插入一个新结点的时间复杂度为（）。 【解答】Ο(1)，Ο(n) 【分析】在p所指结点后插入一个新结点只需修改指针，所以时间复杂度为Ο(1)；而在给定值为x的结点后插入一个新结点需要先查找值为x的结点，所以时间复杂度为Ο(n)。 ⑻可由一个尾指针唯一确定的链表有（）、（）、（）。 【解答】循环链表，循环双链表，双链表 2. 选择题 ⑴线性表的顺序存储结构是一种（）的存储结构，线性表的链接存储结构是一种（）的存储结构。 A 随机存取 B 顺序存取 C 索引存取 D 散列存取 【解答】A，B 【分析】参见2.2.1。 ⑵线性表采用链接存储时，其地址（）。 A 必须是连续的 B 部分地址必须是连续的 C 一定是不连续的 D 连续与否均可以 【解答】D 【分析】线性表的链接存储是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以连续，也可以不连续，甚至可以零散分布在内存中任意位置。 ⑶单循环链表的主要优点是（）。 A 不再需要头指针了 B 从表中任一结点出发都能扫描到整个链表； C 已知某个结点的位置后，能够容易找到它的直接前趋； D 在进行插入、删除操作时，能更好地保证链表不断开。 【解答】B ⑷链表不具有的特点是（）。 A 可随机访问任一元素 B 插入、删除不需要移动元素 C 不必事先估计存储空间 D 所需空间与线性表长度成正比 【解答】A ⑸若某线性表中最常用的操作是取第i 个元素和找第i个元素的前趋，则采用（）存储方法最节省时间。 A 顺序表 B 单链表 C 双链表 D 单循环链表 【解答】A 【分析】线性表中最常用的操作是取第i 个元素，所以，应选择随机存取结构即顺序表，同时在顺序表中查找第i个元素的前趋也很方便。单链表和单循环链表既不能实现随机存取，查找第i个元素的前趋也不方便，双链表虽然能快速查找第i个元素的前趋，但不能实现随机存取。 ⑹若链表中最常用的操作是在最后一个结点之后插入一个结点和删除第一个结点，则采用（）存储方法最节省时间。 A 单链表 B 带头指针的单循环链表 C 双链表 D 带尾指针的单循环链表 第2章线性表 1．选择题 （1）顺序表中第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是（）。 A．110 B．108 C．100 D．120 答案：B 解释：顺序表中的数据连续存储，所以第5个元素的地址为：100+2*4=108。 （2）在n个结点的顺序表中，算法的时间复杂度是O(1)的操作是（）。 A．访问第i个结点（1≤i≤n）和求第i个结点的直接前驱（2≤i≤n） B．在第i个结点后插入一个新结点（1≤i≤n） C．删除第i个结点（1≤i≤n） D．将n个结点从小到大排序 答案：A 解释：在顺序表中插入一个结点的时间复杂度都是O(n2)，排序的时间复杂度为O(n2)或O(nlog2n)。顺序表是一种随机存取结构，访问第i个结点和求第i个结点的直接前驱都可以直接通过数组的下标直接定位，时间复杂度是O(1)。 （3）向一个有127个元素的顺序表中插入一个新元素并保持原来顺序不变，平均要移动的元素个数为（）。 A．8 B．63.5 C．63 D．7 答案：B 解释：平均要移动的元素个数为：n/2。 （4）链接存储的存储结构所占存储空间（）。 A．分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针 B．只有一部分，存放结点值 C．只有一部分，存储表示结点间关系的指针 D．分两部分，一部分存放结点值，另一部分存放结点所占单元数 答案：A （5）线性表若采用链式存储结构时，要求内存中可用存储单元的地址（）。 A．必须是连续的B．部分地址必须是连续的 C．一定是不连续的D．连续或不连续都可以 答案：D （6）线性表Ｌ在（）情况下适用于使用链式结构实现。 A．需经常修改Ｌ中的结点值Ｂ．需不断对Ｌ进行删除插入 C．Ｌ中含有大量的结点Ｄ．Ｌ中结点结构复杂 答案：B 《数据结构》 第二章线性表习题 一、单项选择题 1. 线性表是________。 A．一个有限序列，可以为空B．一个有限序列，不可以为空 C．一个无限序列，可以为空D．一个无限序列，不可以为空 2. 在一个长度为n的顺序表中删除第i个元素(0<=i<=n)时，需向前移动个元素。 A．n-i B．n-i+l C．n-i-1 D．i 3. 线性表采用链式存储时，其地址________。 A．必须是连续的B．一定是不连续的 C．部分地址必须是连续的D．连续与否均可以 4. 从一个具有n个结点的单链表中查找其值等于x的结点时，在查找成功的情况下，需平均比较________个元素结点。 A．n/2 B．n C．（n+1）/2 D．（n-1）/2 5. 在双向循环链表中，在p所指的结点之后插入s指针所指的结点，其操作是____。 A． p->next=s; s->prior=p; p->next->prior=s; s->next=p->next; B． s->prior=p; s->next=p->next; p->next=s; p->next->prior=s; C． p->next=s; p->next->prior=s; s->prior=p; s->next=p->next; D． s->prior=p; s->next=p->next; p->next->prior=s; p->next=s; 6. 设单链表中指针p指向结点m，若要删除m之后的结点（若存在），则需修改指针的操作为________。A．p->next=p->next->next; B．p=p->next; C．p=p->next->next; D．p->next=p; 7. 在一个长度为n的顺序表中向第i个元素(0< i 《数据结构》教材课后习题+答案数据结构 第一章介绍 数据结构是计算机科学中重要的概念，它涉及到组织和存储数据的方法和技术。数据结构的选择对于算法的效率有着重要的影响。本教材为读者提供了丰富的课后习题，以帮助读者巩固所学知识并提高解决问题的能力。下面是一些选定的习题及其答案，供读者参考。 第二章线性表 习题一： 给定一个顺序表L，编写一个算法，实现将其中元素逆置的功能。 答案一： 算法思路： 1. 初始化两个指针i和j，分别指向线性表L的首尾两个元素 2. 对于L中的每一个元素，通过交换i和j所指向的元素，将元素逆置 3. 当i>=j时，停止逆置 算法实现： ```python def reverse_list(L): i, j = 0, len(L)-1 while i < j: L[i], L[j] = L[j], L[i] i += 1 j -= 1 ``` 习题二： 给定两个线性表A和B，编写一个算法，将线性表B中的元素按顺序插入到线性表A中。 答案二： 算法思路： 1. 遍历线性表B中的每一个元素 2. 将B中的元素依次插入到A的末尾 算法实现： ```python def merge_lists(A, B): for element in B: A.append(element) ``` 第三章栈和队列 习题一： 编写一个算法，判断一个表达式中的括号是否匹配。表达式中的括号包括小括号"()"、中括号"[]"和大括号"{}"。 答案一： 算法思路： 1. 遍历表达式中的每一个字符 2. 当遇到左括号时，将其推入栈中 3. 当遇到右括号时，判断栈顶元素是否与其匹配 4. 当遇到其他字符时，继续遍历下一个字符 5. 最后判断栈是否为空，若为空则表示括号匹配 算法实现： ```python def is_matching(expression): stack = [] for char in expression: if char in "([{": 数据结构(第二版)课后习题答案第一章：数据结构概述 数据结构是计算机科学中非常重要的一个概念，它用于组织和管理计算机内部存储的数据。数据结构的设计直接影响到程序的运行效率和对真实世界问题的建模能力。第二版的《数据结构》教材旨在帮助读者更好地理解和应用数据结构。为了提高学习效果，每章节后都附有一系列习题。本文将为第二版《数据结构》教材中的部分习题提供详细的答案和解析。 第二章：线性表 2.1 顺序表 习题1：请问如何判断顺序表是否为空表？ 答案：当顺序表的长度为0时，即为空表。 解析：顺序表是用一块连续的内存空间存储数据元素的线性结构。当顺序表中没有元素时，长度为0，即为空表。 习题2：如何求顺序表中第i个元素的值？ 答案：可以通过访问顺序表的第i-1个位置来获取第i个元素的值。 解析：顺序表中的元素在内存中是连续存储的，通过下标访问元素时，需要将下标减1，因为数组是从0开始编号的。 2.2 链表 习题1：请问链表中的结点包含哪些信息？ 答案：链表的结点一般包含两部分信息：数据域和指针域。 解析：数据域用于存储数据元素的值，指针域用于存储指向下一个 结点的指针。 习题2：如何删除链表中的一个结点？ 答案：删除链表中的一个结点需要将其前一个结点的指针指向其后 一个结点，然后释放被删除结点的内存空间。 解析：链表的删除操作相对简单，只需要通过修改指针的指向即可。但需要注意释放被删除结点的内存空间，防止内存泄漏。 第三章：栈和队列 3.1 栈 习题1：如何判断栈是否为空？ 答案：当栈中没有任何元素时，即为空栈。 解析：栈是一种先进后出（Last In First Out，LIFO）的数据结构， 栈顶指针指向栈顶元素。当栈中没有元素时，栈顶指针为空。 习题2：请问入栈和出栈操作的时间复杂度是多少？ 答案：入栈和出栈操作的时间复杂度均为O(1)。 解析：栈的入栈和出栈操作只涉及栈顶指针的改变，不受栈中元素 数量的影响，因此时间复杂度为O(1)。 第2章自测卷答案 一、填空 1. 【严题集 2.2①】在顺序表中插入或删除一个元素，需要平均移动表中一半元素，具体移动的元素个数与表长和该元素在表中的位置有关。 2. 线性表中结点的集合是有限的，结点间的关系是一对一的。 3. 向一个长度为n的向量的第i个元素(1≤i≤n+1)之前插入一个元素时，需向后移动n-i+1 个元素。 4. 向一个长度为n的向量中删除第i个元素(1≤i≤n)时，需向前移动n-i 个元素。 5. 在顺序表中访问任意一结点的时间复杂度均为O(1)，因此，顺序表也称为随机存取的数据结构。 6. 【严题集2.2①】顺序表中逻辑上相邻的元素的物理位置必定相邻。单链表中逻辑上相邻的元素的物理位置不一定相邻。 7. 【严题集2.2①】在单链表中，除了首元结点外，任一结点的存储位置由其直接前驱结点的链域的值指示。 8．在n个结点的单链表中要删除已知结点*p，需找到它的前驱结点的地址，其时间复杂度为O（n）。二、判断正误（在正确的说法后面打勾，反之打叉） （×）1. 链表的每个结点中都恰好包含一个指针。 答：错误。链表中的结点可含多个指针域，分别存放多个指针。例如，双向链表中的结点可以含有两个指针 域，分别存放指向其直接前趋和直接后继结点的指针。 （×）2. 链表的物理存储结构具有同链表一样的顺序。错，链表的存储结构特点是无序，而链表的示意图有序。（×）3. 链表的删除算法很简单，因为当删除链中某个结点后，计算机会自动地将后续的各个单元向前移动。错，链表的结点不会移动，只是指针内容改变。 （×）4. 线性表的每个结点只能是一个简单类型，而链表的每个结点可以是一个复杂类型。 错，混淆了逻辑结构与物理结构，链表也是线性表！且即使是顺序表，也能存放记录型数据。 （×）5. 顺序表结构适宜于进行顺序存取，而链表适宜于进行随机存取。 错，正好说反了。顺序表才适合随机存取，链表恰恰适于“顺藤摸瓜” （×）6. 顺序存储方式的优点是存储密度大，且插入、删除运算效率高。 错，前一半正确，但后一半说法错误，那是链式存储的优点。顺序存储方式插入、删除运算效率较低， 在表长为n的顺序表中，插入和删除一个数据元素，平均需移动表长一半个数的数据元素。 （×）7. 线性表在物理存储空间中也一定是连续的。 错，线性表有两种存储方式，顺序存储和链式存储。后者不要求连续存放。 （×）8. 线性表在顺序存储时，逻辑上相邻的元素未必在存储的物理位置次序上相邻。 错误。线性表有两种存储方式，在顺序存储时，逻辑上相邻的元素在存储的物理位置次序上也相邻。（×）9. 顺序存储方式只能用于存储线性结构。 错误。顺序存储方式不仅能用于存储线性结构，还可以用来存放非线性结构，例如完全二叉树是属于 非线性结构，但其最佳存储方式是顺序存储方式。（后一节介绍） （×）10. 线性表的逻辑顺序与存储顺序总是一致的。 错，理由同7。链式存储就无需一致。 三、单项选择题 （C）1．数据在计算机存储器内表示时，物理地址与逻辑地址相同并且是连续的，称之为：（A）存储结构（B）逻辑结构（C）顺序存储结构（D）链式存储结构（ B ）2.一个向量第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是（A）110 （B）108 （C）100 （D）120 （ A ）3. 在n个结点的顺序表中，算法的时间复杂度是O（1）的操作是： （A）访问第i个结点（1≤i≤n）和求第i个结点的直接前驱（2≤i≤n） （B）在第i个结点后插入一个新结点（1≤i≤n） 第二章线性表 2.1描述以下三个概念的区别：头指针，头结点，首元结点（第一个元素结点）。 并说明头指针和头结点的作用。 答：头指针是一个指针变量，里面存放的是链表中首结点的地址，并以此来标识一个链表。如链表H，链表L等，表示链表中第一个结点的地址存放在H、L中。头结点是附加在第一个元素结点之前的一个结点，头指针指向头结点。当该链表表示一个非空的线性表时，头结点的指针域指向第一个元素结点，为空表时，该指针域为空。 开始结点指第一个元素结点。 头指针的作用是用来惟一标识一个单链表。 头结点的作用有两个：一是使得对空表和非空表的处理得以统一。二是使得在链表的第一个位置上的操作和在其他位置上的操作一致，无需特殊处理。 2.2填空题 1、在顺序表中插入或删除一个元素，需要平均移动（表中一半）元素，具体移动的元素个数与（表长和该元素在表中的位置）有关。 2、顺序表中逻辑上相邻的元素的物理位置（必定）相邻。单链表中逻辑上相邻的元素的物理位置（不一定）相邻。 3、在单链表中，除了首元结点外，任一结点的存储位置由（其直接前驱结点的链域的值）指示。 4、在单链表中设置头结点的作用是（插入和删除元素不必进行特殊处理）。 2.3何时选用顺序表、何时选用链表作为线性表的存储结构为宜? 答：在实际应用中，应根据具体问题的要求和性质来选择顺序表或链表作为线性表的存储结构，通常有以下几方面的考虑： 1.基于空间的考虑。当要求存储的线性表长度变化不大，易于事先确定其大小时，为了节约存储空间，宜采用顺序表；反之，当线性表长度变化大，难以估计其存储规模时，采用动态链表作为存储结构为好。 2.基于时间的考虑。若线性表的操作主要是进行查找，很少做插入和删除操作时，采用顺序表做存储结构为宜；反之，若需要对线性表进行频繁地插入或删除等的操作时，宜采用链表做存储结构。并且，若链表的插入和删除主要发生在 数据结构第二章习题解答 一、单选题 1．在一个长度为n的顺序存储线性表中，向第i个元素(1≤i≤n+1)之前插入一个新元素时，需要从后向前依次后移（B）个元素。 A、n-i B、n-i+1 C、n-i-1 D、i 2．在一个长度为n的顺序存储线性表中，删除第i个元素(1≤i≤n+1)时，需要从前向后依次前移（A）个元素。 A、n-i B、n-i+1 C、n-i-1 D、i 3. 在一个长度为n的线性表中顺序查找值为x的元素时，在等概率情况下，查找成功时的平均查找长度（即需要比较的元素个数）为( C )。 A. n B. n/2 C. (n+1)/2 D. (n-1)/2 4．在一个长度为n的线性表中，删除值为x的元素时需要比较元素和移动元素的总次数为(C )。 A. (n+1)/2 B. n/2 C. n D. n+1 5. 在一个顺序表的表尾插入一个元素的时间复杂度为(B )。 A. O(n) B. O(1) C. O(n*n) D. O(log2n) 6.若一个结点的引用为p，它的前驱结点的引用为q，则删除p的后继结点的操作为(B )。 A. p=p.next.next B. p.next=p.next.next C. q.next=p.next D. q.next=q.next.next 8. 假定一个多项式中x的最高次幂为n，则在保存所有系数项的线性表表示中，其线性表长度为(A )。 A. n+1 B. n C. n-1 D. n+2 二、填空题 1．对于当前长度为n的线性表，共包含有________多个插入元素的位置，共包含有________多个删除元素的位置。（答案n+1 n） 2．若经常需要对线性表进行表尾插入和删除运算，则最好采用________存储结构，若经 常需要对线性表进行表头插入和删除运算，则最好采用________存储结构。（答案：顺序链式） 3．由n个元素生成一个顺序表，若每次都调用插入算法把一个元素插入到表头，则整个算法的时间复杂度为________，若每次都调用插入算法把一个元素插入到表尾，则整个算法的时间复杂度为________。（答案：O（n）O（n）） 4．由n个元素生成一个单链表，若每次都调用插入算法把一个元素插入到表头，则整个算法的时间复杂度为________，若每次都调用插入算法把一个元素插入到表尾，则整个算法的时间复杂度为________。（答案：O（1）O（1）） 5. 对于一个长度为n的顺序存储的线性表，在表头插入元素的时间复杂度为________， 在表尾插入元素的时间复杂度为________。（答案：O（n），O（1）） 6. 对于一个单链接存储的线性表，在表头插入结点的时间复杂度为________，在表尾插 入结点的时间复杂度为________。（答案：O（1），O（1）） 7. 从一个顺序表和单链表中访问任一个给定位置序号的元素（结点）的时间复杂度分别 为________和_______。（答案：O（1），O（n）） 三、算法设计题 1. 修改从顺序存储的集合中删除元素的算法，要求当删除一个元素后检查数组空间的大小，若空间利用率小于40%同时数组长度大于maxSize时则释放数组的一半存储空间。public void remove(int i) throws Exception{ （A ）需经常修改L 中的结点值 （E ）需不断对L 进行删除插入 第二部分线性表 、选择题 1 •关于顺序存储的叙述中，哪一条是不正确的 （B ） A. 存储密度大 B. 逻辑上相邻的结点物理上不必邻接 C. 可以通过计算直接确定第 i 个结点的位置 D. 插入、删除操作不方便 2.长度为n 的单链表连接在长度为 m 的单链表后的算法的时间复杂度为 （C ） A 0（ n ） B 0（1） C 0（m ） D 0（m+n ） 3 .在n 个结点的顺序表中，算法的时间复杂度是 0（1）的操作是：（A ） A 访问第i 个结点（1<=i<=n ）和求第i 个结点的直接前趋（2<=i<=n ) B 在第i 个结点（1<=i<=n ）后插入一个新结点 C 删除第i 个结点（1<=i<=n ) D 将n 个结点从小到大排序 4.一个向量第一个兀素的存储地址是 100 ,每个兀素的长度为 2 ,则第5 个兀素的地址是 (B ) ( A ) 110 ( B ) 108 (C ) 100 ( D ) 120 5 .已知一个顺序存储的线性表， 设每个结点需要占 m 个存储单元，若第一个结点的地址为 da , 则第i 个结点的地址为：（A ） 7 .链表是一种采用（ B ）存储结构存储的线性表。 （A ）顺序 （B ）链式 （C ）星式 （D ）网状 8 .线性表若采用链式存储结构时，要求内存中可用存储单兀的地址： （D ） （A ）必须是连续的 （B ）部分地址必须是连续的 （C ）一定是不连续的 （D ）连续或不连续都可以 9 .线性表L 在_ （ B ）情况下适用于使用链式结构实现。 A ） da+（i-1）*m B ） da+i*m 6.在具有n 个结点的单链表中，实现（ A ）遍历链表和求链表的第 i 个结点 C ）删除开始结点 C ） da-i*m D ） da+（i+1）*m A ）的操作，其算法的时间复杂度为 0（n ）。 B ）在地址为p 的结点之后插入一个结点 D ） 删除地址为p 的结点的后继结点 数据结构第二章参考答案 习题2 1. 填空题 （1）在一个单链表中，已知每个结点包含data和next两个域，q所指结点是p所指结点的直接前驱，若在q和p之间插入s所指结点，则执行（___________）和（___________）操作。 答案：q->next = s; s->next = p; 或 s->next=q->next; q->next = s; （2）表长为n的顺序表，当在任何位置上插入或删除一个元素的概率相等时，插入一个元素所需移动元素的平均个数为（___________），删除一个元素需要移动元素的平均个数为（___________）。答案：n/2 (n-1)/2 （3）表长为0的线性表称为（___________）。答案：空表 （4）动态内存管理是操作系统的基本功能之一，其作用是响应用户程序对内存的（___________）和（___________）请求。答案：申请释放 （5）顺序表多采用（___________）实现的，是一种随机存取结构，对表中任意结点存取操作的时间复杂度为（___________）。而查找链表中的结节，需要从头指针起顺着链扫描才能得到，平均时间复杂度为（___________）。因此，若线性表的操作主要是进行查找，很少进行插入或删除操作时，采用 （___________）表比较合适。答案：数组 O(1) O(n) 顺序 （6）在链表某个位置上进行插入和删除操作，只需要修改（___________）即可，而无须移动大量元素，操作的时间复杂度为（___________）。而在顺序表中进行插入和删除操作，往往要移动大量元素，平均移动元素的数目为 （___________），平均时间复杂度为（___________）。因此，若对线性表进行频繁的插入和删除操作时，采用（___________）表相对合适。若插入和删除主要发生在表头和表尾，则采用（___________）表更为合适。答案：指针 O(1) 表长的一半 O(n) 链循环链 （7）静态链表一般采用（___________）存储的链表结构。答案：数组（8）对于32位计算机环境，若单链表中的数据类型为整性，则其存储密度为 《数据结构题集》参考答案2线性表 第二章线性表 ◆2.11②设顺序表L中的数据元素递增有序。 试写一算法，将x插入到L的适当位置上，并保 持该表的有序性。 要求实现下列函数： void InsertOrderList(SqList &L, ElemType x) /* 在有序的顺序表 L 中保序插入数据元素 x */ 顺序表类型定义如下： typedef struct { ElemType *elem; int length; int listsize; } SqList; void InsertOrderList(SqList &L, ElemType x) // 在有序的顺序表 L 中保序插入数据元素 x { int j,i=L.length-1; while (x 的共同前缀为(x,y,y,z)，在两表中除去最大共同前缀后 的子表分别为A'=(x,z)和B'=(y,x,x,z)）。若A'=B'=空表，则A=B；若A'=空表，而B'≠空表，或者两者均不为空表，且A'的首元小于B'的首元，则AB。试写一个比较A和B大小的算法。（注意：在算法中，不要破坏原表A 和B，也不一定先求得A'和B'才进行比较）。 要求实现下列函数： char Compare(SqList A, SqList B); /* 比较顺序表A和B, */ /* 返回'<', 若A<="" p=""> /* '=', 若A=B; */ /* '>', 若A>B */ 顺序表类型定义如下： typedef struct { ElemType *elem; int length; int listsize; } SqList; char Compare(SqList A, SqList B) // 比较顺序表A和B, // 返回'<', 若A 数据结构练习题线性表习题及答案 精品文档 第二章线性表 一．名词解释 1.线性结构 2.数据结构的顺序实现 3.顺序表 4.链表 5.数据结构的链接实现 6. 建表 7.字符串 8.串 9.顺序串 10.链串 二、填空题 1.为了便于讨论，有时将含n(n>=0)个结点的线性结构表示成(a，a,……a)，其中每n12个a代表一个______。a称为______结点，a称为______结点，i称为a在线性表中的________ii1n或______。对任意一对相邻结点a、a(1<=i 7.线性表典型的基本运算包括:______、______、______、______、______、______等六种。 8.顺序表的特点是______。 9.顺序表的类型定义可经编译转换为机器级。假定每个datatype 类型的变量占用k(k>=1)个内存单元，其中，b是顺序表的第一个存储结点的第一个单元的内存地址，那么，第i个结点a的存储地址为______。i10.以下为顺序表的插入运算，分析算法，请在______处填上正确的语句。Void insert_sqlist(sqlist L，datatype x，int i) /*将X插入到顺序表L的第i-1个位置*/ { if( https://www.doczj.com/doc/db19181918.html,/doc/158aeafe640e52ea551810a6 f524ccbff021cafb.html st == maxsize) error(“表满”)； if((i<1)||(i>https://www.doczj.com/doc/db19181918.html,/doc/158aeafe640e52ea55 1810a6f524ccbff021cafb.html st+1))error(“非法位置”); for(j=https://www.doczj.com/doc/db19181918.html,/doc/158aeafe640e52ea551810 a6f524ccbff021cafb.html st;j>=i;j--)______; L.data[i-1]=x; https://www.doczj.com/doc/db19181918.html,/doc/158aeafe640e52ea551810a6f52 4ccbff021cafb.html st=https://www.doczj.com/doc/db19181918.html,/doc/158aeafe640e52ea551810a6f524 ccbff021cafb.html st+1; } 11.对于顺序表的插入算法insert_sqlist来说，若以结点移动为标准操作，则插入算法的最坏时间复杂性为________，量级是________。插入算法的平均时间复杂性为________，平均时间复杂性量级是________。 12.以下为顺序表的删除运算，分析算法，请在________处填上正确的语句。 void delete_sqlist(sqlist L,int i) /*删除顺序表L中的第i-1个位置上的结点*/ {if((i<1)||(i>https://www.doczj.com/doc/db19181918.html,/doc/158aeafe640e52ea55181 数据结构练习题第二章线性表习题及答案 第二章线性表 一．名词解释 1.线性结构 2.数据结构的顺序实现 3.顺序表 4.链表 5.数据结构的链接实现 6. 建表 7.字符串 8.串 9.顺序串10.链串 二、填空题 1.为了便于讨论，有时将含n(n>=0)个结点的线性结构表示成(a，a,……a)，其中每个n12a代表一个______。a称为______结点，a称为______结点，i称为a在线性表中的________i1in或______。对任意一对相邻结点a、a(1<=i 8.顺序表的特点是______。 9.顺序表的类型定义可经编译转换为机器级。假定每个datatype 类型的变量占用k(k>=1)个内存单元，其中，b是顺序表的第一个存储结点的第一个单元的内存地址，那么，第i个结点a的存储地址为______。i10.以下为顺序表的插入运算，分析算法，请在______处填上正确的语句。Void insert_sqlist(sqlist L，datatype x，int i) /*将X插入到顺序表L的第i-1个位置*/ { if( == maxsize) error(“表满”)； if((i<1)||(i>+1))error(“非法位置”); for(j=;j>=i;j--)______; [i-1]=x; =+1; } 11.对于顺序表的插入算法insert_sqlist来说，若以结点移动为标准操作，则插入算法的最坏时间复杂性为________，量级是________。插入算法的平均时间复杂性为________，平均时间复杂性量级是________。 12.以下为顺序表的删除运算，分析算法，请在________处填上正确的语句。 void delete_sqlist(sqlist L,int i) /*删除顺序表L中的第i-1个位置上的结点*/ {if((i<1)||(i>)error(“非法位置”)； for(j=i+1;j=;j++)________; =; } 13.对于顺序表的删除算法delete_sqlist来说，若以结点移动为标准操作，最坏情况时间复杂性及其量级分别是________和________,其平均时间复杂性及其量级分别为________和。________ 14.以下为顺序表的定位运算，分析算法，请在________处填上正确的语句。 int locate_sqlist(sqlist L,datatype X)数据结构第2章作业 线性表(答案)
第二章_线性表(参考答案)
《数据结构》习题及答案：第2章 线性表(第1次更新3)
数据结构(C++版)课后答案 (王红梅)第2章 线性表
数据结构线性表课后答案
《数据结构》第二章线性表习题及参考答案
《数据结构》教材课后习题+答案
数据结构(第二版)课后习题答案
数据结构第2章线性表习题及答案
数据结构课后习题答案第二章 线性表
《数据结构》吕云翔编著第2章线性表习题解答
(完整版)数据结构第二章线性表1答案
数据结构第二章参考答案
《数据结构题集》参考答案2线性表
数据结构练习题线性表习题及答案
数据结构练习题第二章线性表习题及答案
相关主题
文本预览