← 函数大全 | ← List

🔢 DList_S - 双向链表（单一数据类型）

存储单一类型数据的双向链表，需要提供数据操作集 (InfoOfData)

📖 概述

DList_S (Double List Single Data) 是一种双向链表数据结构，只能存储单一类型的数据。所有数据都需要提供对应的 InfoOfData 操作集指针，用于执行复制、比较、释放等操作。

⚙️ 数据类型定义

// 链表节点
typedef struct Node_S_inDList {
    struct Node_S_inDList* prev;  // 前驱节点
    struct Node_S_inDList* next;   // 后继节点
    Data_S val;                    // 数据
} Node_S_inDList;

// DList_S 链表
typedef struct {
    Node_S_inDList* head;      // 头节点
    Node_S_inDList* tail;      // 尾节点
    InfoOfData* valInfo;       // 数据操作集
    int size;                  // 链表长度
} DList_S;

🚀 快速开始

#include "base.h"
#include "List/DList/Single_Data/dlist_sdata.h"
#include "Oper/Int_Info/int_info.h"  // 使用预定义整数操作集

int main() {
    // 1. 初始化链表
    DList_S list;
    initSDList(&list, &Info_Int);

    // 2. 创建数据并插入
    Data_S data1 = Data_S_OWN(123, NULL);
    insertSDataAtEndInSDList(&list, data1);

    Data_S data2 = Data_S_OWN(456, NULL);
    insertSDataAtEndInSDList(&list, data2);

    // 3. 打印链表
    printSDList(&list);

    // 4. 释放链表
    freeSDList(&list);
    return 0;
}

📋 函数列表

🔧 初始化与销毁

void initSDList(DList_S* plist, InfoOfData* valInfo)

初始化 DList_S

参数:
  • plist - DList_S 类型的指针
  • valInfo - InfoOfData 类型数据指针
void freeSDataInSDList(DList_S* plist, Data_S* inputData)

释放 SData (Data_S 类型) 的内容

参数:
  • plist - DList_S 的指针
  • inputData - Data_S 类型指针
void freeSDList(DList_S* plist)

清除 DList_S 链表

参数:
  • plist - DList_S 链表指针

➕ 插入操作

InfoOfReturn insertSDataAtEndInSDList(DList_S* plist, Data_S inputData)

在 DList_S 链表的尾部插入数据 Data_S

参数:
  • plist - DList_S 链表指针
  • inputData - 传入的 Data_S 类型数据
返回: 返回 InfoOfReturn 中的枚举类型
InfoOfReturn insertSDataAtStartInSDList(DList_S* plist, Data_S inputData)

在 DList_S 链表头部插入数据 Data_S

参数:
  • plist - DList_S 链表指针
  • inputData - 传入的 Data_S 类型数据
返回: 返回 InfoOfReturn 中的枚举类型
InfoOfReturn insertSDataAtPosInSDList(DList_S* plist, Data_S inputData, int pos)

在 DList_S 链表 Pos 位置插入数据 Data_S

参数:
  • plist - DList_S 链表指针
  • inputData - 传入的 Data_S 类型数据
  • pos - 位置的范围在 [0, list.size]，范围的两端分别代表头插和尾插
返回: 返回 InfoOfReturn 中的枚举类型

➖ 删除操作

InfoOfReturn delStartNodeInSDList(DList_S* plist)

删除 DList_S 链表头节点

参数:
  • plist - DList_S 链表指针
返回: 返回 InfoOfReturn 中的枚举类型
InfoOfReturn delEndNodeInSDList(DList_S* plist)

删除 DList_S 链表尾节点

参数:
  • plist - DList_S 链表指针
返回: 返回 InfoOfReturn 中的枚举类型
InfoOfReturn delNodeBySDataInSDList(DList_S* plist, Data_S inputData)

通过 SData (Data_S 类型) 数据来删除 DList_S 中的节点

参数:
  • plist - DList_S 链表指针
  • inputData - 传入的 Data_S 类型数据
