掌握线性表顺序与链式存储结构操作-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_29069575/article/details/143463631

简介：线性表是基础数据结构，有顺序和链式两种存储结构。顺序存储结构通过连续内存实现快速访问，但插入删除效率较低；链式存储结构通过节点间的链接不需移动元素，但访问速度较慢。本课程还将探讨栈的顺序和链式存储结构及其操作，以便在算法和程序设计中有效应用。线性表的顺序存储结构、链式存储结构上的基本操作

1. 线性表的顺序存储结构概述

线性表的定义

线性表是最基本、最简单的一种数据结构。在逻辑结构上，它是由n个相同类型的数据元素构成，具有唯一前驱和后继（除第一个元素外，其前驱为NULL；除最后一个元素外，其后继为NULL）的线性关系。

顺序存储结构的定义

线性表的顺序存储结构是使用一段地址连续的存储单元依次存储线性表的数据元素。在顺序存储结构中，逻辑上相邻的数据元素，其物理位置也是相邻的。

顺序存储结构的特点

顺序存储结构的优点在于其访问元素的速度快，只需通过计算偏移量直接定位，且实现简单。然而，它也存在一些缺点，比如插入和删除操作可能需要移动大量元素，造成效率低下。此外，顺序存储结构的空间利用率不高，可能会造成内存浪费。

在下文，我们将深入探讨线性表顺序存储结构和链式存储结构的更多细节，并提供相应的操作实现示例。

2. 线性表链式存储结构概述

链式存储结构是一种基于指针的存储方式，它将数据分散存储在物理位置不连续的存储单元中，每个数据元素对应的存储块称为结点，结点之间通过指针相互链接。与顺序存储结构相比，链式存储结构在数据的插入和删除操作上表现出了灵活性，但也增加了存储空间的开销。本章节将深入探讨链式存储结构的特点和实现方式。

2.1 链表的结构特征

链表是一种线性表的链式存储结构，它由一系列节点组成，每个节点包含数据部分和指向下一个节点的指针。链表的头节点通常不含数据，仅起到指向链表第一个实际存储数据的节点的作用。链表的尾节点通过其指针域指向一个空值，表示链表的结束。

链表的灵活性主要体现在对节点的动态分配和回收，这使得链表能够高效地进行插入和删除操作。然而，这种存储方式也带来了额外的指针域开销，并且由于数据不连续存放，缓存利用率较低，访问效率也低于顺序存储结构。

2.2 链表的基本类型

链表根据节点指针域的不同，可以分为单链表、双链表和循环链表等多种类型。每种类型的链表具有不同的特点和应用场景：

单链表 ：每个节点只有指向下一个节点的指针。
双链表 ：每个节点除了有指向下一个节点的指针外，还有指向前一个节点的指针。
循环链表 ：最后一个节点的指针不是指向空，而是指向链表的头节点，形成一个环。

2.3 链表的实现与操作

链表的实现依赖于节点的数据结构定义，以下是单链表节点的数据结构定义示例：

typedef struct Node {
    int data; // 数据域
    struct Node* next; // 指针域，指向下一个节点
} Node;

链表的基本操作包括创建、插入、删除和查找等。这些操作在不同类型的链表中有相似的逻辑，但也存在一些区别，特别是在操作指针时需要注意。

2.3.1 创建链表

创建链表的过程实际上就是初始化头节点和尾节点，并使头节点指向尾节点，同时尾节点的指针域设置为空。

Node* CreateList() {
    Node* head = (Node*)malloc(sizeof(Node)); // 分配头节点空间
    if (head == NULL) {
        return NULL; // 分配失败返回空指针
    }
    head->next = NULL; // 初始化指针域为空
    return head; // 返回头节点指针
}

2.3.2 插入操作的实现

插入操作是在链表中添加一个新的节点。根据插入位置的不同，可以分为头部插入、尾部插入和指定位置插入。

void InsertAtHead(Node** head, int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (newNode == NULL) {
        return; // 分配失败直接返回
    }
    newNode->data = data; // 新节点数据域赋值
    newNode->next = *head; // 新节点指针域指向头节点
    *head = newNode; // 头指针指向新节点
}

