数据结构复习题（线性表）

线性表

选择题

用单链表方式存储的线性表，存储每个节点需要两个域，一个是数据域，另一个是( )
A 当前结点所在地址域
B 指针域
C 空指针域
D 空闲域

下列有关线性表的叙述中，正确的是( )。
A 线性表中的元素之间是线性关系
B 线性表中至少有一个元素
C 线性表中任何一个元素有且仅有一个直接前趋
D 线性表中任何一个元素有且仅有一个直接后继

下列有关线性表的叙述中，正确的是( )。
A 线性表中的元素之间是线性关系
B 线性表中至少有一个元素
C 线性表中任何一个元素有且仅有一个直接前趋
D 线性表中任何一个元素有且仅有一个直接后继

带头结点的单链表head为空的判定条件是( )。
A head==NULL
B head->next==NULL
C head->next!=NULL
D head!=NULL

非空的单循环链表L的尾节点p，满足( )。
A p->next==NULL
B p==NULL
C p->next==L
D p==L

非空的循环单链表head的尾结点(由p所指向)满足( )
A p->next == NULL
B p == NULL
C p->next == head
D p == head

顺序表的一个存储节点仅存储线性表的一个( )。
A 数据元素
B 数据项
C 数据
D 数据结构
链表是一种采用 存储结构存储的线性表；
（A）顺序
（B）链式
（C）星式
（D）网状

在一个长度为n的顺序表中删除第i个元素，需要向前移动( )个元素。
A n-i
B n-i+1
C n-i-1
D i+1

在一个长度为n的顺序表中，在第i个元素之前插入一个新元素时，需向后移动( )个元素。
A n-i
B n-i+1
C n-i-1
D i

在表长为n的顺序表中，当在任何位置删除一个元素的概率相同时，删除一个元素所需移动的平均个数为( )。
A (n-1)/2
B n/2
C (n+1)/2
D n

顺序表中，插入一个元素所需移动的元素平均数是( )。
A (n-1)/2
B n
C n+1
D (n+1)/2

对于顺序表，以下说法错误的是( )。
A 顺序表是用一维数组实现的线性表，数组的下标可以看做元素的地址
B 顺序表的所有存储节点按相应数据元素间的逻辑关系决定的次序依次排列
C 顺序表的特点是：逻辑结构中相邻的节点在存储结构中仍相邻
D 顺序表的特点是：逻辑上相邻的元素，存储在物理位置也相邻的单元中

在表长为n的顺序表上做插入运算，平均要移动的结点数为( )。
An
B n/2
C n/3
D n/4

已知一个顺序存储的线性表，设每个结点需占m个存储单元，若第一个结点的地址为d1，则第i个结点的地址为( )
A d1+(i-1)m
B d1+im
C d1-i*m
D d1+(i+1)*m

设指针p指向双链表的某一节点，则双链表结构的对称性可用( )来描述。
A p->prior->next==p->next->next
B p->prior->prior==p->next->prior
C p->prior->next==p->next->prior
D p->next->next==p->prior->prior

在一个单链表中，若删除p所指向结点的后续结点，则执行( )。
A p->next=p->next->next
B p=p->next，p->next=p->next->next
C p=p->next
D p=p->next->next

线性表的顺序存储结构是一种( )存储结构。
A 随机存取
B 顺序存取
C 索引存取
D 散列存取

链表中指针的全部作用就是( )。
A 指向某常量
B 指向某变量
C 指向某结点
D 存储某数据

L是顺序表，已知LENGTH(L)的值是5，经运算DELETEL(L,2)后LENGTH(L)的值是( )
A 5
B 0
C 4
D 6

线性表是n个( )的有限序列。
A 表元素
B 字符
C 数据元素
D 数据项

若一个线性表中最常用的操作是取第i个元素和找第i个元素的前趋元素，则采用( )存储方式最节省时间。
A 顺序表
B 单链表
C 双链表
D 单循环链表

在线性表的下列存储结构中，读取元素花费的时间最少的是( )
A 单链表
B 双链表
C 循环链表
D 顺序表

