数据结构习题——第二章线性表

╰半夏微凉° 2022-11-01 05:37 167阅读 0赞

**整理自己学习过程中接触的习题，不断更新中。答案在每个部分后面。**

# **第一部分：** #

第二章 线性表

一、选择题

1．下述哪一条是顺序存储结构的优点？（ ）

A．存储密度大 B．插入运算方便 C．删除运算方便 D．可方便地用于各种逻辑结构的存储表示

2．下面关于线性表的叙述中，错误的是哪一个？（ ）

A．线性表采用顺序存储，必须占用一片连续的存储单元。

B．线性表采用顺序存储，便于进行插入和删除操作。

C．线性表采用链接存储，不必占用一片连续的存储单元。

D．线性表采用链接存储，便于插入和删除操作。

3．若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算，则利用（ ）存储方式最节省时间。

A．顺序表 B．双链表 C．带头结点的双循环链表D．单循环链表

4．某线性表中最常用的操作是在最后一个元素之后插入一个元素和删除第一个元素，则采用（ ）存储方式最节省运算时间。

A．单链表 B．仅有头指针的单循环链表C．双链表 D．仅有尾指针的单循环链表

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

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

6．从一个具有n个结点的单链表中查找其值等于x的结点时，在查找成功的情况下，需平均比较（）个元素结点

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

7．设单链表中指针p指向结点m，若要删除m之后的结点（若存在），则需修改指针的操作为（ ）

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

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

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

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．线性表的顺序存储结构是一种（ ）的存储结构。

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

二、填空

1．在线性表的顺序存储中，元素之间的逻辑关系是通过 决定的；在线性表的链接存储中，元素之间的逻辑关系是通过 决定的。

2．在双向链表中，每个结点含有两个指针域，一个指向 结点，另一个指向 结点。

3．当对一个线性表经常进行存取操作，而很少进行插入和删除操作时，则采用 存储结构为宜。相反，当经常进行的是插入和删除操作时，则采用 存储结构为宜。

三、算法设计

1．设有一个正整数序列组成的有序单链表（按递增次序有序，且允许有相等的整数存在），试编写能实现下列功能的算法（要求用最少的时间和最小的空间）

①确定在序列中比正整数x大的数有几个（相同的数只计算一次）

②将单链表中比正整数x小的偶数从单链表中删除

2．设有一个表头指针为h的单链表。试设计一个算法，通过遍历一趟链表，将链表中所有结点的链接方向逆转，如下图所示。要求逆转结果链表的表头指针h指向原链表的最后一个结点。

![Center][]

3．设计算法将一个带头结点的单链表A分解为两个具有相同结构的链表B、C，其中B表的结点为A表中值小于零的结点，而C表的结点为A表中值大于零的结点（链表A的元素类型为整型，要求B、C表利用A表的结点）。

4. 假设链表A、B分别表示一个集合，试设计算法以判断集合A是否是集合B的子集，若是，则返回1，否则返回0，并分析算法的时间复杂度。

5．设有一单循环链表la，其结点有三个域：prior、data与next，其中data为数据域,，next域指向直接后继，prior域应指向直接前驱，但目前空着。试写一算法将此单循环链表改造为双向循环链表。

参 考 答 案

第二章 线性表

一．选择题

1．A

2．B

3．A

4．D

5．A

6．C

7．A

8．B

9．A

二、填空

1．物理位置相邻 指针

2．直接前驱 直接后继

3．顺序 链式

三、算法设计