2.3.3 删除操作的实现

删除操作是从链表中移除一个节点。与插入操作类似，删除操作也需要根据位置来区分，主要包括删除头节点、尾节点和指定位置的节点。

void DeleteAtHead(Node** head) {
    if (*head == NULL) {
        return; // 如果链表为空，则不执行任何操作
    }
    Node* temp = *head; // 临时保存头节点
    *head = (*head)->next; // 将头指针指向下一个节点
    free(temp); // 释放原头节点的内存空间
}

2.3.4 查找操作的实现

查找操作用于在链表中查找满足特定条件的节点，并返回该节点指针。常见的查找条件包括按位置查找和按值查找。

Node* Find(Node* head, int data) {
    Node* current = head;
    while (current != NULL) {
        if (current->data == data) {
            return current; // 查找成功返回节点指针
        }
        current = current->next; // 移动到下一个节点
    }
    return NULL; // 查找失败返回空指针
}

2.4 链表与顺序表操作复杂度对比

链表和顺序表的操作复杂度对比有助于我们理解二者在不同场景下的效率表现：

| 操作类型 | 顺序表平均时间复杂度 | 链表平均时间复杂度 | |----------|----------------------|---------------------| | 插入 | O(n) | O(1) | | 删除 | O(n) | O(1) | | 查找 | O(1) | O(n) |

从表中可以看出，在插入和删除操作时链表更加高效，而顺序表在查找操作上表现更优。这些差异源于二者存储结构的不同特点，也是我们在选择数据结构时需要考虑的重要因素。

第三章：线性表基本操作的实现

线性表的基本操作包括插入、删除和查找等。本章节将详细介绍这些操作在线性表的顺序存储结构和链式存储结构中的具体实现方式，并比较两者的优缺点。

3.1 线性表顺序存储结构的操作

顺序存储结构通过数组实现线性表，数据元素在物理空间上是连续存放的，这使得通过下标能够快速访问任一元素。但这种存储方式的缺点是需要事先定义好最大容量，并且在插入和删除操作时可能会导致大量数据移动。

3.1.1 插入操作的实现

顺序存储结构中的插入操作需要考虑插入位置的合法性以及插入后数组的容量是否足够。以下代码展示了在顺序表中插入一个元素的逻辑：

void InsertArray(int* array, int* size, int index, int data) {
    if (index < 0 || index > *size) {
        return; // 插入位置不合法，直接返回
    }
    if (*size >= MAX_SIZE) {
        return; // 数组已满，无法插入
    }
    for (int i = *size; i > index; i--) {
        array[i] = array[i - 1]; // 将插入位置后的元素后移
    }
    array[index] = data; // 插入新元素
    (*size)++; // 调整数组大小
}

3.1.2 删除操作的实现

删除操作涉及找到要删除的元素并将其后面的元素前移覆盖它，代码如下：

void DeleteArray(int* array, int* size, int index) {
    if (index < 0 || index >= *size) {
        return; // 删除位置不合法，直接返回
    }
    for (int i = index; i < *size - 1; i++) {
        array[i] = array[i + 1]; // 将删除位置后的元素前移
    }
    (*size)--; // 调整数组大小
}

3.2 线性表链式存储结构的操作

链式存储结构的插入和删除操作不需要移动元素，只需调整相关节点的指针即可完成。但其缺点是无法直接通过下标访问元素，需要遍历链表。

3.2.1 插入操作的实现

在链式存储结构中，插入操作主要关注插入位置的前驱节点，以下代码展示了在链表中插入一个元素的逻辑：

void InsertNode(Node** head, int index, int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (newNode == NULL) {
        return; // 分配内存失败
    }
    newNode->data = data; // 新节点数据域赋值
    if (index == 0) { // 插入到头节点
        newNode->next = *head;
        *head = newNode;
    } else {
        Node* current = *head;
        for (int i = 0; i < index - 1 && current->next != NULL; i++) {
            current = current->next; // 移动到插入位置的前驱节点
        }
        newNode->next = current->next; // 新节点指向后继节点
        current->next = newNode; // 前驱节点指向新节点
    }
}

