数据结构2（线性表）

Posted 2022-03-21 -xiangbei-

第2章  线性表

【例2-1】试编写出将两个顺序存储的有序表A和B合成一个有序表C的算法。

解：假设A、B和C的类型为下述SqList类型：

#define  maxlen  1000

typedef  int  elemtype 

typedef  struct 

  elemtype  elem[maxlen];   

int  len;   

SqList;      

设A和B的数据元素均为整数且为升序排列，设A的长度为m，B的长度为n，则合并后C的长度为m+n。合并时进行A、B元素的比较，将较小的链入C中，算法描述如下：

int merge (SqList *A, SqList *B, SqList *C)  //将两个有序表A和B合成一个有序表C

  int m,n,i,j,k;

   m=(*A).len;  n=(*B).len;

if (m+n>maxlen-1)

        printf("overflow");

exit (0);

     i=0; j=0;  //i和j分别作为扫描顺序表A和B的指针

k=0;  //k指示顺序表C中当前位置

     while ((i<=m)&&(j<=n))

        if((*A).elem[i]<＝(*B).elem[j])

             (*C).elem[k]＝(*A)elem[i];

              i++;   k++;

          

        else

  (*C).elem[k]＝(*B)elem[j];

              j++;   k++;

          

     while(i<=m)  //表B已结束，表A没有结束，链入表A的剩余部分

           (*C).elem[k]＝(*A).elem[i];

            i++;  k++;

       

     while(j<=m)  //表A已结束，表B没有结束，链入表B的剩余部分

          (*C).elem[k]＝(*B).elem[j];

           i++;  k++;

       

     return (1);

【例2-2】写一算法实现单链表的逆置。

解：假设单链表的表头指针用head表示，其类型为下面定义的LinkList，并且单链表不带头结点。逆置后原来的最后一个结点成为第一个结点，于是从第一个结点开始逐个修改每个结点的指针域进行逆置，且刚被逆置的结点总是新链表的第一个结点，故令head指向它（如图2-1所示）。

typedef  struct  Node

  elemtype  data;

struct  Node  *next;

LinkList;

 

 

具体算法描述如下：

 

 

 

 

 

 

 

 

 

 

 

 

void  contray(LinkList *head)

  //将head单链表中所有结点按相反次序链接

   LinkList *p, *q;

p=head;  //p指向未被逆序的第一个结点,初始时指向原表头结点

   head=NULL;

   while(p!=NULL)

     q=p;  //q指向将被逆序链接的结点

      p=p->next;

      q->next=head;

      head=q;

   

【例2-3】假设有一个循环链表的长度大于1，且表中既无头结点也无头指针，已知p为指向链表中某结点的指针，设计在链表中删除p所指结点的前趋结点的算法。

解：可引入一个指针q，当q->next=p时，说明此时q所指的结点为p所指结点的前趋结点，从而可得算法如下：

void delete (LinkList *p)

  //在链表中删除p所指结点的前趋结点

LinkList *q,*t;

   q=p;

   while(q->next->next!=p)  //q->next不是p的前趋结点

      q=q->next;

       t=q->next;  //t指向要删除结点

       q->next=p;  //删除t结点

       free(t);

｝

【例2-4】试设计实现删除单链表中值相同的多余结点的算法。

解：该例可以这样考虑，先取开始结点的值，将它与其后的所有结点值一一比较，发现相同的就删除掉，然后再取第二结点的值，重复上述过程直到最后一个结点。

设单链表（其类型为LinkList）的头指针head指向头结点，则可按下列步骤执行：

首先，用一个指针p指向单链表中第一个表结点，然后用另一个指针q查找链表中其余结点元素，由于是单链表，故结束条件为p= =NULL，同时让指针s指向q所指结点的前趋结点，当查找到结点具有q->data= =p->data时删除q所指的结点，然后再修改q，直到q为空；然后使p指针后移（即p=p->next），重复进行，直到p为空时为止。算法描述如下：

del(LinkList *head)

  //删除单链表中值相同的多余结点

   LinkList *p, *s, *q;

   p=head->next;

while(p!=NULL && p->next!=NULL)

  s=p;   //s指向要删除结点的前趋

q=p->next;

         while (q!=NULL)

   if (q->data= =p->data)  //查找值相同的结点并删除

                    s->next=q->next;

                     free(q);

                     q=s->next;

                  

                else

                     s=q;

                      q=q->next;

                  

           

p=p->next;

习题2

一、单项选择题

1. 线性表是________。1．A