1．①
    int count(Linklist h,int x)
    {
        int num=0;
        Linknode *p;
        p=h->next;
        while(p&&p->data<=x)
            p=p->next;
        while(p)
            if(p->next&&p->data==p->next->data)
                p=p->next;
            else
            {
                num++;
                p=p->next;
            }
        return num;
    }
    
    ②   void delevenl(Linklist h,int x)
    {
        Linknode *p,*r;
        p=h->next;r=h;
        while(p&&p->data<x)
        {
            if(p->data%2==0)
            {
                r->next=p->next;
                free(p);
                p=r->next;
            }
            else
            {
                r=p;
                p=p->next;
            }
        }
    }
    2．
    void Inverse（Linklist &h）
    {
        Linklist p,q;
        p=h; h=null;
        while(p)
        { q=p; p=p->next;
            q->next=h;
            h=q; }
    }
    3．
    void merge(Linklist La,Linklist&Lb,Linklist &Lc)
    {
        Linknode*p;
        Lc=newLnode;
        Lc->next=NULL;
        p=La->next;
        Lb=La;
        Lb->next=NULL;
        while(p)
        {
            La=p->next;
            if(p->data>0)
            {
                p->next=Lc->next;
                Lc->next=p;
            }
            else
            {
                p->next=Lb->next;
                Lb->next=p;
            }
            p=La;
        }
    }
    4．
    int insect(Linklist La,Linklist Lb)
    {
        Linknode*p,*q;
        p=La->next;
        while(p)
        {
            q=Lb->next;
            while(q)
            {
                if(p->data==q->data)
                    break;
                else
                    q=q->next;
            }
            if(!q)
                return0;
            p=p->next;
        }
        return1;
    }
    5．
    void change(Dublist &h)
    {
        DubLnode*p;
        p=h;
        while(p->next!=h)
        {
            p->next->prior=p;
            p=p->next;
        }
        h->prior=p;
    }

# 第二部分： #

##  第2章 线性表 ##

### 2.1　选择题 ###

1．对于线性表最常用的操作是查找指定序号的元素和在末尾插入元素，则选择（ ）最节省时间

A）顺序表 B）带头结点的双循环链表

C）单链表 D）带尾结点的单循环链表

【答案】A

2．若长度为n的线性表采用顺序存储结构，在其第i个位置插入一个新元素的算法时间复杂度为（　　）(1≤i≤n+1)。

A） O(0) B） O(1) C） O(n) D） O(n2)

【答案】C

3．双向链表中有两个指针域，prior和next，分别指向前驱及后继，设p指向链表中的一个结点，q指向一待插入结点，现要求在p前插入q，则正确的插入为（ ）

A） p->prior=q; q->next=p; p->prior->next=q; q->prior=p->prior;

B） q->prior=p->prior; p->prior->next=q; q->next=p; p->prior=q->next;

C） q->next=p; p->next=q; p->prior->next=q; q->next=p;

D） p->prior->next=q; q->next=p; q->prior=p->prior; p->prior=q;

【答案】D

4．在一个具有n个结点的有序单链表中插入一个新结点并仍然保持有序的时间复杂度是（ ）