3.2.2 删除操作的实现

删除操作需要先找到被删除节点的前驱节点，然后断开其与后继节点的链接：

void DeleteNode(Node** head, int index) {
    if (*head == NULL || index < 0) {
        return; // 链表为空或位置不合法
    }
    Node* temp;
    if (index == 0) { // 删除头节点
        temp = *head;
        *head = (*head)->next;
    } else {
        Node* current = *head;
        for (int i = 0; current != NULL && i < index - 1; i++) {
            current = current->next;
        }
        if (current == NULL || current->next == NULL) {
            return; // 没有找到对应位置的节点
        }
        temp = current->next;
        current->next = temp->next;
    }
    free(temp); // 释放节点内存
}

通过本章节的介绍，我们了解了线性表在不同存储结构下的基本操作实现及其特点。下一章节将深入探讨栈的定义、特性及其存储结构与操作。

3. 线性表基本操作的实现

3.1 线性表顺序存储结构的操作

3.1.1 插入操作的实现

在顺序存储结构中，线性表的插入操作是通过移动元素来实现的。具体来说，当我们要在第 i 个位置插入一个新的元素 e 时，需要将索引 i 及之后的所有元素依次向后移动一位，然后将新元素 e 放到第 i 个位置上。这一过程涉及到数组元素的移动，需要考虑时间复杂度和空间效率。

以下是C语言中顺序存储结构插入操作的示例代码：

#define MAXSIZE 100 // 定义线性表的最大长度
typedef int ElementType; // 元素类型
typedef struct {
    ElementType data[MAXSIZE]; // 存储空间基址
    int length; // 当前长度
} SqList;

// 在线性表L中第i个位置插入新元素e
int ListInsert(SqList *L, int i, ElementType e) {
    int k;
    if (L->length == MAXSIZE) { // 表满
        return 0;
    }
    if (i < 1 || i > L->length + 1) { // 检查插入位置的合法性
        return 0;
    }
    if (i <= L->length) { // 如果插入数据位置不在表尾
        for (k = L->length - 1; k >= i - 1; k--) { // 将要插入位置后数据元素向后移动一位
            L->data[k + 1] = L->data[k];
        }
    }
    L->data[i - 1] = e; // 将新元素插入
    L->length++;
    return 1;
}

该代码中， ListInsert 函数实现了在顺序线性表 L 的第 i 个位置插入新元素 e 。函数首先检查线性表是否已满，以及插入位置是否合法。接着，从线性表的末尾开始，将第 i 个位置及之后的所有元素向后移动一位，并将新元素插入到指定位置。

3.1.2 删除操作的实现

删除操作与插入操作相反，是在线性表的第 i 个位置移除元素，并将该位置之后的所有元素依次向前移动一位来填补空位。删除操作同样需要考虑元素的移动和空间效率问题。

以下是顺序存储结构中删除操作的示例代码：

// 删除线性表L中第i个元素，并用e返回其值
int ListDelete(SqList *L, int i, ElementType *e) {
    int k;
    if (L->length == 0) { // 表空
        return 0;
    }
    if (i < 1 || i > L->length) { // 检查删除位置的合法性
        return 0;
    }
    *e = L->data[i - 1];
    if (i < L->length) { // 如果删除位置不在表尾
        for (k = i; k < L->length; k++) { // 将删除位置后继元素前移
            L->data[k - 1] = L->data[k];
        }
    }
    L->length--;
    return 1;
}

ListDelete 函数实现了在顺序线性表 L 中删除第 i 个元素，并用变量 e 返回被删除元素的值。函数首先检查线性表是否为空，然后检查删除位置的合法性。如果删除的位置不是线性表的末尾，那么将该位置之后的所有元素向前移动一位，最后将线性表的长度减一。

3.2 线性表链式存储结构的操作

3.2.1 插入操作的实现

