顺序表和链表

文章目录

• **顺序表和链表**
• • **1.线性表**
  • • **1.1线性表的定义与图解**
  • **2.顺序表**
  • • **2.1顺序表的概念与结构**
    • **2.2接口实现**
    • **2.3顺序表的问题及思考**
  • **3.链表**
  • • **3.1链表的概念及结构**
    • **3.2链表的类别**
    • **3.3单链表的实现**
    • **3.4双向链表的实现**
  • **4.顺序表与链表的区别**
  • **5.备注：表的实现只给接口名称，在下一个博客里专门写接口内容**

1.线性表

1.1线性表的定义与图解

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

2.顺序表

2.1顺序表的概念与结构

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

类别：
1.静态顺序表：使用定长数组存储元素
2.动态顺序表：使用动态开辟的数组存储

2.2接口实现

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

    typedef int SLDataType;
    // 顺序表的动态存储
    typedef struct SeqList
    {
        SLDataType* array; // 指向动态开辟的数组
        size_t size ; // 有效数据个数
        size_t capicity ; // 容量空间的大小
    }SeqList; 
    //这里定义的SeqList全局变量名与定义的结构名相同
    //个别编译器会警告声明不清楚
    //我的编译器是支持的，所以这里就这样写
    //如果你们的错了，就加个struct 这下面我帮大家加了struct方便不细看的朋友
    
    // 基本增删查改接口
    
    // 顺序表初始化
    void SeqListInit(struct SeqList* psl, size_t capacity);
    // 检查空间，如果满了，进行增容
    void CheckCapacity(struct SeqList* psl);
    // 顺序表尾插
    void SeqListPushBack(struct SeqList* psl, SLDataType x);
    // 顺序表尾删
    void SeqListPopBack(struct SeqList* psl);
    // 顺序表头插
    void SeqListPushFront(struct SeqList* psl, SLDataType x);
    // 顺序表头删
    void SeqListPopFront(struct SeqList* psl);
    // 顺序表查找
    int SeqListFind(struct SeqList* psl, SLDataType x);
    // 顺序表在pos位置插入x
    void SeqListInsert(struct SeqList* psl, size_t pos, SLDataType x);
    // 顺序表删除pos位置的值
    void SeqListErase(struct SeqList* psl, size_t pos);
    // 顺序表销毁
    void SeqListDestory(struct SeqList* psl);
    // 顺序表打印
    void SeqListPrint(struct SeqList* psl);

2.3顺序表的问题及思考

问题：
1.中间/头部的插入删除，时间复杂度为O(N)
2.增容需要申请新空间，拷贝数据，释放旧空间，会有不小的消耗
3.增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间

思考：如何解决这个问题？ 当然是使用链表啦！

3.链表

3.1链表的概念及结构

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

3.2链表的类别

实际使用中的链表的结构非常多样，总结起来就8种链表结构：

1.单向或者双向

2.带头或者不带头

3.循环或者非循环

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

3.3单链表的实现

    // 1、无头+单向+非循环链表增删查改实现
    typedef int SLTDateType;
    typedef struct SListNode
    {
        SLTDateType data;
        struct SListNode* next;
    }SListNode;
    
    // 动态申请一个节点
    SListNode* BuySListNode(SLTDateType x);
    // 单链表打印
    void SListPrint(SListNode* plist);
    // 单链表尾插
    void SListPushBack(SListNode** pplist, SLTDateType x);
    // 单链表的头插
    void SListPushFront(SListNode** pplist, SLTDateType x);
    // 单链表的尾删
    void SListPopBack(SListNode** pplist);
    // 单链表头删
    void SListPopFront(SListNode** pplist);
    // 单链表查找
    SListNode* SListFind(SListNode* plist, SLTDateType x);
    // 单链表在pos位置之后插入x
    // 分析思考为什么不在pos位置之前插入？
    void SListInsertAfter(SListNode* pos, SLTDateType x);
    // 单链表删除pos位置之后的值
    // 分析思考为什么不删除pos位置？
    void SListEraseAfter(SListNode* pos);

3.4双向链表的实现

    // 2、带头+双向+循环链表增删查改实现
    typedef int LTDataType;
    typedef struct ListNode
    {
    LTDataType _data;
    struct ListNode* next;
    struct ListNode* prev;
    }ListNode;
    
    // 创建返回链表的头结点.
    ListNode* ListCreate();
    // 双向链表销毁
    void ListDestory(ListNode* plist);
    // 双向链表打印
    void ListPrint(ListNode* plist);
    // 双向链表尾插
    void ListPushBack(ListNode* plist, LTDataType x);
    // 双向链表尾删
    void ListPopBack(ListNode* plist);
    // 双向链表头插
    void ListPushFront(ListNode* plist, LTDataType x);
    // 双向链表头删
    void ListPopFront(ListNode* plist);
    // 双向链表查找
    ListNode* ListFind(ListNode* plist, LTDataType x);
    // 双向链表在pos的前面进行插入
    void ListInsert(ListNode* pos, LTDataType x);
    // 双向链表删除pos位置的节点
    void ListErase(ListNode* pos);

4.顺序表与链表的区别

5.备注：表的实现只给接口名称，在下一个博客里专门写接口内容