A）O(nlog2n） B） O(1） C） O(n） D） O(n2）

【答案】C

5． 在一个以 h 为头指针的单循环链中，p 指针指向链尾结点的条件是（ ）

A）p->next==NULL B） p->next==h

C）p->next->next==h D） p->data==-1

【答案】B

6．对于一个具有n个结点的线性表，建立其单链表的时间复杂度是（　　）

A）O(n) B） O(1) C）O(nlog2n) D） O(n2)

【答案】A

8．在双向链表存储结构中，删除p所指的结点时须修改指针（　　）

A）p->prior->next=p->next p->next->prior=p->prior;

B）p->prior=p->prior->prior p->prior->next=p;

C）p->next->prior=p p->next=p->next->next

D）p->next=p->prior->prior p->prior=p->next->next;

【答案】A

9．线性表采用链式存储时，其元素地址（　　）

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

C）部分地址是连续的 D）连续与否均可

【答案】D

### 2.2　填空题 ###

1．线性表L=（a1，a2，…，an）用数组表示，假定删除表中任一元素的概率相同，则删除一个元素平均需要移动元素的个数是\_\_\_\_\_\_\_\_\_\_\_\_\_。

【答案】（n-1）/2

2．在单链表中设置头结点的作用是\_\_\_\_\_\_\_\_\_\_\_\_\_。

【答案】主要是使插入和删除等操作统一，在第一个元素之前插入元素和删除第一个结点不必另作判断。另外，不论链表是否为空，链表头指针不变。

3．线性表的顺序存储是通过\_\_\_\_\_\_\_\_\_\_\_\_\_来反应元素之间的逻辑关系，而链式存储结构是通过\_\_\_\_\_\_\_\_\_\_\_\_\_来反应元素之间的逻辑关系。

【答案】（1）数据元素的前后顺序 （2）元素中的指针

4．当对一个线性表经常进行的是存取操作，而很少进行插入和删除操作时，则采用\_\_\_\_\_\_\_\_\_\_\_\_\_存储结构最节省时间，相反当经常进行插入和删除操作时，则采用\_\_\_\_\_\_\_\_\_\_\_\_\_存储结构最节省时间。

【答案】（1）顺序 （2）链式

5．对于一个具有n个结点的单链表，在已知的结点\*p后插入一个新结点的时间复杂度为\_\_\_\_\_\_\_\_\_\_\_\_\_，在给定值为x的结点后插入一个新结点的时间复杂度为\_\_\_\_\_\_\_\_\_\_\_\_\_。

【答案】（1）O(1) （2）O(n)

7. 对于双向链表，在两个结点之间插入一个新结点需修改的指针共\_\_\_\_\_\_\_\_\_\_\_\_\_个，单链表为\_\_\_\_\_\_\_\_\_\_\_\_\_个。

【答案】（1）4 （2）2

8. 循环单链表的最大优点是\_\_\_\_\_\_\_\_\_\_\_\_\_。

【答案】从任一结点出发都可访问到链表中每一个元素。

9．若要在一个不带头结点的单链表的首结点\*p结点之前插入一个\*s结点时，可执行下列操作：

s->next=\_\_\_\_\_\_\_\_\_\_\_\_\_;

p->next=s;

t=p->data;

p->data= \_\_\_\_\_\_\_\_\_\_\_\_\_;

s->data=\_\_\_\_\_\_\_\_\_\_\_\_\_;

【答案】（1）p->next （2）s->data （3） t

10．某线性表采用顺序存储结构，每个元素占据4个存储单元，首地址为100，则下标为11的（第12个）元素的存储地址为\_\_\_\_\_\_\_\_\_\_\_\_\_。

【答案】144

11．带头结点的双循环链表L中只有一个元素结点的条件是\_\_\_\_\_\_\_\_\_\_\_\_\_。

【答案】L->next->next==L

### 2.3 　判断题 ###

1．取线性表的第i个元素的时间同i的大小有关（　　）

【答案】×

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

【答案】×

3． 顺序存储方式的优点是存储密度大，且插入、删除运算效率高（　　）

【答案】×

4．线性表采用链表存储时，结点的存储空间可以是不连续的（　　）

【答案】√

5．链表是采用链式存储结构的线性表，进行插入、删除操作时，在链表中比在顺序存储结构中效率高（　　）

【答案】√

6．顺序存储方式只能用于存储线性结构（　　）

【答案】×

【解析】线性结构、树型结构和图状结构均可用顺序存储表示。

9．顺序存储结构的主要缺点是不利于插入或删除操作（　　）

【答案】√

10．顺序存储方式插入和删除时效率太低，因此它不如链式存储方式好（　　）

【答案】×

### 2.4　程序设计题 ###

1．设顺序表va中的数据元素递增有序。试设计一个算法，将x插入到顺序表的适当位置上，以保持该表的有序性。

【算法源代码】

##### void Insert\_SqList(SqList va,int x)/\*把x插入递增有序表va中\*/ #####

##### \{ int i; #####

#####  if(va.length> MAXSIZE) return; #####

#####  for(i=va.length-1;va.elem\[i\]>x&&i>=0;i--) #####

#####  va.elem\[i+1\]=va.elem\[i\]; #####

#####  va.elem\[i+1\]=x; #####

#####  va.length++; #####

##### \}/\*Insert\_SqList\*/ #####

2．设 A=（a1，a2，…，am） 和 B=（b1，b2，…，bn）均为顺序表，试设计一个比较A，B大小的算法（请注意：在算法中，不要破坏原表A和B）。

【算法分析】比较顺序表A和B，并用返回值表示结果，值为1，表示A>B；值为-1，表示A<B；值为0，表示A=B。

1）当两个顺序表可以互相比较时，若对应元素不等，则返回值为1或-1；

2）当两个顺序表可以互相比较的部分完全相同时，若表长也相同，则返回值为0；否则，哪个较长，哪个就较大

【算法源代码】

##### int ListComp(SqList A,SqList B) #####

##### \{  #####

#####  for(i=1;i<=A.length&&i<=B.length;i++) #####

#####  if(A.elem\[i\]!=B.elem\[i\]) #####

#####  return A.elem\[i\]>B.elem\[i\]?1:-1; #####

#####  if(A.length==B.length) return 0; #####

#####  return A.length>B.length?1:-1; #####

##### /\*当两个顺序表可以互相比较的部分完全相同时，哪个较长，哪个就较大\*/ #####

##### \}/\*ListComp \*/ #####

3．已知指针 ha和 hb分别指向两个单链表的头结点，并且已知两个链表的长度分别为m和n。试设计一个算法将这两个链表连接在一起（即令其中一个表的首元结点连在另一个表的最后一个结点之后），假设指针hc指向连接后的链表的头结点，并要求算法以尽可能短的时间完成连接运算。

【算法分析】

1）单链表ha的头结点作为连接后的链表的头结点，即hc=ha；

2）查找单链表ha的最后一个结点，由指针p指向，即p->next==NULL；

3）将单链表hb的首元结点（非头结点）连接在p之后，即p->next=hb->next；

4）回收单链表hb的头结点空间

【算法源代码】

##### void ListConcat(LinkList ha,LinkList hb,LinkList \*hc) #####

##### /\*把链表hb接在ha后面形成链表hc\*/ #####

##### \{  #####

#####  \*hc=ha; #####

#####  p=ha;/\*由指针p指向ha的尾元结点\*/ #####

#####  p=p->next; #####

#####  p->next=hb->next; #####

#####  free(hb); #####

##### \}/\*ListConcat \*/ #####

4．试设计一个算法，在无头结点的动态单链表上实现线性表操作INSERT（L，i，b），并和在带头结点的动态单链表上实现相同操作的算法进行比较。

【算法分析】

1）生成新结点存放元素b，由指针new指向；

2）将new插入在单链表的第i个元素的位置上：若i==1，new插在链表首部；否则查找第i-1个结点，由指针p指向，然后将new插在p之后。

【算法源代码】

##### void Insert(LinkList \*L,int i,int b) #####

##### \{ LinkList new; #####

#####  new=(LinkList\*)malloc(sizeof(LNode)); #####

#####  new->data=b;  #####

#####  if(i==1) #####

#####  \{/\*插入在链表头部\*/ #####

#####  New->next=\*L; #####

#####  \*L=new; #####

#####  \} #####

#####  else #####

#####  \{ /\*插入在第i个元素的位置\*/ #####

#####  p=\*L; #####

#####  while(--i>1) p=p->next; #####

#####  new->next=p->next;p->next=new; #####

#####  \} #####

##### \}/\*Insert \*/ #####

5．已知线性表中的元素以值递增有序排列，并以单链表作存储结构。试设计一个高效的算法，删除表中所有值大于 mink且小于 maxk的元素（若表中存在这样的元素），同时释放被删结点空间（注意：mink和maxk是给定的两个参变量。它们的值可以和表中的元素相同，也可以不同）。

【算法分析】

1）查找最后一个不大于mink的元素结点，由指针p指向；

2）如果还有比mink更大的元素，查找第一个不小于maxk的元素，由指针q指向；

3）p->next=q，即删除表中所有值大于 mink且小于 maxk的元素。

【算法源代码】

##### void Delete\_Between(LinkList \*L,int mink,int maxk) #####

##### \{  #####

#####  p=\*L; #####

#####  while(p->next->data<=mink) p=p->next; /\*p是最后一个不大于mink的元素\*/ #####

#####  if(p->next) /\*如果还有比mink更大的元素\*/ #####

#####  \{  #####

#####  q=p->next; #####

#####  while(q->data<maxk) q=q->next; /\*q是第一个不小于maxk的元素\*/ #####

#####  p->next=q; #####

#####  \} #####

##### \}/\*Delete\_Between \*/ #####

[Center]: /images/20221024/d73cc8f5dd4d48cdbbab1bc3582c1ab5.png

数据结构习题——第二章线性表

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关数据结构第二章线性表相关习题

相关数据结构第二章线性表

相关数据结构：第二章线性表

相关数据结构---第二章_线性表-顺序表的实现

相关《数据结构》复习——第二章线性表

相关数据结构习题——第二章线性表

相关数据结构-----第二章线性表

相关数据结构第二章线性表

相关数据结构学习笔记第二章线性表

相关数据结构第二章线性表作业