在单链表中，增加头结点的目的( )。
A 使单链表至少有一个节点
B 标示表节点中首节点的位置
C 方便运算的实现
D 说明单链表是线性表的链式存储实现

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

下面关于线性表的叙述中，错误的是哪一个？( )
A 线性表采用顺序存储，必须占用一片连续的存储单元
B 线性表采用顺序存储，便于进行插入和删除操作
C 线性表采用链式存储，不必占用一片连续的存储单元
D 线性表采用链式存储，便于插入和删除操作

线性表采用链式存储时，其地址( )
A 必须是连续的
B 一定是不连续的
C 部分地址必须是连续的
D 连续与否均可以

单链表的一个存储节点包含( )。
A 数据域或指针域
B 指针域或链域
C 指针域和链域
D 数据域和链域

单链表的存储密度
（Ａ）大于1；
（Ｂ）等于1；
（Ｃ）小于1；
（Ｄ）不能确定

线性表L在( )情况下适用于使用链式结构实现
A 需经常修改Ｌ中的结点值
B 需不断对Ｌ进行删除插入
C Ｌ中含有大量的结点
D Ｌ中结点结构复杂

一个顺序表的第一个元素的存储地址是90，每个元素的长度为2，则第6个元素的存储地址是( )。
A 98
B 100
C 102
D 106

设a1、a2、a3为3个结点，整数P0，3，4代表地址，则如下的链式存储结构称为

（Ａ）循环链表
（Ｂ）单链表
（Ｃ）双向循环链表
（Ｄ）双向链表

循环链表的主要优点是( )。
A 不再需要头指针了
B 已知某个节点的位置后，能够容易地找到它的直接前驱
C 在进行插入、删除运算时，能更好的保证链表不断开
D 从表中任一节点出发都能扫描到整个链表

顺序表的长度是( )
A 表中的存储空间数
B 表中的数据元素个数
C 存储空间数减去数据元素个数
D 存储空间数加数据元素个数

在单链表中插入结点的时间复杂度是( )
A O(1)
B O(n)
C O(n2)
D O(log2n)

若长度为n的线性表采用顺序存储结构，在其第i个位置插入一个新元素算法的时间复杂度( )。
A O(log2n)
B O(1)
C O(n)
D O(n2)

将长度为n的单链表连接在长度为m的单链表之后的算法的时间复杂度为( )。
A O(1)
B O(n)
C O(m)
D O(m+n)

链表不具有的特点是( )。
A 可随机访问任一元素
B 插入删除不需要移动元素
C 不必事先估计存储空间
D 所需空间与线性表长度成正比

单链表的存储密度( )
A 大于1
B 等于1
C 小于1
D 不能确定

.一个向量第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是
（A）110
（B）108
（C）100
（D）120

向一个有127个元素的顺序表中插入一个新元素并保持原来顺序不变，平均要移动 个元素
（A）8
（B）63.5
（C）63
（D）7

填空题

线性表的顺序存储比链式存储最与利于进行（ ）操作。
答案：表尾插入或删除

链表不具备的特点是（ ）。
答案：可随机访问任一结点

在顺序表中访问任意一结点的时间复杂度均为 O(1) ，因此，顺序表也称为 随机存取 的数据结构

向一个有 127 个元素的顺序表中插入一个新元素，并保持原来的顺序不变，平均要移动（ ）个元素。
答案：63.5

在一个长度为 n 的顺序存储线性表中，向第 i 个元素（1≤i≤n）之前插入一个新元素时，需要依次后移（ ）个元素。
答案：n-i+1

向一个长度为n的向量的第i个元素(1≤i≤n+1)之前插入一个元素时，需向后移动== n-i+1== 个元素。

在一个长度为 n 的顺序存储线性表中，删除第 i 个元素（1≤i≤n），需要前移（ ）个元素。
答案：n-i

一个顺序存储线性表的第一个元素的存储地址是 90，每个元素的长度是 2，则第 6 个元素的存储地址是（ ）。
答案：100

