• 数据结构（二）顺序表和链表

    1.线性表

    线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使
    用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...
    线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，
    线性表在物理上存储时，通常以数组和链式结构的形式存储。

    2.顺序表 

    2.1概念及结构

    顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存
    储。在数组上完成数据的增删查改。
    顺序表一般可以分为：

    1. 静态顺序表：使用定长数组存储元素。

    2. 动态顺序表：使用动态开辟的数组存储。

    我们在这里讲一下静态开辟的缺点：

    1.我们不知道需要多少。

    2.开辟多了（空间）浪费。

    3.开辟少了（空间）不够用

    同时我们讲一下动态开辟的优点：

    1.不够用了可以开辟

    2，开辟多了可以释放

    .................................总之我们还是强烈建议使用动态开辟。

    现在我们来创建一个顺序表：

    1. #include
    2. int main()
    3. {
    4.    struct seqsdfs
    5.    { 
    6.       int *a;
    7.       int size;      //记录有效数据
    8.       int capacity   //记录空间有多大

    2.2 接口实现 

    静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空
    间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间
    大小，所以下面我们实现动态顺序表。

    1. typedef int SLDataType;
    2. // 顺序表的动态存储
    3. typedef struct SeqList
    4. {
    5.  SLDataType* array;  // 指向动态开辟的数组
    6.  size_t size ;    // 有效数据个数
    7.  size_t capicity ;  // 容量空间的大小
    8. }SeqList;
    9. // 基本增删查改接口
    10. // 顺序表初始化
    11. void SeqListInit(SeqList* psl);
    12. // 检查空间，如果满了，进行增容
    13. void CheckCapacity(SeqList* psl);
    14. // 顺序表尾插
    15. void SeqListPushBack(SeqList* psl, SLDataType x);
    16. // 顺序表尾删
    17. void SeqListPopBack(SeqList* psl);
    18. // 顺序表头插
    19. void SeqListPushFront(SeqList* psl, SLDataType x);
    20. // 顺序表头删
    21. void SeqListPopFront(SeqList* psl);
    22. // 顺序表查找
    23. int SeqListFind(SeqList* psl, SLDataType x);
    24. // 顺序表在pos位置插入x
    25. void SeqListInsert(SeqList* psl, size_t pos, SLDataType x);
    26. // 顺序表删除pos位置的值
    27. void SeqListErase(SeqList* psl, size_t pos);
    28. // 顺序表销毁
    29. void SeqListDestory(SeqList* psl);
    30. // 顺序表打印
    31. void SeqListPrint(SeqList* psl);

     

    3.链表 

    3.1 链表的概念及结构

    概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表
    中的指针链接次序实现的 。

     

    现实中 数据结构中

     

    3.2 链表的分类 

    实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

    1. 单向或者双向

     2. 带头或者不带头

     3. 循环或者非循环

    虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：

     

    1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结
    构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
    2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都
    是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带
    来很多优势，实现反而简单了，后面我们代码实现了就知道了。 

    3.3 链表的实现

    1. // 1、无头+单向+非循环链表增删查改实现
    2. typedef int SLTDateType;
    3. typedef struct SListNode
    4. {
    5. SLTDateType data;
    6. struct SListNode* next;
    7. }SListNode;
    8. // 动态申请一个结点
    9. SListNode* BuySListNode(SLTDateType x);
    10. // 单链表打印
    11. void SListPrint(SListNode* plist);
    12. // 单链表尾插
    13. void SListPushBack(SListNode** pplist, SLTDateType x);
    14. // 单链表的头插
    15. void SListPushFront(SListNode** pplist, SLTDateType x);
    16. // 单链表的尾删
    17. void SListPopBack(SListNode** pplist);
    18. // 单链表头删
    19. void SListPopFront(SListNode** pplist);
    20. // 单链表查找
    21. SListNode* SListFind(SListNode* plist, SLTDateType x);
    22. // 单链表在pos位置之后插入x
    23. // 分析思考为什么不在pos位置之前插入？
    24. void SListInsertAfter(SListNode* pos, SLTDateType x);
    25. // 单链表删除pos位置之后的值
    26. // 分析思考为什么不删除pos位置？
    27. void SListEraseAfter(SListNode* pos);

    3.4 链表面试题 

    1. 删除链表中等于给定值 val 的所有结点。 OJ链接. - 力扣（LeetCode）
    2. 反转一个单链表。 OJ链接. - 力扣（LeetCode）
    3. 给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则
    返回第二个中间结点。OJ链接. - 力扣（LeetCode）
    4. 输入一个链表，输出该链表中倒数第k个结点。 OJ链接牛客网-题目已下线_牛客网
    5. 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有
    结点组成的。OJ链接. - 力扣（LeetCode）
    6. 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结
    点之前 。OJ链接链表分割_牛客题霸_牛客网
    7. 链表的回文结构。OJ链接链表的回文结构_牛客题霸_牛客网
    8. 输入两个链表，找出它们的第一个公共结点。OJ链接. - 力扣（LeetCode）

    9. 给定一个链表，判断链表中是否有环。. - 力扣（LeetCode）

    【思路】
    快慢指针，即慢指针一次走一步，快指针一次走两步，两个指针从链表其实位置开始运行，
    如果链表
    带环则一定会在环中相遇，否则快指针率先走到链表的末尾。比如：陪女朋友到操作跑步减
    肥。

    【扩展问题】

    为什么快指针每次走两步，慢指针走一步可以？
    假设链表带环，两个指针最后都会进入环，快指针先进环，慢指针后进环。当慢指针刚
    进环时，可能就和快指针相遇了，最差情况下两个指针之间的距离刚好就是环的长度。
    此时，两个指针每移动一次，之间的距离就缩小一步，不会出现每次刚好是套圈的情
    况，因此：在满指针走到一圈之前，快指针肯定是可以追上慢指针的，即相遇。
    快指针一次走3步，走4步，...n步行吗？

    10. 给定一个链表，返回链表开始入环的第一个结点。 如果链表无环，则返回 NULL OJ链接 . - 力扣（LeetCode）

    结论
    让一个指针从链表起始位置开始遍历链表，同时让一个指针从判环时相遇点的位置开始绕环
    运行，两个指针都是每次均走一步，最终肯定会在入口点的位置相遇。
    证明

     

    3.5 双向链表的实现 

    1. // 2、带头+双向+循环链表增删查改实现
    2. typedef int LTDataType;
    3. typedef struct ListNode
    4. {
    5. LTDataType _data;
    6. struct ListNode* next;
    7. struct ListNode* prev;
    8. }ListNode;
    9. // 创建返回链表的头结点.
    10. ListNode* ListCreate();
    11. // 双向链表销毁
    12. void ListDestory(ListNode* plist);
    13. // 双向链表打印
    14. void ListPrint(ListNode* plist);
    15. // 双向链表尾插
    16. void ListPushBack(ListNode* plist, LTDataType x);
    17. // 双向链表尾删
    18. void ListPopBack(ListNode* plist);
    19. // 双向链表头插
    20. void ListPushFront(ListNode* plist, LTDataType x);
    21. // 双向链表头删
    22. void ListPopFront(ListNode* plist);
    23. // 双向链表查找
    24. ListNode* ListFind(ListNode* plist, LTDataType x);
    25. // 双向链表在pos的前面进行插入
    26. void ListInsert(ListNode* pos, LTDataType x);
    27. // 双向链表删除pos位置的结点
    28. void ListErase(ListNode* pos);

    4.顺序表和链表的区别 

    今天的分享就到这了

    感谢你的观看

     

     

  • 相关阅读:
    怎么按要求对PDF文件进行拆分？PDF拆分教程来了
    防火墙的相关知识
    ESDA in PySal (5)：空间数据的探索性分析：空间自相关
    微型机器人群，隧道挖掘的未来之才
    105-120-Hadoop-MapReduce-outputformat：
    部署Netlify站点博客
    【接口测试】Postman（一）--接口测试知识准备
    Redis怎么测？这篇文章写的太全了
    【数据结构】链表超全整理~
    【论文阅读】Semi-supervised Sequence Learning半监督序列学习
  • 原文地址：https://blog.csdn.net/weixin_73496371/article/details/136720287