数据结构基础

最新推荐文章于 2025-09-06 17:50:40 发布

MadeInSQL

最新推荐文章于 2025-09-06 17:50:40 发布

阅读量782

点赞数 16

CC 4.0 BY-SA版权

文章标签：数据结构

本文链接：https://blog.csdn.net/NIIT0532/article/details/150845414

数据结构知识点详解

单向链表的逆置

单向链表逆置是一种常见的链表操作，其核心思想是将链表节点的指针方向逆转。这种操作在实际开发中经常用于需要反向处理链表数据的场景。

算法原理

逆置过程本质上是通过改变每个节点的next指针指向来实现的。要实现这一操作，我们需要跟踪三个关键节点：

当前正在处理的节点(current)
当前节点的前驱节点(prev)
当前节点的后继节点(next)

详细实现步骤

初始化三个指针：
- prev = NULL (最初没有前驱节点)
- current = head (从链表头开始)
- next = NULL (暂存下一个节点)
遍历链表：
- 保存current的下一个节点到next
- 将current的next指针指向prev (实现逆转)
- 将prev移动到current位置
- 将current移动到next位置
循环终止条件：
- 当current为NULL时停止，此时prev指向原链表的最后一个节点
返回新的头节点：
- 最终prev就是逆置后链表的新头节点

时间复杂度分析

时间复杂度：O(n)，需要遍历整个链表一次
空间复杂度：O(1)，只使用了固定数量的指针变量

示例代码（C语言实现）

struct ListNode* reverseList(struct ListNode* head) {
    struct ListNode *prev = NULL;
    struct ListNode *current = head;
    struct ListNode *next = NULL;
    
    while (current != NULL) {
        next = current->next;  // 保存下一个节点
        current->next = prev;   // 逆转指针方向
        prev = current;        // 移动prev指针
        current = next;        // 移动current指针
    }
    
    return prev;  // 新的头节点
}

应用场景

回文链表判断：将链表后半部分逆置后与前半部分比较
链表相加运算：从低位到高位相加时可能需要逆置链表
某些特定排序算法中需要逆序处理链表
实现栈或队列等数据结构时可能需要逆置操作

边界条件处理

空链表：直接返回NULL
单节点链表：直接返回原头节点
大链表：注意栈溢出问题（递归实现时）

双向循环链表

双向循环链表是一种特殊的链表结构，它在双向链表的基础上增加了循环特性，使其具有更灵活的操作方式。

结构特点

节点结构：
- 数据域：存储元素值
- prev指针：指向前驱节点
- next指针：指向后继节点
循环特性：
- 头节点的prev指向尾节点
- 尾节点的next指向头节点
- 形成首尾相连的环形结构

主要操作详解

插入操作

头部插入：
- 创建新节点
- 新节点的next指向原头节点
- 新节点的prev指向尾节点
- 更新头节点和尾节点的相关指针
尾部插入：
- 创建新节点
- 新节点的prev指向原尾节点
- 新节点的next指向头节点
- 更新尾节点和头节点的相关指针
中间插入：
- 定位插入位置
- 调整前后节点的指针关系
- 设置新节点的prev和next指针

删除操作

头部删除：
- 保存头节点指针
- 将头节点指向原头节点的next
- 更新新头节点的prev指针
- 释放原头节点内存
尾部删除：
- 保存尾节点指针
- 将尾节点指向原尾节点的prev
- 更新新尾节点的next指针
- 释放原尾节点内存
中间删除：
- 定位要删除的节点
- 调整前后节点的指针关系
- 释放被删除节点内存

遍历操作

正向遍历：
- 从头节点开始
- 依次访问next指针直到回到头节点
反向遍历：
- 从尾节点开始
- 依次访问prev指针直到回到尾节点
任意位置开始遍历：
- 可以从任意节点开始
- 向任意方向遍历

优势分析

双向遍历能力：可以从任意节点向两个方向遍历
高效删除操作：已知节点情况下删除时间复杂度为O(1)
环形结构优势：
- 实现环形缓冲区
- 约瑟夫环问题
- 轮询调度算法
无边界条件：没有真正的头和尾的概念，操作更统一

缺点分析

内存开销：
- 每个节点需要额外存储prev指针
- 相比单向链表多占用33%的空间(假设指针和数据大小相同)
操作复杂性：
- 插入删除时需要维护更多指针关系
- 容易产生循环引用或指针丢失
- 调试难度较大
实现复杂度：
- 初始化时需要正确处理循环关系
- 空链表状态需要特殊处理

典型应用场景

实现LRU缓存淘汰算法
音乐播放器的播放列表
浏览器历史记录管理
操作系统的进程调度
游戏中的循环动画序列

栈的基本操作

输出栈（遍历栈）

输出栈内容是一个常见的操作，但由于栈的后进先出特性，直接遍历会破坏栈结构。因此需要特殊处理。