用链表表示线性表的优点是（ ）。

答案：便于插入和删除

带头结点的链表为空的判断条件是（ ）（设头指针为 head）。

 head->next==NULL

非空的单向循环链表的尾结点满足（ ）（设头指针为 head，指针 p 指向尾结点）。选择一项：
答案：p->next==head

在一个单链表中，p、q 分别指向表中两个相邻的结点，且 q 所指结点是 p 所指结点的直接
后继，现要删除 q 所指结点，可用语句（ ）。
答案：p->next=q->next

线性表在链式存储中各结点之间的地址（ ）。
答案：连续与否无所谓

有关线性表的正确说法是（ ）。
答案：除了一个和最后一个元素外，其余元素都有一个且仅有一个直接前驱和一个直接后继

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

在单链表中，若p 不是尾结点，在其后插入s 结点的操作是（ ）。
答案：s->next=p->next;p->next=s;

在一个长度为 n 的顺序表中为了删除第 5 个元素，由第 6 个元素开始从后到前依次移动了
15 个元素。则原顺序表的长度为（ ）。
答案：20

对于一个具有 n 个结点的单向链表，在给定值为 x 的结点之后插入一个新结点的时间复杂
度为（ ）。
答案：O(n)

设顺序存储的线性表长度为 n，对于插入操作，设插入位置是等概率的，则插入一个元素
平均移动元素的次数为（ ）。
答案：n/2

线性表的顺序结构中，（ ）。
答案：逻辑上相邻的元素在物理位置上也相邻

顺序表中逻辑上相邻的元素的物理位置== 必定==相邻。单链表中逻辑上相邻的元素的物理位置 不一定 相邻。

在单链表中，除了首元结点外，任一结点的存储位置由 其直接前驱结点的链域的值 指示。

在n个结点的单链表中要删除已知结点*p，需找到它的前驱结点的地址，其时间复杂度为O（n）。

以下表中可以随机访问的是（ ）。
答案：顺序表

设链表中的结点是 NODE 类型的结构体变量，且有 NODE *p；为了申请一个新结点，并由 p 指向该结点，可用以下语句（ ）。
答案：p=(NODE*)malloc(sizeof(NODE));

设 head 为非空的单向循环链表头指针，p 指向链表的尾结点，则满足逻辑表达式（ ）的值为真。
答案：p->next==head

在顺序表中插入或删除一个元素，需要平均移动 表中一半元素，具体移动的元素个数与 ==表长和该元素在表中的位置 ==有关

线性表中结点的集合是 ==有限 == 的，结点间的关系是 == 一对一 == 的。

判断题

顺序存取的线性表乐意随机存取（ ）。
正确的答案是“对”。

由于顺序存储要求连续的存储区域，所以在存储管理上不够灵活（ ）。
正确的答案是“对”。

线性表中的元素可以是各种各样的，但同一线性表中的数据元具有相同的特性，因此是属于同一数据对象（ ）。
正确的答案是“对”。

在线性表的顺序存储结构中，逻辑上相邻的两个元素但是在物理上位置并不一定是相邻的（ ）。
正确的答案是“错”。

在单链表中，任何两个元素的存储位置之间都有固定的联系，因为可以从头结点进行查找任何一个元素
正确的答案是“错”。

线性表的链式存储结构优于顺序存储结构（ ）。
正确的答案是“错”。

在线性表的顺序存储结构中，插入和删除元素时，移动元素的个数与该元素的位置有关（ ）。
正确的答案是“对”。

在单链表中，要取=得某个元素，只要知道该元素的指针机可，因此单链表是随机存取的存储结构。 （ ）
正确的答案是“错”。

顺序存储方式只能用于存储线性结构。（ ）
正确的答案是“错”。

顺序存储方式的有点是存储密度大，且插入、删除运算效率高。（ ）
正确的答案是“错”。

任何一个链表都可以根据需要设置一个头结点。( )
正确的答案是“对”。

链表的每个结点中都恰好包含一个指针。( )
正确的答案是“错”。

