第二章线性表

最新推荐文章于 2023-07-28 01:08:51 发布

AIAlchemy

最新推荐文章于 2023-07-28 01:08:51 发布

阅读量186

点赞数

文章标签：算法数据结构

本文链接：https://blog.csdn.net/weixin_52677033/article/details/130712281

版权

学习线性表的知识要点包括以下内容：

定义：线性表是由一组有序的元素组成的数据结构，元素之间存在一对一的关系。

特点：线性表的特点是元素之间存在唯一的前驱和后继，除了第一个元素没有前驱，最后一个元素没有后继。

基本操作：

插入操作：在线性表的指定位置插入一个新元素。
删除操作：删除线性表中指定位置的元素。
查找操作：根据给定的关键字或位置查找线性表中的元素。
修改操作：修改线性表中指定位置的元素值。
遍历操作：按照一定顺序访问线性表中的所有元素。

实现方式：线性表可以通过顺序存储和链式存储两种方式来实现。

顺序存储：使用数组或列表等连续的存储空间来存储线性表的元素，可以通过下标直接访问元素。
链式存储：使用节点和指针的方式来存储线性表的元素，每个节点包含元素值和指向下一个节点的指针。

常见线性表的实现：

数组：使用连续的内存空间存储元素，可以通过下标快速访问元素。
链表：通过节点和指针组成的链式结构存储元素，可以动态地插入和删除元素。
栈：具有后进先出（LIFO）特性的线性表，只能在栈顶进行插入和删除操作。
队列：具有先进先出（FIFO）特性的线性表，可以在队尾插入元素，在队头删除元素。

线性表的应用：线性表广泛应用于各种算法和数据结构中，如树、图等的表示和遍历，排序和查找算法等。

以上是线性表的基本要点，掌握这些知识可以帮助理解和使用线性表相关的数据结构和算法。

2.1 线性表的类型定义

线性表是n个数据元素的有限序列。

线性表中的数据元素可以说各种各样的，但是同一线性表中的元素必须具有相同特性。在线性表中，每一个数据元素由逻辑序列唯一确定，可将线性表记为：

$(a_{1}, \cdots ,a_{i-1},a_{i},a_{i+1},\cdots ,a_{n})$

其中称 $a_{i-1}$ 是 $a_{i}$ 的直接前驱元素， $a_{i+1}$ 是 $a_{i}$ 的直接后继元素。除了最后一个数据元素，所有数据元素都有且只有一个直接后继；除了第一个数据元素，所有数据元素都有且只有一个直接前驱；

以下是线性表的基本操作：

ADT LinearList

    // 数据对象：线性表由一组有序的元素组成
    // 操作：
    InitList(&L)
    // 输入：线性表对象 L 的引用
    // 输出：无
    // 功能：初始化线性表 L，构造一个空的线性表

    ListEmpty(L)
    // 输入：线性表对象 L
    // 输出：布尔值，表示线性表是否为空
    // 功能：判断线性表 L 是否为空，若为空则返回 true，否则返回 false

    ClearList(&L)
    // 输入：线性表对象 L 的引用
    // 输出：无
    // 功能：清空线性表 L，使其成为一个空表

    GetElem(L, position)
    // 输入：线性表对象 L，元素的位置 position
    // 输出：元素的值
    // 功能：获取线性表 L 中指定位置的元素的值

    LocateElem(L, element)
    // 输入：线性表对象 L，要查找的元素 element
    // 输出：元素的位置
    // 功能：在线性表 L 中查找指定元素 element，并返回其位置

    ListInsert(&L, position, element)
    // 输入：线性表对象 L 的引用，要插入的位置 position，要插入的元素 element
    // 输出：布尔值，表示插入是否成功
    // 功能：在线性表 L 的指定位置插入新元素 element

    ListDelete(&L, position)
    // 输入：线性表对象 L 的引用，要删除的位置 position
    // 输出：布尔值，表示删除是否成功
    // 功能：删除线性表 L 中指定位置的元素

    ListLength(L)
    // 输入：线性表对象 L
    // 输出：整数值，表示线性表的长度
    // 功能：返回线性表 L 的元素个数
END ADT LinearList

2.2 线性表的顺序表示和实现

2.2.1 线性表的的顺序表示

线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素。所有元素按照其逻辑顺序依次存储到计算机存储器中指定存储位置开始的一块连续的存储空间里。在C++和C语言中，借助数组类型来实现顺序表，描述如下：

#define LIST_INIT_SIZE 100  //线性表存储空间的初始分配量
#define LISTINCREMENT  10   //线性表存储空间的分配增量
typedef struct{
    ElemType data[LIS_INIT_SIZE]        //存储空间的基址
    int length;             //当前长度
    int listsize;           //当前分配的存储容量
}SqList

2.2.2 线性表基本运算实现

1. 建立顺序表

由一个a[0..n-1]的数组进行创建线性表，将数组中的每一个元素依次放入顺序表中即可