链式存储结构中，线性表的插入操作不需要移动元素，只需要修改相应的指针即可。在双向链表中，插入操作需要改变三个节点的指针：前驱节点的 next 指针、当前节点的 prev 和 next 指针、后继节点的 prev 指针。

以下是链式存储结构中插入操作的示例代码：

typedef struct Node {
    ElementType data;
    struct Node *next;
    struct Node *prev;
} Node, *LinkList;

// 在双向链表L中的第i个位置插入新元素e
int ListInsert(LinkList L, int i, ElementType e) {
    int j = 0;
    Node *p = L;
    while (p && j < i - 1) { // 寻找第i-1个节点
        p = p->next;
        ++j;
    }
    if (!p || j > i - 1) { // 插入位置不合理
        return 0;
    }
    Node *newNode = (Node *)malloc(sizeof(Node));
    newNode->data = e;
    newNode->next = p->next;
    newNode->prev = p;
    if (p->next) {
        p->next->prev = newNode; // 前驱指针
    }
    p->next = newNode; // 改变当前节点的next指针
    return 1;
}

ListInsert 函数实现了在双向链表 L 的第 i 个位置插入新元素 e 。函数首先检查 i 是否在合理的范围内，然后遍历链表寻找第 i-1 个节点。找到插入位置后，创建一个新的节点 newNode ，将新节点插入到链表中，并更新相关节点的指针。

3.2.2 删除操作的实现

与插入操作类似，链式存储结构的删除操作也主要是修改指针，不需要移动元素。在双向链表中，删除操作涉及到四个节点的指针：被删除节点的前驱节点、被删除节点本身、被删除节点的后继节点。

以下是链式存储结构中删除操作的示例代码：

// 删除双向链表L中的第i个节点，并用e返回其值
int ListDelete(LinkList L, int i, ElementType *e) {
    int j = 0;
    Node *p = L;
    while (p->next && j < i - 1) { // 寻找第i-1个节点
        p = p->next;
        ++j;
    }
    if (!(p->next) || j > i - 1) { // 删除位置不合理
        return 0;
    }
    Node *q = p->next;
    *e = q->data;
    p->next = q->next;
    if (q->next) {
        q->next->prev = p; // 后继节点的前驱指针
    }
    free(q); // 释放被删除节点的内存空间
    return 1;
}

ListDelete 函数实现了在双向链表 L 中删除第 i 个节点，并用变量 e 返回被删除节点的值。函数首先检查 i 是否在合理的范围内，然后遍历链表寻找第 i-1 个节点。找到删除位置后，将被删除节点从链表中断开，并释放其内存空间。

在本章节中，我们详细介绍了线性表顺序存储结构和链式存储结构中基本操作的实现方法，包括插入和删除操作的详细步骤、代码逻辑分析和参数说明。通过这些具体的操作，我们能够更好地理解线性表在不同存储结构下的行为和特性。在接下来的章节中，我们将继续深入探讨栈的数据结构，包括栈的定义、特性以及顺序存储结构和链式存储结构下的栈操作实现。

4. 栈的定义、特性及其存储结构与操作

4.1 栈的定义与特性

在计算机科学中，栈（Stack）是一种抽象数据类型，它遵循后进先出（Last In First Out, LIFO）的原则。栈的操作限制在表的一端进行，这一端被称为栈顶。栈的这种特性使得它特别适用于实现如撤销操作、括号匹配、表达式求值等场景。

在实现上，栈可以使用数组或链表来存储其元素。当使用数组实现时，它被称为栈的顺序存储结构；而使用链表实现时，则被称为栈的链式存储结构。栈的操作包括压栈（Push）、弹栈（Pop）、查看栈顶元素（Peek）等。

4.2 栈的顺序存储结构与操作

顺序存储结构使用数组来实现栈，使得栈中的元素在内存中是连续存放的。这种方法的优点是存储密度高，且对元素的访问速度较快，因为数组的索引访问是常数时间复杂度。

4.2.1 压栈操作的实现

