当前位置：首页 > news >正文

【408--复习笔记】数据结构

news 来源：原创 2025/4/30 6:40:56

【408--复习笔记】数据结构

1.绪论
- 数据结构基本概念
- - • 请简述数据结构的定义。
  - • 数据结构中数据、数据元素、数据项、数据对象的区别是什么？
- 算法相关
- - • 什么是算法？算法的五个重要特性是什么？
  - • 如何理解算法的时间复杂度和空间复杂度？请举例说明如何计算。
  - • 请比较常见的时间复杂度的量级，如O(1)、O(n)、O(n^2)、O(logn)等，并说明它们在实际应用中的特点。
- 数据结构的分类
- - • 数据结构分为逻辑结构和物理结构，它们分别有哪些类型？请举例说明。
  - • 线性结构和非线性结构的区别是什么？常见的线性结构和非线性结构有哪些？
- 抽象数据类型
- - • 什么是抽象数据类型？它有什么作用？
  - • 请用伪代码或其他方式描述一个简单的抽象数据类型，如栈或队列。
2.线性表
- 基本概念
- 顺序存储结构
- 链式存储结构
- 算法相关
- 其他
3.栈、队列、数组
4.串
5.树与二叉树
6.图
7.查找
8.排序

1.绪论

在这里插入图片描述

数据结构基本概念

• 请简述数据结构的定义。

数据结构是相互之间存在一种或者多种特定关系的数据元素的集合，主要包逻辑结构、存储结构、和数据运算三方面。
逻辑结构包含线性结构与非线性结构。线性结构包含数一般线性表，受限线性表（栈队列），广义线性表（数组，串等），非线性结构包含（集合，树，图）
存储结构/物理结构是数据结构在计算机中的表示，包含顺序存储、链式存储、索引存储、散列存储。
数据运算是针对数数据逻辑结构的运算和实现。

• 数据结构中数据、数据元素、数据项、数据对象的区别是什么？

数据：信息载体
数据元素：数据的基本单位，一个数据元素由若干数据项组成。
数据项：构成数据元素的最小不可分割单位
数据对象：具有相同性质的数据元素的集合，是数据的子集。

算法相关

• 什么是算法？算法的五个重要特性是什么？

算法：对特定问题求解问题的描述，是指令的有限集合。
五个特性
有穷、确定、可行、输入、输出
好的算法目标：
正确、可读、健壮、高效（时间/空间）

• 如何理解算法的时间复杂度和空间复杂度？请举例说明如何计算。

时间复杂度，算法中基本运算的执行次数的数量级。
空间复杂度，算法所需的存储空间

• 请比较常见的时间复杂度的量级，如O(1)、O(n)、O(n^2)、O(logn)等，并说明它们在实际应用中的特点。

O(1)<O(log n)<O(n)<O(n log n)<O(n²)<O(n³)<O(2ⁿ)<O(n!)<O(nⁿ)

数据结构的分类

• 数据结构分为逻辑结构和物理结构，它们分别有哪些类型？请举例说明。

逻辑结构
线性结构、非线性结构
在这里插入图片描述
物理结构
• 顺序存储结构：把逻辑上相邻的数据元素存储在物理上相邻的存储单元中，如数组。例如，存储一组整数的数组，元素在内存中是连续存放的，通过数组下标可以快速访问元素。
• 链式存储结构：数据元素的存储单元可以不连续，通过指针来表示元素之间的逻辑关系，如链表。链表中的每个节点包含数据域和指针域，指针指向下一个节点，这样可以灵活地插入和删除元素。
• 索引存储结构：在存储数据元素的同时，还建立一个附加的索引表，通过索引表可以快速查找数据元素。例如，在数据库中，经常会为某些字段建立索引，以提高查询效率。
• 散列存储结构：根据数据元素的关键字，通过一个散列函数计算出存储地址，将数据元素存储在该地址中。如哈希表，通过哈希函数将键值映射到数组的特定位置，实现快速的查找、插入和删除操作。

