实验楼楼赛第14期-双向链表

最新推荐文章于 2022-10-29 13:29:55 发布

MagicScaring

最新推荐文章于 2022-10-29 13:29:55 发布

阅读量268

点赞数

CC 4.0 BY-SA版权

分类专栏： ACM程序设计

本文链接：https://blog.youkuaiyun.com/MagicScaring/article/details/84032795

ACM程序设计专栏收录该内容

22 篇文章

订阅专栏

本文分享了一次双向链表编程的经历，从初始化、遍历、插入到删除等操作进行了详细解析，并针对循环链表的特性调整了释放内存的逻辑，通过实际编码过程中的bug修复，加深了对链表结构的理解。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目链接双向链表
这道题一开始没有灵感,于是网上搜了下答案.没搜到.于是只好自己乖乖的慢慢改bug.发现List表的head表头和tail表尾是都不为空的,都是指向了具体的节点的,而且这是一个双向循环链表，结尾的遍历和释放都明显错了.代码贴在下面啦:

list.c

#include "list.h"

struct List*
init_list () {
    struct List* list = (struct List *) malloc (sizeof (struct List));
	
	list->head = list->tail = NULL;
    return list;
}

void
free_list (struct List* list) {
    struct Node* current = list->head;
    struct Node* pcurrent = current;
	
	current = current->next;
	free(pcurrent);
	

    while (current != list->head) {
		pcurrent = current;
		current = current->next;
        free (pcurrent);
    }
    free (list);
}

void
traverse_list (struct List* list, void (*callback)(void* data)) {
    struct Node* current = list->head;
    while (current) {
        (*callback)(current->data);
        current = current->next;
		if(current == list->head)
			break;
    }
}

void
insert_after (struct List* list, struct Node* prev, void* data) {
	struct Node* next = prev ? prev->next : list->head;

    struct Node* newnode = (struct Node *) malloc (sizeof (struct Node));
    newnode->data = data;

	newnode->prev = prev ? prev : list->tail;
    newnode->next = next;

    prev ? prev->next = newnode : list->tail ? list->tail->next = newnode : NULL;
    next ? next->prev = newnode : 0 ;

    list->head == NULL ? list->head = list->tail = newnode :
        prev == NULL ? list->tail = newnode : 0 ;
}

void
insert_before (struct List* list, struct Node* next, void* data) {
    struct Node* prev = next ? next->prev : list->tail;

    struct Node* newnode = (struct Node *) malloc (sizeof (struct Node));
    newnode->data = data;

	newnode->prev = prev;
	newnode->next = next ? next : list->head;
	
	next ? next->prev = newnode : list->head ?  list->head->prev = newnode : NULL;
    prev ? prev->next = newnode : 0 ;

    list->tail == NULL ? list->head = list->tail = newnode :
        next == NULL ? list->head = newnode : 0 ;
}

void
insert_front (struct List* list, void* data) {
    insert_before (list, NULL, data);
}

void
insert_back (struct List* list, void* data) {
    insert_after (list, NULL, data);
}

void
delete_from (struct List* list, struct Node* node) {
    struct Node* prev = node->prev;
    struct Node* next = node->next;

    prev ? prev->next = next : 0 ;
    next ? next->prev = prev : 0 ;

    node == list->head ? list->head = next : 0;
    node == list->tail ? list->tail = prev : 0;

    free (node);
}