void creatList(SqList *&L,ElemType a[],int n){
    //数组a中的n个元素
    int i = 0;k=0;
    L=(sqList *)malloc(sizeof(SqList));//分配存放线性表的空间
    while(i>n){
        l->data[i]=a[i];
        k++;
        i++;
    }
    L->length=k;
}

2. 初始化线性表

构造一个空的线性表L：

void InitList(SqList *&L){
    L=(SqList *)malloc(sizeeof(SqList));
    L->length=0;
    }

void 表示该函数没有返回值。
InitList 是函数的名称。
(SqList *&L) 是函数的参数列表，其中 &L 表示传入的参数是指向 SqList 结构体指针的引用。
L = (SqList *)malloc(sizeof(SqList)) 分配内存空间，将指针 L 指向这块内存，实现了初始化操作。sizeof(SqList) 用于获取 SqList 结构体的大小，malloc 用于分配内存。
L->length = 0 将 L 指向的 SqList 结构体的 length 成员设置为 0，表示线性表的初始长度为 0

3. 销毁线性表

void DestroyList(SqList *&L) {
    free(L);
    L = NULL;
}

void 表示该函数没有返回值。
DestroyList 是函数的名称。
(SqList *&L) 是函数的参数列表，其中 &L 表示传入的参数是指向 SqList 结构体指针的引用。
free(L) 使用 free 函数释放 L 指向的内存空间，销毁线性表。
L = NULL 将 L 设置为 NULL，防止产生野指针。

4. 判断线性表是否为空表

bool ListEmpty(SqList *L) {
    return L->length == 0;
}

bool 表示该函数返回一个布尔值（true或false）。
ListEmpty 是函数的名称。
(SqList *L) 是函数的参数列表，其中 L 是指向 SqList 结构体的指针，表示线性表对象。
L->length 是访问 L 所指向的 SqList 结构体的 length 成员，该成员表示线性表的长度。
函数返回表达式 L->length == 0 的结果，即判断线性表是否为空表。如果 length 的值为 0，表示线性表为空表，函数返回 true；否则，返回 false。

5. 求线性表的长度

int ListLength(SqList *L) {
    return L->length;
}

(SqList *L) 是函数的参数列表，其中 L 是指向 SqList 结构体的指针，表示线性表对象。
L->length 是访问 L 所指向的 SqList 结构体的 length 成员，该成员表示线性表的长度。
函数返回 L->length 的值，即线性表的长度

6.输出线性表

void DispList(SqList *L) {
    if (ListEmpty(L)) {
        printf("The list is empty.\n");
    } else {
        printf("The elements in the list are: ");
        for (int i = 0; i < L->length; i++) {
            printf("%d ", L->data[i]);
        }
        printf("\n");
    }
}

(SqList *L) 是函数的参数列表，其中 L 是指向 SqList 结构体的指针，表示线性表对象。
首先，通过调用 ListEmpty 函数判断线性表是否为空。如果为空，则输出提示信息 "The list is empty."。
如果线性表不为空，则依次遍历线性表的元素

7.返回线性表中的某个数据元素的值

bool GetElem(SqList *L, int i, ElementType *e) {
    if (i < 1 || i > L->length) {
        return false;  // 越界错误，返回 false
    }
    *e = L->data[i - 1];  // 获取元素值
    return true;
}

(SqList *L, int i, ElementType *e) 是函数的参数列表，其中 L 是指向 SqList 结构体的指针，表示线性表对象；i 是要获取元素的位置；e 是指向 ElementType 类型的指针，用于存储获取到的元素值。
首先，判断传入的位置 i 是否越界，即判断 i 是否小于 1 或大于线性表的长度 L->length。如果越界，则返回 false 表示获取失败。
如果位置 i 不越界，则将对应位置的元素值赋给指针 e 所指向的内存空间，即 *e = L->data[i - 1]。
返回 true 表示获取成功。

8. 按元素查找，返回序号

int LocateElem(SqList *L, ElementType e) {
    for (int i = 0; i < L->length; i++) {
        if (L->data[i] == e) {
            return i + 1;  // 返回序号（位置）
        }
    }
    return -1;  // 元素未找到，返回 -1
}

(SqList *L, ElementType e) 是函数的参数列表，其中 L 是指向 SqList 结构体的指针，表示线性表对象；e 是要查找的元素值。
使用循环遍历线性表的元素，从第一个元素开始逐个比较。
如果找到与目标元素值相等的元素，则返回该元素在线性表中的位置序号（位置从 1 开始）。
如果遍历完整个线性表都没有找到目标元素，则返回 -1，表示元素未找到。

9. 插入数据元素