A．一个有限序列，可以为空     B．一个有限序列，不可以为空

C．一个无限序列，可以为空     D．一个无限序列，不可以为空

2. 在一个长度为n的顺序表中删除第i个元素(0<=i<=n)时，需向前移动    个元素。  2．A 

A．n-i       B．n-i+l       C．n-i-1       D．i

3. 线性表采用链式存储时，其地址________。3．D

A．必须是连续的              B．一定是不连续的

C．部分地址必须是连续的       D．连续与否均可以   

    4. 从一个具有n个结点的单链表中查找其值等于x的结点时，在查找成功的情况下，需平均比较________个元素结点。4．C  //任选一个节点，它的最少比较次数到最大比较次数的平均

A．n/2        B．n           C．（n+1）/2    D．（n-1）/2

    5. 在双向循环链表中，在p所指的结点之后插入s指针所指的结点，其操作是____。5．D 

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之后的结点（若存在），则需修改指针的操作为________。6．A  

A．p->next=p->next->next;        B．p=p->next;

C．p=p->next->next;          D．p->next=p;

    7. 在一个长度为n的顺序表中向第i个元素(0< i<n+l )之前插入一个新元素时，需向后移动______个元素。7．B 

A．n-i          B．n-i+l         C．n-i-1           D．i

8. 在一个单链表中，已知q结点是p结点的前趋结点，若在q和p之间插入s结点，则须执行8．B 

A．s->next=p->next;  p->next=s

B．q->next=s;  s->next=p

C．p->next=s->next;  s->next=p

D．p->next=s;  s->next=q

9. 以下关于线性表的说法不正确的是______。9．C   

A．线性表中的数据元素可以是数字、字符、记录等不同类型。

B．线性表中包含的数据元素个数不是任意的。

C．线性表中的每个结点都有且只有一个直接前趋和直接后继。

D．存在这样的线性表：表中各结点都没有直接前趋和直接后继。

10. 线性表的顺序存储结构是一种_______的存储结构。  10．A 

A．随机存取       B．顺序存取     C．索引存取     D．散列存取

11. 在顺序表中，只要知道_______，就可在相同时间内求出任一结点的存储地址。11．D 

A．基地址                B．结点大小    

C．向量大小               D．基地址和结点大小//就是首地址和偏移量

12. 在等概率情况下，顺序表的插入操作要移动______结点。  12．B 

A．全部                   B．一半  

C．三分之一              D．四分之一

//已经有N个点了,再加一个就是N+1个.假设新加的结点插在第i位,那么后面N+1-i个结点都要往后移动. i的取值服从1到N+1的平均分布,即概率是1/(N+1). 求期望得N/2,即平均要移动N/2个结点
    13. 在______运算中，使用顺序表比链表好。  13．C  

A．插入                  B．删除  

C．根据序号查找          D．根据元素值查找

14. 在一个具有n个结点的有序单链表中插入一个新结点并保持该表有序的时间复杂度是_______。  14．B

A．O(1)                  B．O(n)  

C．O(n²)                  D．O(log2n)

15. 设有一个栈，元素的进栈次序为A, B, C, D, E,下列是不可能的出栈序列__________。15．C 

A．A, B, C, D, E          B．B, C, D, E, A

C．E, A, B, C, D          D．E, D, C, B, A

    16. 在一个具有n个单元的顺序栈中，假定以地址低端（即0单元）作为栈底，以top作为栈顶指针，当做出栈处理时，top变化为______。16．C  

A．top不变       B．top=0        C．top--        D．top++

17. 向一个栈顶指针为hs的链栈中插入一个s结点时，应执行______。17．B 

A．hs->next=s;               

B．s->next=hs;   hs=s;//s的下一节点是hs，hs再指向s

C．s->next=hs->next;hs->next=s;  

D．s->next=hs; hs=hs->next;

//节点Node中存有此节点存于栈中的元素以及指向下个节点的指针

    18. 在具有n个单元的顺序存储的循环队列中，假定front和rear分别为队头指针和队尾指针，则判断队满的条件为________。18．D 

A．rear％n= = front      B．（front+l）％n= = rear

C．rear％n -1= = front    D．(rear+l)％n= = front

    19. 在具有n个单元的顺序存储的循环队列中，假定front和rear分别为队头指针和队尾指针，则判断队空的条件为________。19．C    

A．rear％n= = front      B．front+l= rear

C．rear= = front         D．(rear+l)％n= front