详细步骤

创建临时栈：
- 初始化一个与原栈相同大小的空栈
转移元素：
- 循环将原栈元素弹出并压入临时栈
- 此时临时栈中的元素顺序与原栈相反
输出元素：
- 再次将临时栈元素弹出并输出
- 同时可以将元素压回原栈（可选）
清理资源：
- 释放临时栈占用的内存

注意事项

时间复杂度：O(n)，需要两轮弹出操作
空间复杂度：O(n)，需要额外临时栈空间
保持原栈状态：如果需要保持原栈不变，需要将元素压回

销毁栈

销毁栈是释放栈占用的所有内存资源的过程，需要特别注意内存泄漏问题。

完整销毁过程

释放栈元素：
- 循环弹出所有元素
- 对动态分配的元素调用free释放内存
- 静态分配的元素无需特殊处理
释放栈结构：
- 释放栈数组空间（顺序栈）
- 释放栈节点空间（链式栈）
- 释放栈控制结构本身
防止野指针：
- 将栈指针置为NULL
- 避免后续误用已释放的指针
错误处理：
- 检查栈指针是否为NULL
- 处理可能的释放失败情况

示例代码（C语言实现）

void destroyStack(Stack *stack) {
    if (stack == NULL) return;
    
    // 释放栈中元素
    while (!isEmpty(stack)) {
        int *element = pop(stack);
        if (element != NULL) {
            free(element);  // 如果栈中存储的是动态分配的数据
        }
    }
    
    // 释放栈数组空间
    if (stack->array != NULL) {
        free(stack->array);
    }
    
    // 释放栈结构
    free(stack);
    
    // 防止野指针
    stack = NULL;
}

不同类型栈的销毁差异

顺序栈：
- 需要释放连续存储空间
- 通常只需一次free操作
链式栈：
- 需要逐个释放节点
- 需要维护指针关系
静态栈：
- 无需释放固定内存
- 只需重置栈指针

顺序表和链表的区别与优缺点

存储结构对比

顺序表

物理结构：使用一段地址连续的存储单元（如数组），在内存中占据连续的存储空间。例如，在C语言中可以声明为int arr[100]，或在Java中为ArrayList。

逻辑关系：物理相邻即逻辑相邻。由于元素在内存中是连续存储的，第i个元素的地址可以通过首地址和偏移量直接计算得出（如Loc(a_i) = Loc(a_0) + i*size）。

实现方式：

静态分配：编译时确定大小（如#define MAXSIZE 100），一旦声明后容量不可改变
动态分配：运行时可调整大小（如C++的vector，Java的ArrayList），当空间不足时能自动扩容（通常按1.5或2倍增长）

链表

物理结构：使用任意可用的存储单元，各节点在内存中可以是非连续分布的。每个节点除了存储数据元素外，还需要额外的空间存储指针。

逻辑关系：通过指针链接建立逻辑关系。节点的逻辑顺序与物理存储顺序无关，通过指针来维持元素间的逻辑关系。

实现方式：

单链表：只有后继指针（next），如struct Node { int data; Node* next; };
双链表：包含前驱和后继指针（prev和next），如Java的LinkedList
循环链表：首尾相连，可以是单循环链表或双循环链表

操作效率对比

访问操作

顺序表：O(1)随机访问（通过下标直接访问）
链表：O(n)顺序访问（必须从头节点开始遍历）

插入/删除操作

顺序表：
- 尾部操作：O(1)
- 头部/中间操作：O(n)（需要移动后续元素）
链表：
- 已知位置插入/删除：O(1)
- 需要先查找位置：O(n)

内存使用对比

顺序表：
- 空间利用率高（只存储数据）
- 可能产生内存浪费（预分配空间）
- 需要连续的存储空间
链表：
- 每个节点需要额外空间存储指针
- 动态分配内存，无空间浪费
- 可以利用内存碎片

典型应用场景

顺序表适用场景：

需要频繁随机访问元素（如数组排序、二分查找）
元素数量相对固定
对内存要求严格，希望尽量减少额外开销

链表适用场景：

需要频繁在任意位置插入/删除
元素数量变化较大
无法预估数据规模大小
实现栈、队列、哈希表等数据结构

详细区别分析

特性	顺序表	链表
存储方式	连续存储	离散存储
访问方式	随机访问（O(1)）	顺序访问（O(n)）
插入/删除效率	O(n)（需要移动元素）	O(1)（只需修改指针）
空间利用率	高（无额外空间开销）	低（需要存储指针）
动态扩展	困难（可能需要重新分配内存）	容易（只需分配新节点）
缓存友好性	好（空间局部性）	差（内存不连续）
实现复杂度	简单	较复杂
内存分配	一次性分配	动态分配
内存碎片	无	可能产生
遍历效率	高（CPU缓存预取）	较低（随机内存访问）