压栈操作是将一个新元素添加到栈顶的过程。在顺序存储结构中，这通常涉及到在数组的下一个位置写入新元素，然后更新栈顶指针。

class Stack:
    def __init__(self):
        self.items = []
    def push(self, item):
        self.items.append(item)  # 将元素添加到数组末尾
    def pop(self):
        if not self.is_empty():
            return self.items.pop()  # 移除并返回数组末尾元素
    def peek(self):
        if not self.is_empty():
            return self.items[-1]  # 返回数组末尾元素，但不移除
    def is_empty(self):
        return len(self.items) == 0  # 判断栈是否为空

4.2.2 弹栈操作的实现

弹栈操作是移除栈顶元素，并返回该元素的过程。在数组实现的栈中，这需要更新栈顶指针，指向下一个元素。

4.2.3 查看栈顶元素的实现

查看栈顶元素操作不需要移动栈顶指针，只需返回栈顶元素的值即可。

4.3 栈的链式存储结构与操作

链式存储结构使用链表实现栈，其中每个节点包含数据部分和指向下一个节点的指针。这种方式的优点是灵活，可以动态地添加和移除元素，但可能会因为指针的增加而占用更多的内存。

4.3.1 压栈操作的实现

压栈操作在链式栈中涉及创建一个新的节点，将其数据部分设置为传入的元素，然后将新节点的指针部分指向当前的栈顶节点。

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedStack:
    def __init__(self):
        *** = None
    def push(self, item):
        new_node = Node(item)
        new_node.next = ***  # 新节点的next指针指向当前栈顶
        *** = new_node       # 更新栈顶指针
    def pop(self):
        if not self.is_empty():
            popped_node = ***
            *** = ***.next  # 更新栈顶指针
            return popped_node.data   # 返回被移除节点的数据
    def peek(self):
        if not self.is_empty():
            ***.data  # 返回栈顶元素
    def is_empty(self):
        *** is None

4.3.2 弹栈操作的实现

弹栈操作在链式栈中，涉及更新栈顶指针，使其指向下一个节点。

4.3.3 查看栈顶元素的实现

查看栈顶元素操作在链式栈中，只返回栈顶节点的数据部分，不改变栈顶指针。

4.4 栈的应用场景分析

栈在算法和编程中有着广泛的应用，以下是一些典型的使用场景：

括号匹配验证 ：通过压栈和弹栈操作来检查括号字符串是否有效。
表达式求值 ：使用栈来解析和计算逆波兰表达式（后缀表达式）。
函数调用栈 ：编程语言使用栈来管理函数调用的执行环境。
深度优先搜索（DFS） ：在图和树的搜索中，使用栈来追踪访问路径。

4.5 栈操作的效率分析

4.5.1 时间复杂度分析

栈的顺序存储结构和链式存储结构在压栈和弹栈操作上通常都能达到 O(1) 的时间复杂度。这是因为这些操作都只涉及对栈顶元素的操作。

4.5.2 空间复杂度分析

在空间复杂度上，栈的顺序存储结构和链式存储结构各有优劣。顺序存储结构受限于预先分配的数组大小，而链式存储结构则受链表节点分配的内存影响。

4.6 栈操作的练习与挑战

4.6.1 实践练习

为了加深对栈操作的理解，可以尝试实现一个简单的计算器，使用栈来处理运算符的优先级和括号内的表达式。

4.6.2 解决挑战

在解决栈相关的编程挑战时，需要考虑如何有效地使用栈结构来处理数据，例如在浏览器的后退功能实现中，可以使用栈来存储访问历史。

| 栈的类型 | 时间复杂度 | 空间复杂度 | 灵活性 | 内存使用 | |-----------|------------|------------|---------|----------| | 顺序存储 | O(1) | O(n) | 较低 | 连续空间 | | 链式存储 | O(1) | O(n) | 较高 | 灵活分配 |

通过以上章节的详细探讨，我们可以看到栈在数据结构中的重要性及其在实际应用中的表现。理解栈的存储结构和操作有助于我们更有效地解决各种算法问题。