• 线性结构和非线性结构的区别是什么？常见的线性结构和非线性结构有哪些？

线性结构和非线性结构的区别主要体现在数据元素之间的逻辑关系上：

• 线性结构：数据元素之间存在一对一的线性关系，除了第一个和最后一个元素外，每个元素都有唯一的前驱和后继。

• 非线性结构：数据元素之间存在一对多或多对多的关系，元素的前驱和后继关系不唯一，或者不存在明显的线性顺序。

常见的线性结构有线性表、栈、队列、串等。常见的非线性结构有树（如二叉树、B树等）、图（如无向图、有向图等）、集合等。

抽象数据类型

• 什么是抽象数据类型？它有什么作用？

抽象数据类型（Abstract Data Type，ADT）是指一个数学模型及定义在该模型上的一组操作。它是对数据类型的一种抽象描述，强调数据的逻辑特性和操作的功能，而不涉及数据的具体存储结构和操作的实现细节。

抽象数据类型具有以下作用：
• 数据封装与隐藏：将数据和操作数据的方法封装在一起，隐藏了数据的内部表示和操作的具体实现，使得用户只能通过定义好的接口来访问和操作数据，提高了数据的安全性和可靠性。
• 代码复用：可以在不同的程序中重复使用抽象数据类型，只要满足相同的逻辑需求，就可以直接使用已定义好的抽象数据类型，而无需重新编写相关代码，提高了代码的复用性。
• 模块化设计：有助于将复杂的系统分解为多个相对独立的模块，每个模块可以基于抽象数据类型进行设计和实现，使得系统的结构更加清晰，易于理解、维护和扩展。
• 提高编程效率：用户只需关注抽象数据类型提供的操作功能，而不必关心其内部实现细节，从而减少了编程的复杂度，提高了编程效率。

• 请用伪代码或其他方式描述一个简单的抽象数据类型，如栈或队列。

以下分别用伪代码描述栈和队列这两个抽象数据类型：

栈（Stack）抽象数据类型：
栈是一种后进先出（LIFO）的数据结构。

// 定义栈的抽象数据类型
ADT Stack {
    // 初始化栈
    Operation InitStack():
        // 创建一个空栈
        // 例如，初始化一个空数组来存储栈元素
        stack = []
        return stack
    
    // 判断栈是否为空
    Operation IsEmpty(stack):
        if length(stack) == 0 then
            return true
        else
            return false
    
    // 入栈操作
    Operation Push(stack, item):
        stack.append(item)
        return stack
    
    // 出栈操作
    Operation Pop(stack):
        if IsEmpty(stack) then
            // 栈为空时可以根据情况返回特殊值或报错
            return null 
        else
            item = stack.pop()
            return item
    
    // 获取栈顶元素
    Operation GetTop(stack):
        if IsEmpty(stack) then
            return null 
        else
            return stack[length(stack) - 1]
}

队列（Queue）抽象数据类型：
队列是一种先进先出（FIFO）的数据结构。


