链表（Linked List）的C语言实现

其他 2018-07-03 15:29:56 阅读次数: 0

链表中的各对象按线性顺序排列，而其顺序是由各个对象里的指针所决定的。
链表有多种形式，它可以是单链接的或者双链接的，可以是已排序的或未排序的，可以是循环的或非循环的。
定义的结构体以及函数如下：

typedef struct SINGLE_LINKED_LIST
{
    Node * head;
    Node * tail;
} SLL;
typedef struct CIRCULAR_SINGLE_LINKED_LIST
{
    Node * head;
    Node * tail;
} CSLL;
typedef struct DOUBLE_LINKED_LIST
{
    Node * head;
    Node * tail;
} DLL;
typedef struct CIRCULAR_DOUBLE_LINKED_LIST_WITH_SENTINEL
{
    Node * nil;
} CDLLS;

void linked_list_traverse(Node * L);
void linked_list_free(Node* L);

Node* single_linked_list_insert(SLL * L, item_t item);
Node* single_linked_list_search(SLL * L, item_t item);
int single_linked_list_delete(SLL * L, Node * node);

Node* circular_single_linked_list_insert(CSLL * L, item_t item);
Node* circular_single_linked_list_search(CSLL * L, item_t item);
int circular_single_linked_list_delete(CSLL * L, Node * node);

Node* double_linked_list_insert(DLL * L, item_t  item);
Node* double_linked_list_search(DLL * L, item_t item);
int double_linked_list_delete(DLL * L, Node * node);

CDLLS* circular_double_linked_list_with_sentinel_init();
Node* circular_double_linked_list_with_sentinel_insert(CDLLS * L, item_t item);
Node* circular_double_linked_list_with_sentinel_search(CDLLS * L, item_t item);
int circular_double_linked_list_with_sentinel_delete(CDLLS * L, Node * node);

几个公共函数如下：

//functions for all kind of linked list
void linked_list_traverse(Node* L) {
    if (L == NULL) {
        printf("Empty Linked List.\n");
    }
    Node * pos = L;
    while (pos != NULL) {
        printf("%2d is in location:%9p. prev is %9p. next is %9p.\n", pos->item.key, \
            pos, pos->prev, pos->next);
        pos = pos->next;
        if (pos == L) return;
    }
}

void linked_list_free(Node* L) {
    Node * pos = L;
    Node * f = L;
    while (pos != NULL && pos != L) {
        f = pos;
        pos = pos->next;
        free(f);
    }
}
//-----------------------------------------------------------------------

单链接的未排序非循环链表可以如如下实现：

//functions for single linked list
Node* single_linked_list_insert(SLL * L, item_t item) {
    Node * node = (Node*)malloc(sizeof(Node));
    node->item = item;
    node->prev = NULL;
    node->next = L->head;
    if (L->tail == NULL)
        L->tail = node;
    L->head = node;
    return node;
}
Node* single_linked_list_search(SLL * L, item_t item) {
    if (L->head == NULL) {
        fprintf(stderr, "The single linked list is empty.\n");
        return NULL;
    }
    Node * pos = L->head;
    while (pos != NULL) {
        if (item.key == pos->item.key)
            return pos;
        pos = pos->next;
    }
    fprintf(stderr, "The item cannot be found.\n");
    return NULL;
}
int single_linked_list_delete(SLL * L, Node * node) {
    if (L->head == NULL) {
        fprintf(stderr, "The single linked list is empty.\n");
        return 0;
    }
    if (node == NULL) {
        fprintf(stderr, "The node is NULL.\n");
        return 0;
    }
    if (L->head == node) {
        L->head = node->next;
        if (L->head == NULL)
            L->tail = NULL;
        return 1;
    }
    Node * pos = L->head;
    while (pos != NULL && pos->next != node) {
        pos = pos->next;
    }
    if (pos->next = node) {
        if (node == L->tail)
            L->tail = pos;
        pos->next = pos->next->next;
        return 1;
    }
    fprintf(stderr, "No such node in linked list.\n");
    return 0;
}
int single_linked_list_reverse(SLL * L) {
    if (L->head == NULL) {
        fprintf(stderr, "The single linked list is empty.\n");
        return 0;
    }
    L->tail = L->head;
    Node *pre, *current, *next;
    pre = L->head;
    current = L->head->next;
    L->head->next = NULL;
    next = NULL;
    while (current != NULL) {
        next = current->next;
        current->next = pre;
        pre = current;
        current = next;
    }
    L->head = pre;
    return 1;
}
//------------------------------------------------------------------------