线性表的顺序存储结构必须占用一片地址连续的存储单元。( )
正确的答案是“对”。

线性表的链式存储结构不必占用地址连续的存储空间。( )
正确的答案是“对”。

线性表的每个结点只能是一个简单类型，而链表的每个结点可以是一个复杂类型
正确的答案是“错”。

线性表的链式存储结构,是一种物理存储单元上非连续、非顺序的存储结构
正确的答案是“对”。

循环链表的最后那个链结点的指针域中存放着链表最前面那个节点的地址。( )
正确的答案是“对”。

设置一个指针变量，它可以遍历整个循环链表。( )
正确的答案是“对”。

链表的物理存储结构具有同链表一样的顺序。( )
正确的答案是“错”。

线性表占用的存储单元的数量与表中数据元素的类型有关。( )
正确的答案是“错”。

线性表在物理存储空间中也一定是连续的。( )
正确的答案是“错”。

在链结点数目相同的前提下，双向链表占用的空间是线性链表的2倍。( )
正确的答案是“错”

线性链表(单链表)中的每个链结点只有后继节点，没有前驱节点。( )
正确的答案是“错”

线性表的顺序存储结构要比链式存储结构节省存储空间。( )
正确的答案是“错”

链表的删除算法很简单，因为当删除链中某个结点后，计算机会自动的将后序的各个单元向前移动。( )
正确的答案是“错”

空线性表的特征是表中数据元素都未赋值。( )
正确的答案是“错”

链表的每个结点中都恰好包含一个指针。

答：错误。链表中的结点可含多个指针域，分别存放多个指针。例如，双向链表中的结点可以含有两个指针域，分别存放指向其直接前趋和直接后继结点的指针。

链表的物理存储结构具有同链表一样的顺序。

答：错，链表的存储结构特点是无序，而链表的示意图有序

线性表的每个结点只能是一个简单类型，而链表的每个结点可以是一个复杂类型

答：错，混淆了逻辑结构与物理结构，链表也是线性表！且即使是顺序表，也能存放记录型数据

顺序表结构适宜于进行顺序存取，而链表适宜于进行随机存取。

答：错，正好说反了。顺序表才适合随机存取，链表恰恰适于“顺藤摸瓜”

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

答：错，前一半正确，但后一半说法错误，那是链式存储的优点。顺序存储方式插入、删除运算效率较低，在表长为n的顺序表中，插入和删除一个数据元素，平均需移动表长一半个数的数据元素。

顺序存储方式只能用于存储线性结构。

答：错误。顺序存储方式不仅能用于存储线性结构，还可以用来存放非线性结构，例如完全二叉树是属于非线性结构，但其最佳存储方式是顺序存储方式。

解答题

1. 试比较顺序存储结构和链式存储结构的优缺点。在什么情况下用顺序表比链表好？

答：① 顺序存储时，相邻数据元素的存放地址也相邻（逻辑与物理统一）；要求内存中可用存储单元的地址必须是连续的。
优点：存储密度大（＝1？），存储空间利用率高。缺点：插入或删除元素时不方便。
②链式存储时，相邻数据元素可随意存放，但所占存储空间分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针
优点：插入或删除元素时很方便，使用灵活。缺点：存储密度小（<1），存储空间利用率低。
顺序表适宜于做查找这样的静态操作；链表宜于做插入、删除这样的动态操作。 若线性表的长度变化不大，且其主要操作是查找，则采用顺序表；
若线性表的长度变化较大，且其主要操作是插入、删除操作，则采用链表。

2. 描述以下三个概念的区别：头指针、头结点、首元结点（第一个元素结点）。在单链表中设置头结点的作用是什么？

答：