返回: 返回 InfoOfReturn 中的枚举类型
InfoOfReturn delNodeByPosInSDList(DList_S* plist, int pos)

通过位置删除 DList_S 的节点

参数:
  • plist - DList_S 链表指针
  • pos - 要删除的位置（从 0 开始）
返回: 返回 InfoOfReturn 中的枚举类型

🔍 查询操作

Data_S getPtrSDataByPosInSDList(DList_S* plist, int pos)

通过位置 Pos 返回 SData 的指针 (Data_S 类型)，可直接修改内部的 void* data 和 void* content 内容

参数:
  • plist - List 类型指针
  • pos - 位置（从 0 开始）
返回: 返回 Data_S 类型数据，若没有返回空 Data_S 类型数据，通过 Data.isEmpty 进行查看
Data_S getCopySDataByPosInSDList(DList_S* plist, int pos)

通过 Pos 位置返回 Data_S，注意这里 Data_S 中的 void* data 和 void* content 都是复制的，使用完后记得释放

参数:
  • plist - DList_S 类型指针
  • pos - 位置（从 0 开始）
返回: 返回 Data_S 类型数据，若没有返回空 Data_S 类型数据，通过 Data.isEmpty 进行查看
Data_S getPtrSDataBySDataInSDList(DList_S* plist, Data_S inputData)

通过 Data_S 类型数据返回 SData 的指针 (Data_S 类型)，可直接修改内部的 void* data 和 void* content 内容

参数:
  • plist - DList_S 类型指针
  • inputData - 传入的 Data_S 类型数据
返回: 返回 Data_S 类型数据，若没有返回空 Data_S 类型数据，通过 Data.isEmpty 进行查看
bool hasSDataInSDList(DList_S* plist, Data_S inputData)

判断 Data_S 数据是否在 DList_S 里面

参数:
  • plist - List_M 类型指针
  • inputData - 传入的 Data_S 类型数据
返回: 有就返回 true，没有就 false

🔄 其他操作

void reverseSDList(DList_S* plist)

反转 DList_S 链表

参数:
  • plist - DList_S 链表指针
void printSDataInSDList(DList_S* plist, Data_S inputData)

打印 List_M 链表中的 Data_S 数据（一般为查找类函数返回值）

参数:
  • plist - DList_S 链表指针
  • inputData - Data_S 类型数据
void printSDList(DList_S* plist)

打印 DList_S 链表数据

参数:
  • plist - DList_S 链表指针

💡 完整示例

#include <stdio.h>
#include "base.h"
#include "List/DList/Single_Data/dlist_sdata.h"
#include "Oper/Int_Info/int_info.h"

int main() {
    // 初始化链表
    DList_S list;
    initSDList(&list, &Info_Int);

    // 插入数据
    printf("=== 插入数据 ===\n");
    insertSDataAtEndInSDList(&list, Data_S_OWN(100, NULL));
    insertSDataAtEndInSDList(&list, Data_S_OWN(200, NULL));
    insertSDataAtStartInSDList(&list, Data_S_OWN(50, NULL));
    insertSDataAtPosInSDList(&list, Data_S_OWN(150, NULL), 2);
    printSDList(&list);

    // 查找数据
    printf("\n=== 查找数据 ===\n");
    Data_S found = getPtrSDataByPosInSDList(&list, 2);
    if (!found.isEmpty) {
        printf("位置 2 的数据: %d\n", *(int*)found.data);
    }

    // 判断是否存在
    printf("\n是否存在 200: %s\n", hasSDataInSDList(&list, Data_S_OWN(200, NULL)) ? "是" : "否");

    // 删除数据
    printf("\n=== 删除数据 ===\n");
    delNodeByPosInSDList(&list, 1);
    printSDList(&list);

    // 反转链表
    printf("\n=== 反转链表 ===\n");
    reverseSDList(&list);
    printSDList(&list);

    // 释放链表
    freeSDList(&list);
    return 0;
}

⚠️ 注意事项