各个函数的功能均可见其函数名与返回值。使用SLL时动态分配内存即可，如：

void test_for_single_linked_list() {
    SLL * L = (SLL*)malloc(sizeof(SLL));
    printf("%p\n", L->head);
    item_t item = {10, NULL};
    Node * node;
    for (int i = 0; i < 10; i++) {
        item.key = i + 10;
        single_linked_list_insert(L, item);
    }
    printf("SLL head is in location:%p\n", L->head);
    linked_list_traverse(L->head);
    single_linked_list_reverse(L);
    linked_list_traverse(L->head);
    for (int i = -1; i <= 10; i++) {
        item.key = i + 10;
        node = single_linked_list_search(L, item);
        if (node != NULL)
            printf("Node %d in location %p delete :%d\n", node->item.key, node, \
                single_linked_list_delete(L, node));
        //printf("SLL tail is in location:%p\n", L->tail);
    }
    printf("---------------------------------------------\n");
    for (int i = 0; i < 10; i++) {
        item.key = i + 10;
        single_linked_list_insert(L, item);
    }
    printf("SLL head is in location:%p\n", L->head);
    linked_list_traverse(L->head);
    for (int i = 11; i >= -1; i--) {
        item.key = i + 10;
        node = single_linked_list_search(L, item);
        if (node != NULL)
            printf("Node %d in location %p delete :%d\n", node->item.key, node, \
                single_linked_list_delete(L, node));
        //printf("SLL tail is in location:%p\n", L->tail);
    }
    linked_list_free(L->head);
    free(L);
}

双链接的未排序非循环链表可如如下实现：

//functions for double linked list
Node* double_linked_list_insert(DLL * L, item_t item) {
    Node * node = (Node*)malloc(sizeof(Node));
    node->prev = NULL;
    node->item = item;
    node->next = L->head;
    if (L->head != NULL)
        L->head->prev = node;
    else
        L->tail = node;
    L->head = node;
    return node;
}
Node* double_linked_list_search(DLL * L, item_t item) {
    if (L->head == NULL) {
        fprintf(stderr, "The double linked list is empty.\n");
        return NULL;
    }
    Node * pos = L->head;
    while (pos != NULL) {
        if (pos->item.key == item.key)
            return pos;
        pos = pos->next;
    }
    fprintf(stderr, "The item cannot be found.\n");
    return NULL;
}
int double_linked_list_delete(DLL * L, Node * node) {
    if (L->head == NULL) {
        fprintf(stderr, "The double linked list is empty.\n");
        return 0;
    }
    if (node == NULL) {
        fprintf(stderr, "The node is NULL.\n");
        return 0;
    }
    if (node == L->tail)
        L->tail = node->prev;
    if (node->prev != NULL) {
        node->prev->next = node->next;
    } else {
        L->head = node->next;
    }
    if (node->next != NULL) {
        node->next->prev = node->prev;
    }
    return 1;
}
//----------------------------------------------------------------------------

注意要点与单链接的未排序非循环链表相同。测试可如下：