20. 在一个链队列中，假定front和rear分别为队首和队尾指针，则删除一个结点的操作为________。20．A

A．front=front->next   　 B．rear=rear->next

C．rear=front->next     　D．front=rear->next

二、填空题

1. 线性表是一种典型的____线性_____结构。

2. 在一个长度为n的顺序表的第i个元素之前插入一个元素，需要后移___．n-i+1_个元素。

3. 顺序表中逻辑上相邻的元素的物理位置_____相邻___。   

4. 要从一个顺序表删除一个元素时，被删除元素之后的所有元素均需__前移_____一个位置，移动过程是从___前____向__后_____依次移动每一个元素。

5. 在线性表的顺序存储中，元素之间的逻辑关系是通过___物理存储位置____决定的；在线性表的链接存储中，元素之间的逻辑关系是通过__链域的指针值_____决定的。      

6. 在双向链表中，每个结点含有两个指针域，一个指向___前趋____结点，另一个指向____后继___结点。

7. 当对一个线性表经常进行存取操作，而很少进行插入和删除操作时，则采用___顺序____存储结构为宜。相反，当经常进行的是插入和删除操作时，则采用___链接____存储结构为宜。       

8. 顺序表中逻辑上相邻的元素，物理位置__一定_____相邻，单链表中逻辑上相邻的元素，物理位置____不一定___相邻。

9. 线性表、栈和队列都是____线性___结构，可以在线性表的___任何___位置插入和删除元素；对于栈只能在____栈顶___位置插入和删除元素；对于队列只能在___队尾____位置插入元素和在___队头____位置删除元素。

10. 根据线性表的链式存储结构中每个结点所含指针的个数，链表可分为____单链表_____和____双链表___；而根据指针的联接方式，链表又可分为____非循环链表____和____循环链表_____

11. 在单链表中设置头结点的作用是____使空表和非空表统一；算法处理一致____。

12. 对于一个具有n个结点的单链表，在已知的结点p后插入一个新结点的时间复杂度为___ O(1)___，在给定值为x的结点后插入一个新结点的时间复杂度为__ O(n)_____。

    13. 对于一个栈作进栈运算时，应先判别栈是否为__栈满_____，作退栈运算时，应先判别栈是否为___栈空____，当栈中元素为m时，作进栈运算时发生上溢，则说明栈的可用最大容量为___ m ____。为了增加内存空间的利用率和减少发生上溢的可能性，由两个栈共享一片连续的内存空间时，应将两栈的___栈底____分别设在这片内存空间的两端，这样只有当____两个栈的栈顶在栈空间的某一位置相遇___时才产生上溢。//双进栈操作

14. 设有一空栈，现有输入序列1，2，3，4，5，经过push, push, pop, push, pop, push, push后，输出序列是____2、3_____。

15. 无论对于顺序存储还是链式存储的栈和队列来说，进行插入或删除运算的时间复杂度均相同为_____ O(1)_____。

 

三、简答题

1. 描述以下三个概念的区别：头指针，头结点，表头结点。

1．指向链表第一个结点的指针是头指针；在表头结点之前附设的结点称为头结点；表头结点为链表中存储线性表中第一个数据元素的结点。若链表中附设头结点，则不管线性表是否为空表，头指针均不为空，否则表示空表的链表的头指针为空。

//在单链表中，设置头结点的作用是，使得空表和非空表统一，算法处理一致

 

2. 线性表的两种存储结构各有哪些优缺点？

2．线性表具有两种存储结构即顺序存储结构和链接存储结构。线性表的顺序存储结构可以直接存取数据元素，方便灵活、效率高，但插入、删除操作时将会引起元素的大量移动，因而降低效率：而在链接存储结构中内存采用动态分配，利用率高，但需增设指示结点之间关系的指针域，存取数据元素不如顺序存储方便，但结点的插入、删除操作较简单。

 

3. 对于线性表的两种存储结构，如果有n个线性表同时并存，而且在处理过程中各表的长度会动态发生变化，线性表的总数也会自动改变，在此情况下，应选用哪一种存储结构？为什么？

3．应选用链接存储结构，因为链式存储结构是用一组任意的存储单元依次存储线性表中的各元素，这里存储单元可以是连续的，也可以是不连续的：这种存储结构对于元素的删除或插入运算是不需要移动元素的，只需修改指针即可，所以很容易实现表的容量的扩充。

 

4. 对于线性表的两种存储结构，若线性表的总数基本稳定，且很少进行插入和删除操作，但要求以最快的速度存取线性表中的元素，应选用何种存储结构？试说明理由。