```vbnet
// 定义队列的抽象数据类型
ADT Queue {
    // 初始化队列
    Operation InitQueue():
        // 创建一个空队列
        // 例如，初始化一个空数组来存储队列元素
        queue = []
        return queue
    
    // 判断队列是否为空
    Operation IsEmpty(queue):
        if length(queue) == 0 then
            return true
        else
            return false
    
    // 入队操作
    Operation Enqueue(queue, item):
        queue.append(item)
        return queue
    
    // 出队操作
    Operation Dequeue(queue):
        if IsEmpty(queue) then
            // 队列为空时可以根据情况返回特殊值或报错
            return null 
        else
            item = queue.pop(0)
            return item
    
    // 获取队头元素
    Operation GetFront(queue):
        if IsEmpty(queue) then
            return null 
        else
            return queue[0]
}

2.线性表

在这里插入图片描述

基本概念

什么是线性表？它有哪些基本特征？
线性表是具有相同数据类型的 n（n≥0）个数据元素的有限序列，通常记为 (a1,a2,…,ai,ai+1,…,an)，其中 n 为线性表的长度，当 n = 0 时，称为空表。它具有以下基本特征：
有限性：线性表中数据元素的个数是有限的。
顺序性：数据元素之间存在着顺序关系，即除了第一个和最后一个元素外，其他每个元素都有且仅有一个直接前驱和一个直接后继。
同质性：线性表中的所有数据元素必须是同一数据类型。
可操作性：可以对线性表进行插入、删除、查找、修改等操作，以实现对数据的处理和管理。
抽象性：表中元素具有抽象性，仅讨论其逻辑关系，不考虑内容。
第一个元素只有一个直接后继，最后一个元素只有一个直接前驱。其他元素都有只有一个直接前驱和一个直接后继。

线性表的逻辑结构与存储结构有什么区别？
线性表的逻辑结构与存储结构是两个不同层面的概念，它们的区别如下：

定义角度
逻辑结构：是从数据元素之间的逻辑关系角度来描述线性表，它只关注元素之间的前后顺序关系，而不考虑数据在计算机中的具体存储方式。比如，在一个学生成绩表中，每个学生的成绩记录之间存在着顺序关系，这种顺序关系就是线性表的逻辑结构。
存储结构：是指线性表在计算机内存中的存储方式，它需要考虑如何将数据元素及其逻辑关系有效地存储在计算机的存储空间中，以便于计算机进行数据的访问和操作。

表现形式
逻辑结构：通常用线性序列的形式来表示，如 (a1, a2, a3, …, an)，强调的是元素之间的线性顺序关系，每个元素都有唯一的前驱（除第一个元素外）和唯一的后继（除最后一个元素外）。
存储结构：有顺序存储和链式存储等多种形式。顺序存储结构是将数据元素依次存储在连续的内存单元中，就像数组一样；链式存储结构则是通过指针将各个数据元素链接起来，每个元素除了存储自身数据外，还包含指向下一个元素的指针（单链表情况）。

操作特性
逻辑结构：主要定义了一系列基于逻辑关系的操作，如查找第 i 个元素、在第 i 个位置插入元素、删除第 i 个元素等，这些操作是基于元素的逻辑位置进行的，不涉及具体的存储细节。
存储结构：不同的存储结构对操作的实现方式和效率有很大影响。例如，顺序存储结构可以直接通过数组下标快速访问元素，时间复杂度为 O (1)，但插入和删除元素可能需要移动大量后续元素，时间复杂度为 O (n)；链式存储结构访问元素需要从头指针开始遍历链表，时间复杂度为 O(n)，但插入和删除元素只需修改指针，时间复杂度为 O (1)。

独立性
逻辑结构：独立于计算机的硬件和软件环境，它是对数据之间关系的一种抽象描述，不依赖于具体的存储和实现方式，可以在不同的存储结构中实现相同的逻辑结构。
存储结构：与计算机的内存结构和编程语言等密切相关，需要根据具体的硬件环境和编程语言的特点来选择合适的存储方式，以提高数据处理的效率和空间利用率。

线性表的主要操作有哪些？请简要描述。
线性表的主要操作包括初始化、插入、删除、查找、修改、求长度、判空、遍历等

顺序存储结构

顺序表是如何实现的？它有什么优缺点？
实现方式
顺序表是将线性表中的数据元素依次存储在一组连续的存储单元中，使得逻辑上相邻的数据元素在物理位置上也相邻。在高级程序设计语言中，通常可以用数组来实现顺序表。数组的下标可以直接对应数据元素在线性表中的位置，通过数组的存储单元依次存放线性表的各个元素，从而实现顺序表的顺序存储。
在这里插入图片描述

优点
随机访问效率高：由于数据元素在内存中是连续存储的，因此可以通过数组下标直接访问任意位置的元素，时间复杂度为 O(1)。这使得对于顺序表中元素的随机访问操作非常高效，能够快速地获取或修改指定位置的元素值。
存储密度高：顺序表中每个数据元素只存储自身的数据值，没有额外的指针等辅助信息来表示元素之间的逻辑关系（除了数组本身的结构信息外），所以存储密度大，空间利用率高。

缺点
插入和删除操作效率低：在顺序表中进行插入和删除操作时，需要移动大量的元素。例如，在表头或表中间插入一个元素，需要将插入位置之后的所有元素都向后移动一个位置；删除一个元素时，需要将删除位置之后的元素都向前移动一个位置。在最坏情况下，插入和删除操作的时间复杂度为O(n)，其中 n为顺序表的长度，这在数据量较大时效率较低。
空间大小固定：顺序表的存储空间是在程序运行前静态分配的，一旦确定了大小，在程序运行过程中就很难动态改变。如果事先分配的空间过大，可能会造成内存空间的浪费；如果分配的空间过小，当数据元素个数超过预先分配的大小时，就会出现溢出错误，导致程序无法正常运行。

阐述顺序表中插入和删除操作的基本步骤和时间复杂度。
在这里插入图片描述

如何在顺序表中实现元素的查找？请描述查找算法的思路和时间复杂度。
在这里插入图片描述

链式存储结构

链表与顺序表有什么不同？在什么情况下适合使用链表？
链表与顺序表在存储结构、数据访问方式、插入删除操作等方面存在不同，以下是具体分析以及链表适用场景的介绍：

存储结构
顺序表：采用连续的存储空间来存储数据元素，就像数组一样，在内存中是一块连续的区域，逻辑上相邻的元素在物理位置上也相邻。
链表：采用=离散的存储方式，每个数据元素（节点）除了存储自身的数据外，还需要存储指向下一个节点的指针（单链表）或指向前驱和后继节点的指针（双链表），节点在内存中的位置是不连续的，通过指针来链接各个节点，形成逻辑上的线性结构。

数据访问方式
顺序表：支持随机访问，可以通过下标直接访问任意位置的元素，时间复杂度为O(1) ，能快速定位到需要的元素，就像在一排连续的座位中，直接根据座位号就能找到对应的人。
链表：不支持随机访问，只能从链表的头节点开始，通过指针逐个遍历节点来访问数据，访问第i个元素的时间复杂度为O(n)，类似于在一条串联的珠子项链上，要找到某颗特定的珠子，需要从一端开始逐个查找。

插入和删除操作
顺序表：插入和删除元素时，通常需要移动大量元素。比如在表头插入一个元素，需要将后面的所有元素都向后移动一位，时间复杂度为 O(n)。
链表：插入和删除操作相对简单，只需修改相关节点的指针即可。例如在链表中插入一个新节点，只需找到插入位置的前一个节点，将其指针指向新节点，新节点再指向原来的下一个节点，时间复杂度为O(1)（前提是已经找到插入位置的前一个节点）。

空间分配
顺序表：需要预先分配固定大小的存储空间，如果数据量变化较大，可能会出现空间浪费或空间不足的情况。
链表：不需要预先分配大量空间，它的空间是根据实际需求动态分配的，只要内存还有空间，就可以不断地插入新节点，更灵活地适应数据量的变化。

根据以上特点，链表适用于以下情况：
数据量不确定且经常需要进行插入和删除操作：例如，在一个实时处理数据的系统中，数据的到来是不确定的，可能随时需要插入新数据，或者根据某些条件删除已有的数据，使用链表可以高效地完成这些操作，而不会像顺序表那样因为大量元素的移动而消耗过多时间。
内存空间有限且需要动态管理内存：当程序运行时可用的内存空间有限，并且数据的大小和数量在运行过程中会动态变化时，链表的动态内存分配特性可以更好地利用有限的内存资源，避免顺序表可能出现的内存溢出问题。
实现一些需要频繁插入和删除节点的算法和数据结构：如实现栈、队列等数据结构，以及一些图算法中的邻接表表示等，链表能够提供更高效的操作支持。

请描述单链表、双链表和循环链表的结构特点和适用场景。
单链表、双链表和循环链表是常见的链表结构，它们的结构特点各有不同，在不同的应用场景中发挥着各自的优势，具体如下：

单链表
结构特点：每个节点包含数据域和指针域，指针域指向下一个节点，最后一个节点的指针域为 NULL，表头指针指向第一个节点，通过指针依次访问各个节点，形成线性结构。
适用场景：适用于数据元素的插入和删除操作较为频繁，且不需要频繁地反向遍历数据的场景。例如，在简单的线性数据集合管理中，如学生信息的简单存储与动态更新，新学生的插入和退学学生信息的删除操作较多，而查询操作主要是从前往后顺序进行，使用单链表可以高效地实现这些操作。

双链表
结构特点：每个节点除了数据域外，还包含两个指针域，一个指向前驱节点，一个指向后继节点。表头指针指向第一个节点，第一个节点的前驱指针为 NULL，最后一个节点的后继指针为 NULL，这样可以双向遍历链表，既可以从前往后，也可以从后往前访问节点。
适用场景：当需要频繁地在链表中进行双向遍历操作时，双链表更为合适。比如在实现文本编辑器的撤销和重做功能时，用户既可以撤销最近的操作（向前遍历），也可以重做已撤销的操作（向后遍历），双链表能够方便地实现这种双向的操作记录和访问。

循环链表
结构特点：循环链表分为单循环链表和双循环链表。单循环链表中，最后一个节点的指针不是指向 NULL，而是指向表头节点，形成一个环形结构；双循环链表中，表头节点的前驱指针指向最后一个节点，最后一个节点的后继指针指向表头节点，也构成一个环形。
适用场景：适用于需要循环处理数据的场景，如约瑟夫环问题，在一个环形的人员队列中，按照一定的规则依次淘汰人员，直到只剩下最后一个人，循环链表可以很好地模拟这种环形的结构和循环处理的过程。又如，在操作系统的进程调度中，将所有就绪进程用循环链表连接起来，调度程序可以依次遍历链表来分配 CPU 时间片，当遍历到链表末尾时，又回到表头继续循环，实现进程的轮流执行。

如何实现单链表的遍历？请写出遍历单链表的代码。
遍历单链表是指按照链表中节点的顺序依次访问每个节点的数据。基本思路是从链表的头节点开始，通过节点的指针域依次访问下一个节点，直到遍历完整个链表（即遇到指针域为 NULL 的节点）。

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

# 定义单链表类
class LinkedList:
    def __init__(self):
        self.head = None

    # 遍历单链表的方法
    def traverse(self):
        current = self.head
        while current:
            print(current.val)
            current = current.next

# 创建单链表并添加节点
linked_list = LinkedList()
node1 = ListNode(1)
node2 = ListNode(2)
node3 = ListNode(3)
linked_list.head = node1
node1.next = node2
node2.next = node3

# 遍历单链表
linked_list.traverse()

解释一下链表中的头结点和头指针的作用，是否可以省略头结点？
在这里插入图片描述在链表中，头结点和头指针起着不同但又相互配合的重要作用，以下是对它们的详细解释以及关于头结点是否可以省略的分析：

头结点的作用
简化插入和删除操作：头结点是为了操作的统一与方便而设立的，它的数据域可以不存储任何信息，也可以存储如链表长度等附加信息。有了头结点，在链表的头部进行插入和删除操作时，就无需特殊处理，和在其他位置的操作一致，都可以通过修改指针来完成。例如，要在链表头部插入一个新节点，只需将新节点的指针指向原头结点的下一个节点，然后将头结点的指针指向新节点即可，无需像没有头结点时那样，需要单独处理头指针的更新。
标识链表的开始：它作为链表的第一个节点，明确标识了链表的起始位置，使得对链表的遍历等操作有一个确定的起点。即使链表为空，头结点也存在，此时头结点的指针域指向
NULL。

头指针的作用：头指针是指向链表头结点（或第一个数据节点，如果没有头结点的话）的指针变量。它是访问链表的唯一入口，通过头指针可以找到链表中的任意节点，进而实现对链表的各种操作，如遍历、插入、删除等。无论链表是否为空，头指针都始终存在，并且不会改变其指向链表头部的性质。

是否可以省略头结点：在实际应用中，头结点是可以省略的。当链表的操作主要集中在链表的中间和尾部，且对链表头部的插入、删除操作很少或者不需要统一处理边界情况时，可以不设置头结点。这样可以节省一个节点的存储空间，并且代码实现上相对简单一些，因为不需要额外处理头结点相关的逻辑。然而，省略头结点可能会使链表头部的操作变得复杂，需要单独处理插入和删除第一个节点的情况，容易导致代码的可读性和可维护性下降。所以在大多数情况下，尤其是在需要频繁进行各种链表操作的场景中，使用头结点可以使代码更加清晰、简洁，减少出错的可能性。

如何在单链表中插入和删除一个节点？请描述具体的操作过程，并分析时间复杂度。
在这里插入图片描述

算法相关

请编写一个算法，实现将两个有序链表合并成一个新的有序链表。

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next


def merge_two_lists(l1, l2):
    dummy = ListNode(0)
    current = dummy

    while l1 and l2:
        if l1.val < l2.val:
            current.next = l1
            l1 = l1.next
        else:
            current.next = l2
            l2 = l2.next
        current = current.next

    if l1:
        current.next = l1
    if l2:
        current.next = l2

    return dummy.next


# 辅助函数：将列表转换为链表
def list_to_linked_list(lst):
    dummy = ListNode(0)
    current = dummy
    for val in lst:
        current.next = ListNode(val)
        current = current.next
    return dummy.next


# 辅助函数：将链表转换为列表
def linked_list_to_list(head):
    result = []
    current = head
    while current:
        result.append(current.val)
        current = current.next
    return result


# 示例用法
l1 = list_to_linked_list([1, 2, 4])
l2 = list_to_linked_list([1, 3, 4])
merged_head = merge_two_lists(l1, l2)
print(linked_list_to_list(merged_head))

如何判断一个链表是否存在环？请描述算法思路，并分析时间复杂度和空间复杂度。
判断一个链表是否存在环可以使用快慢指针法（Floyd 判圈算法），以下是详细步骤：
初始化指针：
定义两个指针，一个快指针 fast 和一个慢指针 slow，它们都初始化为链表的头节点。
指针移动：
慢指针 slow 每次移动一步，即 slow = slow.next。
快指针 fast 每次移动两步，即 fast = fast.next.next。
判断是否有环：
在指针移动过程中，如果链表中存在环，那么快指针 fast 最终会追上慢指针 slow，即 fast == slow，此时就可以判定链表存在环。
如果链表中不存在环，那么快指针 fast 会先到达链表的末尾（即 fast 或者 fast.next 为 None），此时可以判定链表不存在环。

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next


def has_cycle(head):
    if not head or not head.next:
        return False
    slow = head
    fast = head.next
    while slow != fast:
        if not fast or not fast.next:
            return False
        slow = slow.next
        fast = fast.next.next
    return True

在这里插入图片描述

编写一个函数，删除单链表中指定值的所有节点。

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next


def remove_elements(head, val):
    # 创建一个虚拟头节点，方便处理头节点需要删除的情况
    dummy = ListNode(0)
    dummy.next = head
    current = dummy

    while current.next:
        if current.next.val == val:
            # 如果下一个节点的值等于指定值，跳过该节点
            current.next = current.next.next
        else:
            # 否则移动到下一个节点
            current = current.next

    return dummy.next


# 辅助函数：将列表转换为链表
def list_to_linked_list(lst):
    dummy = ListNode(0)
    current = dummy
    for val in lst:
        current.next = ListNode(val)
        current = current.next
    return dummy.next


# 辅助函数：将链表转换为列表
def linked_list_to_list(head):
    result = []
    current = head
    while current:
        result.append(current.val)
        current = current.next
    return result


# 示例用法
head = list_to_linked_list([1, 2, 6, 3, 4, 5, 6])
new_head = remove_elements(head, 6)
print(linked_list_to_list(new_head))

给定一个单链表，如何反转该链表？请给出算法思路和代码实现。
反转单链表可以使用迭代和递归两种常见的方法，下面分别介绍这两种方法的思路：
迭代法
初始化指针：定义三个指针，prev 初始化为 None，curr 初始化为链表的头节点，next_node 用于临时保存 curr 的下一个节点。
遍历链表：在遍历过程中，首先保存 curr 的下一个节点到 next_node，然后将 curr 的 next 指针指向 prev，接着更新 prev 为 curr，curr 为 next_node，不断重复这个过程，直到 curr 为 None。
返回结果：当 curr 为 None 时，prev 就指向了原链表的最后一个节点，也就是反转后链表的头节点，返回 prev。

递归法
终止条件：如果链表为空或者只有一个节点，直接返回该链表，因为空链表或者只有一个节点的链表反转后还是其本身。
递归调用：递归地反转当前节点之后的链表，得到反转后的子链表。
调整指针：将当前节点的下一个节点的 next 指针指向当前节点，然后将当前节点的 next 指针置为 None。
返回结果：返回反转后的子链表的头节点。

# 定义单链表节点类
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

# 迭代法反转链表
def reverseList_iterative(head):
    prev = None
    curr = head
    while curr:
        next_node = curr.next
        curr.next = prev
        prev = curr
        curr = next_node
    return prev

# 递归法反转链表
def reverseList_recursive(head):
    if not head or not head.next:
        return head
    new_head = reverseList_recursive(head.next)
    head.next.next = head
    head.next = None
    return new_head

# 辅助函数：将列表转换为链表
def list_to_linked_list(lst):
    dummy = ListNode(0)
    current = dummy
    for val in lst:
        current.next = ListNode(val)
        current = current.next
    return dummy.next

# 辅助函数：将链表转换为列表
def linked_list_to_list(head):
    result = []
    current = head
    while current:
        result.append(current.val)
        current = current.next
    return result

# 示例用法
head = list_to_linked_list([1, 2, 3, 4, 5])
# 使用迭代法反转链表
reversed_head_iterative = reverseList_iterative(head)
print("迭代法反转后的链表:", linked_list_to_list(reversed_head_iterative))

# 重新创建链表用于递归法测试
head = list_to_linked_list([1, 2, 3, 4, 5])
# 使用递归法反转链表
reversed_head_recursive = reverseList_recursive(head)
print("递归法反转后的链表:", linked_list_to_list(reversed_head_recursive))

其他

线性表在实际应用中有哪些常见的场景？请举例说明。
线性表是一种基本的数据结构，在实际应用中有许多常见的场景，以下是一些例子：

数据存储与管理：在数据库系统中，数据表中的数据通常以线性表的形式进行存储和管理。例如，一个存储学生信息的表，每一行代表一个学生的记录，包括学号、姓名、年龄等字段，这些记录就可以看作是线性表中的元素。通过线性表的操作，可以方便地进行数据的插入、删除、查找等操作，如添加新学生记录、删除退学学生记录、根据学号查找学生信息等。

文本处理：在文本编辑器中，文本内容可以看作是一个字符的线性表。用户对文本的各种操作，如插入字符、删除字符、查找特定字符串等，都可以通过对线性表的相应操作来实现。例如，当用户在文档中插入一个新的段落时，实际上就是在线性表中特定位置插入一系列字符元素；查找某个关键词时，就是在线性表中遍历查找匹配的字符序列。
在这里插入图片描述

图的邻接表表示：在图论中，图的邻接表是一种常用的存储方式，其中就用到了线性表。对于图中的每个顶点，用一个线性表来存储与该顶点相邻的顶点信息。例如，在一个有向图中，顶点A与顶点B、C相邻，那么可以用一个线性表[B,C]来表示顶点A的邻接顶点。通过这种方式，可以方便地存储和遍历图的边信息，进行图的各种算法操作，如深度优先搜索、广度优先搜索等。

内存管理：操作系统中的内存管理也会用到线性表。系统会维护一个空闲内存块的线性表，每个元素代表一个空闲的内存块，记录其起始地址、大小等信息。当有程序申请内存时，系统会在这个线性表中查找合适的空闲块，进行分配；当程序释放内存时，又会将释放的内存块合并到空闲内存块线性表中。这样可以有效地管理内存资源，提高内存的利用率。

对比线性表的顺序存储和链式存储，在不同的应用场景下，你会如何选择？
线性表的顺序存储和链式存储是两种常见的存储方式，前者逻辑上相邻的元素在物理位置上也相邻，后者通过指针将物理位置上不一定相邻的节点链接起来。在不同应用场景下，可根据以下几个方面的特性来选择合适的存储方式：

随机访问需求
顺序存储：它支持随机访问，可通过数组下标直接访问元素，时间复杂度为O(1)。比如在一个需要频繁根据索引查找元素的场景，如学生成绩管理系统中，若经常要根据学生的学号（假设学号是连续的，可作为数组下标）快速查询成绩，顺序存储就很合适。
链式存储：不支持随机访问，要访问第i个元素，需从表头开始遍历链表，时间复杂度为O(n)。所以对于有大量随机访问需求的场景，链式存储不是最佳选择。

插入和删除操作频率
顺序存储：在顺序表中插入和删除元素，平均要移动大约一半的元素，时间复杂度为 O(n)。如果在一个线性表中需要频繁地进行插入和删除操作，比如在一个实时处理数据的系统中，新数据不断插入，旧数据不断删除，使用顺序存储会导致大量的数据移动，效率较低。
链式存储：在链表中插入和删除元素，只需修改相关节点的指针，时间复杂度为O(1)（前提是已找到要操作的位置）。因此，对于插入和删除操作频繁的场景，如文本编辑中，用户频繁地插入和删除字符，链式存储更能体现出其优势。

内存空间管理
顺序存储：顺序存储需要一块连续的内存空间，当线性表长度变化较大时，可能会出现空间浪费或溢出的情况。例如，事先分配了较大的空间，但实际使用的元素很少，就会造成内存空间的浪费；而如果元素数量超出了预分配的空间，又需要进行扩容操作，这可能涉及到数据的重新复制，效率较低。
链式存储：链式存储的节点空间是动态分配的，不需要连续的内存空间，能更灵活地利用内存。在内存资源紧张且数据量不确定的情况下，链式存储更合适。比如在一些嵌入式系统中，内存资源有限，且数据的产生和销毁是动态的，使用链式存储可以更好地管理内存。

数据规模可预测性
顺序存储：如果数据规模在初始化时就可以确定，且不会有太大变化，顺序存储可以根据预计的数据量分配合适的空间，能有效地利用内存，并且可以利用数组的特性进行一些优化，提高访问效率。例如，在一个固定大小的缓存系统中，已知最多需要存储N个数据项，使用顺序存储可以预先分配好空间，简单高效。
链式存储：当数据规模不确定，可能会动态增长或缩小，链式存储可以根据实际需求动态地分配和释放节点空间，不会因为数据规模的变化而导致内存管理上的困难。比如在一个网络数据包处理系统中，数据包的数量是不确定的，使用链式存储可以方便地处理不同数量的数据包。