void test_for_double_linked_list() {
    DLL * L = (DLL*)malloc(sizeof(DLL));
    printf("%p\n", L->head);
    item_t item = {10, NULL};
    Node * node;
    for (int i = 0; i < 10; i++) {
        item.key = i + 10;
        double_linked_list_insert(L, item);
    }
    printf("DLL head is in location:%p\n", L->head);
    linked_list_traverse(L->head);
    for (int i = -1; i <= 10; i++) {
        item.key = i + 10;
        node = double_linked_list_search(L, item);
        if (node != NULL)
            printf("Node %d in location %p delete :%d\n", node->item.key, node, \
                double_linked_list_delete(L, node));
        //printf("DLL tail is in location:%p\n", L->tail);
    }
    printf("---------------------------------------------\n");
    for (int i = 0; i < 10; i++) {
        item.key = i + 10;
        double_linked_list_insert(L, item);
    }
    printf("DLL head is in location:%p\n", L->head);
    linked_list_traverse(L->head);
    for (int i = 11; i >= -1; i--) {
        item.key = i + 10;
        node = double_linked_list_search(L, item);
        if (node != NULL)
            printf("Node %d in location %p delete :%d\n", node->item.key, node, \
                double_linked_list_delete(L, node));
        //printf("DLL tail is in location:%p\n", L->tail);
    }
    linked_list_free(L->head);
    free(L);
}

单链接未排序的循环链表可如如下实现：

//functinos for circular single linked list
Node* circular_single_linked_list_insert(CSLL * L, item_t item) {
    Node * node = (Node*)malloc(sizeof(Node));
    node->item = item;
    node->prev = NULL;
    if (L->head == NULL) {
        L->head = node;
        L->tail = node;
        node->next = node;
    } else {
        node->next = L->head;
        L->head = node;
        L->tail->next = node;
    }
    return node;
}
Node* circular_single_linked_list_search(CSLL * L, item_t item) {
    if (L->head == NULL) {
        fprintf(stderr, "The circular single linked list is empty.\n");
        return NULL;
    }
    Node * pos = L->head;
    if (pos->item.key == item.key)
        return pos;
    else
        pos = pos->next;
    while (pos->item.key != item.key && pos != L->head) {
        pos = pos->next;
    }
    if (pos != L->head)
        return pos;
    fprintf(stderr, "The item cannot be found.\n");
    return NULL;
}
int circular_single_linked_list_delete(CSLL * L, Node * node) {
    if (L->head == NULL) {
        fprintf(stderr, "The circular single linked list is empty.\n");
        return 0;
    }
    if (node == NULL) {
        fprintf(stderr, "The node is NULL.\n");
        return 0;
    }
    if (node == L->head && node == L->tail) {
        L->head = NULL;
        L->tail = NULL;
        return 1;
    } else if (node == L->head) {
        L->head = node->next;
        L->tail->next = L->head;
        return 1;
    }
    Node * pos = L->head;
    while (pos->next != node && pos != L->tail) {
        pos = pos->next;
    }
    if (pos->next == node) {
        if (node == L->tail) {
            L->tail = pos;
        }
        pos->next = node->next;
        return 1;
    }
    fprintf(stderr, "No such node in linked list.\n");
    return 0;
}
//------------------------------------------------------------------------

测试可如下：

void test_for_circular_single_linked_list() {
    CSLL * L = (CSLL*)malloc(sizeof(CSLL));
    printf("%p\n", L->head);
    item_t item = {10, NULL};
    Node * node;
    for (int i = 0; i < 10; i++) {
        item.key = i + 10;
        circular_single_linked_list_insert(L, item);
    }
    printf("CSLL head is in location:%p\n", L->head);
    linked_list_traverse(L->head);
    for (int i = -1; i <= 10; i++) {
        item.key = i + 10;
        node = circular_single_linked_list_search(L, item);
        if (node != NULL)
            printf("Node %d in location %p delete :%d\n", node->item.key, node, \
                circular_single_linked_list_delete(L, node));
        //linked_list_traverse(L->head);
    }
    printf("---------------------------------------------\n");
    for (int i = 0; i < 10; i++) {
        item.key = i + 10;
        circular_single_linked_list_insert(L, item);
    }
    printf("CSLL head is in location:%p\n", L->head);
    linked_list_traverse(L->head);
    for (int i = 11; i >= -1; i--) {
        item.key = i + 10;
        node = circular_single_linked_list_search(L, item);
        if (node != NULL)
            printf("Node %d in location %p delete :%d\n", node->item.key, node, \
                circular_single_linked_list_delete(L, node));
    }
    linked_list_free(L->head);
    free(L);
}

