typedef struct listNode {
  struct listNode *prev;
  struct listNode *next;
  void *value;
} listNode;

typedef struct list {
    listNode *head;
    listNode *tail;
    void *(*dup)(void *ptr);
    void (*free)(void *ptr);
    int (*match)(void *ptr, void *key);
    unsigned long len;
} list;

list *listCreate(void){
	// 声明 list结构体的指针list
    struct list *list;
	// list 结构体分配内存
    if ((list = zmalloc(sizeof(*list))) == NULL)
        return NULL;
    // 初始化链表头尾指针为 NULL,链表长度len=0
    list->head = list->tail = NULL;
    list->len = 0;
    // 复制、释放和匹配函数为 NULL
    list->dup = NULL;
    list->free = NULL;
    list->match = NULL;
    return list;
}

void listRelease(list *list){
    if (!list) // 避免了在空指针上执行操作，这可能会导致未定义行为或程序崩溃。
        return;
    // listEmpty释放链表中的所有节点，逐个释放每个节点所占用的内存
    listEmpty(list);
    // zfree释放list结构体本身所占用的内存
    zfree(list);
}

void listEmpty(list *list)  {  
    // 获取链表的长度  
    unsigned long len;  
    // 定义当前节点和下一个节点的指针  
    listNode *current, *next;  
      
    // 将当前节点指针指向链表的头节点  
    current = list->head;  
      
    // 将链表长度赋值给len变量，方便后续遍历  
    len = list->len;  
      
    // 循环遍历链表，直到所有节点都被处理  
    while(len--) {  
        // 将下一个节点指针指向当前节点的下一个节点  
        next = current->next;  
          
        // 如果链表定义了释放节点值的函数，则调用该函数释放当前节点的值  
        if (list->free) list->free(current->value);  
          
        // 释放当前节点所占用的内存  
        zfree(current);  
          
        // 将当前节点指针指向下一个节点，准备处理下一个节点  
        current = next;  
    }  
      
    // 将链表的头节点和尾节点指针置为NULL，表示链表为空  
    list->head = list->tail = NULL;  
      
    // 将链表长度置为0，表示链表没有节点  
    list->len = 0;  
}

// 接受一个指向 list 结构的指针和一个 void 类型的指针作为参数
// 返回一个指向 list 结构的指针
list *listAddNodeHead(list *list, void *value)  {  
    // 指向 listNode 结构的指针 node
    listNode *node;
  
    // 为 listNode 分配内存，并将返回的地址赋值给 node
    if ((node = zmalloc(sizeof(*node))) == NULL)  
        // 如果内存分配失败，则返回 NULL  
        return NULL;  
  
    // 将传入的 value 赋值给新节点的 value 字段
    node->value = value;  
  
    // 调用 listLinkNodeHead 函数，将新节点添加到链表的头部  
    listLinkNodeHead(list, node);  
  
    // 返回更新后的链表指针
    return list;  
} 

// 将一个节点链接到链表的头部  
void listLinkNodeHead(list* list, listNode *node) {  
    // 如果链表为空（即长度为0）  
    if (list->len == 0) {  
        // 将新节点设置为链表的头节点和尾节点  
        list->head = list->tail = node;  
        // 因为链表只有一个节点，所以该节点的prev和next都指向NULL  
        node->prev = node->next = NULL;  
    } else {  
        // 如果链表不为空，新节点的prev指向NULL（因为它是头部节点）  
        node->prev = NULL;  
        // 将新节点的next指向当前的头节点  
        node->next = list->head;  
        // 将当前头节点的prev指向新节点，形成双向链表的链接  
        list->head->prev = node;  
        // 将链表的头节点更新为新节点  
        list->head = node;  
    }  
    // 无论链表是否为空，都将链表的长度加1  
    list->len++;  
}

// 从列表中删除一个节点，并释放相关内存  
void listDelNode(list *list, listNode *node)  {  
    // listUnlinkNode从列表中解除该节点的链接  
    listUnlinkNode(list, node);  
    // 列表的free字段不为空（即存在一个用于释放节点值的回调函数）  
    if (list->free)   
        // 调用该回调函数，释放节点中存储的值所占用的内存  
        list->free(node->value);  
      
    // zfree释放节点本身所占用的内存  
    zfree(node);  
}

// 从双向链表中移除一个节点，但不释放其内存  
void listUnlinkNode(list *list, listNode *node) {  
    // 如果该节点有前一个节点  
    if (node->prev) {  
        // 将前一个节点的next指针指向当前节点的下一个节点  
        node->prev->next = node->next;  
    } else {  
        // 否则，当前节点是头节点，将列表的头指针指向当前节点的下一个节点  
        list->head = node->next;  
    }  
      
    // 如果该节点有下一个节点  
    if (node->next) {  
        // 将下一个节点的prev指针指向当前节点的前一个节点  
        node->next->prev = node->prev;  
    } else {  
        // 否则，当前节点是尾节点，将列表的尾指针指向当前节点的前一个节点  
        list->tail = node->prev;  
    }  
      
    // 将当前节点的next和prev指针都设置为NULL，表示它已经从链表中移除  
    node->next = NULL;  
    node->prev = NULL;  
      
    // 减少列表的长度计数  
    list->len--;  
}