bool Insert(SqList *&L, int i, ElementType e) {
    if (i < 1 || i > L->length + 1) {
        return false;  // 插入位置越界错误，返回 false
    }
    if (L->length >= MAXSIZE) {
        return false;  // 线性表已满，无法插入，返回 false
    }
    for (int j = L->length; j >= i; j--) {
        L->data[j] = L->data[j - 1];  // 元素后移
    }
    L->data[i - 1] = e;  // 插入元素
    L->length++;  // 线性表长度加 1
    return true;
}

(SqList *&L, int i, ElementType e) 是函数的参数列表，其中 &L 表示传入的参数是指向 SqList 结构体指针的引用，即可以修改实参的值；i 是插入位置；e 是要插入的元素值。
首先，判断插入的位置 i 是否越界，即判断 i 是否小于 1 或大于线性表的长度 L->length + 1（允许在线性表末尾插入）。如果越界，则返回 false 表示插入失败。
接着，判断线性表是否已满，即判断线性表的长度是否达到了最大容量 MAXSIZE。如果已满，则返回 false 表示插入失败。
如果插入位置和线性表状态都符合要求，则从线性表末尾开始，将元素逐个后移一位，以为插入元素腾出位置。
最后，将要插入的元素值 e 放入插入位置 i 处，更新线性表的长度 L->length。
返回 true 表示插入成功

10. 删除数据元素

bool ListDelete(SqList *&L, int i, ElementType &e) {
    if (i < 1 || i > L->length) {
        return false;  // 删除位置越界错误，返回 false
    }
    e = L->data[i - 1];  // 保存被删除元素的值
    for (int j = i; j < L->length; j++) {
        L->data[j - 1] = L->data[j];  // 元素前移
    }
    L->length--;  // 线性表长度减 1
    return true;
}

首先检查给定的位置 i 是否超出了顺序表 L 的有效范围。如果是，则返回 false，表示删除操作未成功。
否则，它将索引为 i-1 的元素的值保存在变量 e 中。然后，函数从位置 i+1 开始迭代所有元素，直到列表的末尾，并将每个元素向左移动一个位置（即，位于索引 j 的元素移动到索引 j-1），从而实现删除位于位置 i 的元素。
最后，列表 L 的长度减少 1，函数返回 true 表示删除操作成功。

总结

线性表是一种常见的数据结构，它可以用于存储一组具有相同类型的数据元素，并且这些元素之间存在线性关系。线性表有多种表示方式，其中一种常见的表示方式是顺序表。

顺序表是使用数组来实现线性表的一种方式，它将线性表的元素顺序存储在一块连续的内存空间中。顺序表具有以下特点：

随机访问：由于顺序表中的元素在内存中是连续存储的，因此可以通过下标直接访问任意位置的元素，具有较快的访问速度。
插入和删除操作的效率较低：当需要在顺序表中插入或删除元素时，需要将插入点之后的元素都后移或将删除点之后的元素都前移，这涉及到大量的数据搬移，效率较低。
固定容量：顺序表在创建时需要预先指定容量，而且在运行过程中无法动态扩容，因此容量是固定的。当顺序表已满时，再插入新元素就会导致溢出。
适用于频繁访问和读取操作：由于顺序表的随机访问效率高，适用于需要频繁访问和读取元素的场景。

学习线性表和顺序表的内容，需要掌握以下核心要点：

线性表的定义和基本操作：包括初始化线性表、销毁线性表、判断线性表是否为空、获取线性表的长度、获取指定位置的元素、按元素查找位置、插入元素和删除元素等基本操作。
顺序表的实现：了解顺序表的数据结构定义，包括使用数组存储元素和使用变量记录线性表长度。熟悉顺序表的插入和删除操作的实现方式，以及涉及到的数据搬移操作。
线性表和顺序表的优缺点：了解线性表和顺序表的特点和适用场景，理解顺序表的随机访问和插入/删除操作的效率差异，以及固定容量带来的限制。
理解时间复杂度和空间复杂度：学习线性表和顺序表的过程中，理解各个操作的时间复杂度和空间复杂度，以评估算法的效率和资源消耗。

总结起来，学习线性表和顺序表需要掌握其定义、基本操作、实现方式以及优缺点。理解线性表和顺序表的特点和适用场景，能够根据具体需求选择合适的数据结构来存储和操作数据。同时，掌握时间复杂度和空间复杂度的概念，有助于评估算法和数据结构的效率。

AIAlchemy

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
第二章线性表

线性表是n个数据元素的有限序列。线性表中的数据元素可以说各种各样的，但是同一线性表中的元素必须具有相同特性。在线性表中，每一个数据元素由逻辑序列唯一确定，可将线性表记为：其中称是的直接前驱元素，是的直接后继元素。除了最后一个数据元素，所有数据元素都有且只有一个直接后继；除了第一个数据元素，所有数据元素都有且只有一个直接前驱；// 数据对象：线性表由一组有序的元素组成// 操作：// 输入：线性表对象 L 的引用// 输出：无// 功能：初始化线性表 L，构造一个空的线性表。
复制链接

扫一扫