4．应选用顺序存储结构，因为每个数据元素的存储位置和线性表的起始位置相差一个和数据元素在线性表中的序号成正比的常数。因此，只要确定了其起始位置，线性表中的任一个数据元素都可随机存取，因此，线性表的顺序存储结构是一种随机存取的存储结构，而链表则是一种顺序存取的存储结构。

 

5. 在单循环链表中设置尾指针比设置头指针好吗？为什么?

5．设尾指针比设头指针好。尾指针是指向终端结点的指针，用它来表示单循环链表可以使得查找链表的开始结点和终端结点都很方便，设一带头结点的单循环链表，其尾指针为rear，则开始结点和终端结点的位置分别是rear->next->next 和 rear, 查找时间都是O(1)。若用头指针来表示该链表，则查找终端结点的时间为O(n)。

 

6. 假定有四个元素A, B, C, D依次进栈，进栈过程中允许出栈，试写出所有可能的出栈序列。

6．共有14种可能的出栈序列，即为：

ABCD, ABDC，ACBD, ACDB，BACD，ADCB，BADC，BCAD, BCDA，BDCA,CBAD, CBDA，CDBA, DCBA

 

7. 什么是队列的上溢现象？一般有几种解决方法，试简述之。

7．在队列的顺序存储结构中，设队头指针为front，队尾指针为rear，队列的容量（即存储的空间大小）为maxnum。当有元素要加入队列（即入队）时，若rear=maxnum，则会发生队列的上溢现象，此时就不能将该元素加入队列。对于队列，还有一种“假溢出”现象，队列中尚余有足够的空间，但元素却不能入队，一般是由于队列的存储结构或操作方式的选择不当所致，可以用循环队列解决。

    一般地，要解决队列的上溢现象可有以下几种方法：

（1）可建立一个足够大的存储空间以避免溢出，但这样做往往会造成空间使用率低，浪费存储空间。

（2）要避免出现“假溢出”现象可用以下方法解决：

    第一种：采用移动元素的方法。每当有一个新元素入队，就将队列中已有的元素向队头移动一个位置，假定空余空间足够。

    第二种：每当删去一个队头元素，则可依次移动队列中的元素总是使front指针指向队列中的第一个位置。

    第三种：采用循环队列方式。将队头、队尾看作是一个首尾相接的循环队列，即用循环数组实现，此时队首仍在队尾之前，作插入和删除运算时仍遵循“先进先出”的原则。

 

 

8. 下述算法的功能是什么?

LinkList  *Demo(LinkList *L)

  // L是无头结点的单链表

LinkList *q,*p;

if(L&&L->next)

  q=L; L=L->next; p=L;

　　　while (p->next) 

p=p->next;

　　  p->next=q; q->next=NULL;

　　

　　return (L);

8．该算法的功能是：将开始结点摘下链接到终端结点之后成为新的终端结点，而原来的第二个结点成为新的开始结点，返回新链表的头指针。

 

 

四、算法设计题

1. 设计在无头结点的单链表中删除第i个结点的算法。

1．算法思想为：

（1）应判断删除位置的合法性，当i<0或i>n-1时，不允许进行删除操作；

（2）当i=0时，删除第一个结点：

（3）当０<i<n时，允许进行删除操作，但在查找被删除结点时，须用指针记住该结点的前趋结点。算法描述如下：

delete(LinkList *q,int i)

  //在无头结点的单链表中删除第i个结点

   LinkList  *p,*s;

   int  j;

   if(i<0)

      printf("Can‘t delete");

   else if(i= =0)

        s=q;

         q=q->next;

         free(s);

      

else

    j=0; s=q;

          while((j<i) && (s! = NULL))

              p=s;

               s=s->next;

j++;

if (s= =NULL)  

printf("Cant‘t  delete");

          else

                p->next=s->next;

                 free(s);

             

        

 

2. 在单链表上实现线性表的求表长ListLength(L)运算。

2．由于在单链表中只给出一个头指针，所以只能用遍历的方法来数单链表中的结点个数了。算法描述如下：

int ListLength ( LinkList *L )

  //求带头结点的单链表的表长

　 int len=0;

　 ListList *p;

　 p=L;

　 while ( p->next!=NULL )

  p=p->next;

　　　len++;

　

　 return (len);

 

3. 设计将带表头的链表逆置算法。