有哨兵的双链接未排序循环链表可如如下实现：

//functions for cicular double linked list with sentinel
CDLLS* circular_double_linked_list_with_sentinel_init() {
    CDLLS * L = (CDLLS*)malloc(sizeof(CDLLS));
    L->nil = (Node*)malloc(sizeof(Node));
    L->nil->next = L->nil;
    L->nil->prev = L->nil;
    return L;
}
Node* circular_double_linked_list_with_sentinel_insert(CDLLS * L, item_t item) {
    Node * node = (Node*)malloc(sizeof(Node));
    node->item = item;
    node->next = L->nil->next;
    L->nil->next->prev = node;
    node->prev = L->nil;
    L->nil->next = node;
    return node;
}
Node* circular_double_linked_list_with_sentinel_search(CDLLS * L, item_t item) {
    if (L->nil->next == L->nil) {
        fprintf(stderr, "The circular double linked list is empty.\n");
        return NULL;
    }
    Node* pos = L->nil->next;
    while (pos != L->nil && pos->item.key != item.key) {
        pos = pos->next;
    }
    if (pos == L->nil) {
        fprintf(stderr, "The item cannot be found.\n");
        return NULL;
    } else {
        return pos;
    }
}
int circular_double_linked_list_with_sentinel_delete(CDLLS * L, Node * node) {
    if (L->nil->next == L->nil) {
        fprintf(stderr, "The circular double linked list is empty.\n");
        return 0;
    }
    if (node == NULL) {
        fprintf(stderr, "The node is NULL.\n");
        return 0;
    }
    node->prev->next = node->next;
    node->next->prev = node->prev;
    return 1;
}
//--------------------------------------------------------------------------

测试可如下：

void test_for_circular_double_linked_list() {
    CDLLS * L = circular_double_linked_list_with_sentinel_init();
    printf("%p %p %p %p\n", L, L->nil, L->nil->prev, L->nil->prev);
    item_t item = {10, NULL};
    Node * node;
    for (int i = 0; i < 10; i++) {
        item.key = i + 10;
        circular_double_linked_list_with_sentinel_insert(L, item);
    }
    printf("CDLLS nil is in location:%p\n", L->nil);
    linked_list_traverse(L->nil);
    for (int i = -1; i <= 10; i++) {
        item.key = i + 10;
        node = circular_double_linked_list_with_sentinel_search(L, item);
        if (node != NULL)
            printf("Node %d in location %p delete :%d\n", node->item.key, node, \
                circular_double_linked_list_with_sentinel_delete(L, node));
    }
    printf("---------------------------------------------\n");
    for (int i = 0; i < 10; i++) {
        item.key = i + 10;
        circular_double_linked_list_with_sentinel_insert(L, item);
    }
    printf("CDLLS nil is in location:%p\n", L->nil);
    linked_list_traverse(L->nil);
    for (int i = 11; i >= -1; i--) {
        item.key = i + 10;
        node = circular_double_linked_list_with_sentinel_search(L, item);
        if (node != NULL)
            printf("Node %d in location %p delete :%d\n", node->item.key, node, \
                circular_double_linked_list_with_sentinel_delete(L, node));
    }
    linked_list_free(L->nil);
    free(L);
}

可以将其看为含有哨兵的一个循环的圆圈，这样理解比较方便。

猜你喜欢

转载自blog.csdn.net/sinat_16709955/article/details/77431034
今日推荐
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
周排行
rbac——界面、权限
Apache CXF + SpringMVC 整合发布WebService
so插件化
Vue.js实战系列---图标字体制作（svg格式）
PAT乙级 1007 素数对猜想(孪生素数对) (20分) ---（C语言 + 详细注释）
被IRM保护的文档，打开失败
Calendar和Date计算日期差的小问题
win10子系统ubuntu18.4安装docker
利用Wrap Shell Script定位Android Native内存泄漏
MySQL: Transaction (Part I - Basic Concept)
每日归档
更多
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022