首元结点是指链表中存储线性表中第一个数据元素a1的结点。为了操作方便，通常在链表的首元结点之前附设一个结点，称为头结点，该结点的数据域中不存储线性表的数据元素，其作用是为了对链表进行操作时，可以对空表、非空表的情况以及对首元结点进行统一处理。头指针是指向链表中第一个结点（或为头结点或为首元结点）的指针。若链表中附设头结点，则不管线性表是否为空表，头指针均不为空。否则表示空表的链表的头指针为空。这三个概念对单链表、双向链表和循环链表均适用。是否设置头结点，是不同的存储结构表示同一逻辑结构的问题。

简而言之，

头指针是指向链表中第一个结点（或为头结点或为首元结点）的指针；
头结点是在链表的首元结点之前附设的一个结点；数据域内只放空表标志和表长等信息（内放头指针？那还得另配一个头指针！！！）
首元素结点是指链表中存储线性表中第一个数据元素a1的结点。

顺序表的插入和删除

//顺序表的插入
//获取元素
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
Status GetElm(seqlist L, int i, ElemType *e)
{
    if (L.length == 0 || i < 1 || i > L.length)
        return ERROR;

    *e = L.r[i - 1];
    return OK;
}

Status ListInsert(seqlist L, int i, ElemType *e)
{
    int k;
    if (L.length == MAXSIZE)
        return ERROR;

    if (i < 1 || i > L.length + 1)
        return ERROR;
    if (i <= L.length)
    {
        for (k = L.length - 1; k = i - 1; k--)
        {
            L.r[k + 1] = L.r[k];
        }
        L.r[i - 1] = e;
        L.length++;
        return OK;
    }
}

Status ListInsert(seqlist L, int i, ElemType *e)
{
    int k;
    if (L.length == 0)
        return ERROR;

    if (i < 1 || i > L.length)
        return ERROR;
    if (i <= L.length)
    {
        for (k = L.length; k++)
        {
            L.r[k - 1] = L.r[k];
        }

        L.length--;
        return OK;
    }
}

单链表的插入与删除，创建

//单链表表的插入
typedef struct Node
{
    ElemType data;
    struct Node *next;
} Node;

typedef struct Node *LinkList;

Status GetElem(LinkList L, int i, ElemType *e)
{
    int j;
    LinkList p;
    p = L->next;
    j = 1;
    while (p && j < i)
    {
        p = p->next;
    }
}
Status ListInsert3(LinkList L, int i, ElemType *e)
{
    int j;
    LinkList p, s;
    p = *L;
    j = 1;
    while (p && j < i)
    {
        p = p->next;
        ++j;
    }
    if (!p || j > 1)
        return ERROR;
    s = (LinkList)malloc(sizeof(Node));

    s->data = e;
    s->next = p->next;
    p->next = s;
    return Ok;
}
Status Listdel2(LinkList L, int i, ElemType *e)
{
    int j;
    LinkList p, q;
    p = *L;
    j = 1;
    while (p && j < i)
    {
        p = p->next;
        ++j;
    }
    if (!(p->next || j > i))
        return ERROR;
    q = p->next;
    p->next = q->next;
    *e = q->data;
    free(q);
    return OK;
}
//单链表的整体创建
void CreateListHead(LinkList *L, int n)
{
    LinkList p;
    int i;
    scand(time(0));
    *L = (LinkList)malloc(sizeof(Node));
    (*L)->next = NULL;
    for (i = 0; i < n; i++)
    {

        p = (LinkList)malloc(sizeof(Node));
        p->data = rand() % 100 + 1;
        p->next = (*L)->next;
        (*L)->next = p;
    }
}
void CreateListTail(LinkList *L, int n)
{
    LinkList p, r;
    int i;
    scand(time(0));
    *L = (LinkList)malloc(sizeof(Node));
    r = *L;
    for (i = 0; i < n; i++)
    {

        p = (Node *)malloc(sizeof(Node));
        p->data = rand() % 100 + 1;
        r->next = p;

        r = p;
    }
    r->next = NULL;
}
//整表删除
Status clearList(LinkList *L)
{
    LinkList p, q;
    p = (*L)->next;
    while (p)
    {
        q = p->next;
        free(p);
        p = q;
        /* code */
    }
    (*L)->next = NULL;
    return OK;
}

循环链表