3．设单循环链表的头指针为head，类型为LinkList。逆置时需将每一个结点的指针域作以修改，使其原前趋结点成为后继。如要更改q结点的指针域时，设s指向其原前趋结点，p指向其原后继结点，则只需进行q->next=s;操作即可，算法描述如下：

void invert(LinkList  *head)

  //逆置head指针所指向的单循环链表

linklist *p, *q, *s;

   q=head;

   p=head->next;

   while (p!=head)  //当表不为空时，逐个结点逆置

     s=q;

      q=p;

      p=p->next;

      q->next=s;

   

    p->next=q;

 

 

 

4. 假设有一个带表头结点的链表，表头指针为head，每个结点含三个域：data, next和prior。其中data为整型数域，next和prior均为指针域。现在所有结点已经由next域连接起来，试编一个算法，利用prior域（此域初值为NULL）把所有结点按照其值从小到大的顺序链接起来。

4．定义类型LinkList如下：

typedef struct node

  int data;

   struct node *next,*prior;

LinkList;

此题可采用插入排序的方法，设p指向待插入的结点，用q搜索已由prior域链接的有序表找到合适位置将p结点链入。算法描述如下：

insert (LinkList *head)

   LinkList *p,*s,*q;

    p=head->next;  //p指向待插入的结点，初始时指向第一个结点

    while(p!=NULL)

      s=head;  // s指向q结点的前趋结点

       q=head->prior;  //q指向由prior域构成的链表中待比较的结点

       while((q!=NULL) && (p->data>q->data))  //查找插入结点p的合适的插入位置

  s=q;

             q=q->prior;

         

       s->prior=p;

       p->prior=q;  //结点p插入到结点s和结点q之间

       p=p->next;

 

5. 已知线性表的元素按递增顺序排列，并以带头结点的单链表作存储结构。试编写一个删除表中所有值大于min且小于max的元素（若表中存在这样的元素）的算法。

5．算法描述如下：

delete(LinkList *head, int max, int min)

  linklist *p, *q;

   if (head!=NULL)

     q=head;

      p=head->next;

      while((p!=NULL) && (p->data<=min))

        q=p;

p=p->next;

while((p!=NULL) && (p->data<max))

         p=p->next;

      q->next=p;　

 

6. 已知线性表的元素是无序的，且以带头结点的单链表作为存储结构。设计一个删除表中所有值小于max但大于min的元素的算法。

6．算法描述如下：

delete(LinkList *head, int max, int min)

  LinkList *p,*q;

   q=head;

   p=head->next;

   while (p!=NULL)

      if((p->data<=min) || (p->data>=max))

        q=p;

         p=p->next;

     

else

  q->next=p->next;

free(p);

p=q->next;

 

 

7. 假定用一个单循环链表来表示队列（也称为循环队列），该队列只设一个队尾指针，不设队首指针，试编写下列各种运算的算法：

（1）向循环链队列插入一个元素值为x的结点；

（2）从循环链队列中删除一个结点。

7．本题是对一个循环链队列做插入和删除运算，假设不需要保留被删结点的值和不需要回收结点，算法描述如下：

（1）插入（即入队）算法：

insert(LinkList *rear, elemtype x)

  //设循环链队列的队尾指针为rear,x为待插入的元素

   LinkList *p;

p=(LinkList *)malloc(sizeof(LinkList));

if(rear= =NULL)  //如为空队，建立循环链队列的第一个结点

  rear=p;

rear->next=p;   //链接成循环链表

else  //否则在队尾插入p结点

     p->next=rear->next;

rear->next=p;

      rear=p;

（2）删除（即出队）算法：

delete(LinkList  *rear)

  //设循环链队列的队尾指针为rear

if (rear= =NULL)  //空队

      printf("underflow\n");

if(rear->next= =rear)  //队中只有一个结点

rear=NULL;

else

rear->next=rear->next->next;  //rear->next指向的结点为循环链队列的队头结点

 

8. 设顺序表L是一个递减有序表，试写一算法，将x插入其后仍保持L的有序性。

8．只要从终端结点开始往前找到第一个比x大(或相等)的结点数据，在这个位置插入就可以了。算法描述如下：

int InsertDecreaseList( SqList *L, elemtype x )

  int i;

if ( (*L).len>= maxlen)

  printf(“overflow");

return(0);

for ( i=(*L).len ; i>0 && (*L).elem[ i-1 ] < x ; i--)

      (*L).elem[ i ]=(*L).elem[ i-1 ] ;   // 比较并移动元素

   (*L).elem[ i ] =x;

   (*L).len++;

return(1);