C实现通用数据结构--单链表

单链表概述

单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。

从概念上讲，可以把链表想象成一系列连续的元素，然而，由于这些元素是动态分配的（C语言中使用malloc），切记这些元素通常实际上都是分散在内存空间的

本文地址：http://www.cnblogs.com/archimedes/p/c-datastruct-linklist.html，转载请注明源地址。

单链表的接口定义：

1、list_init

void list_init(List *list, void (*destroy)(void *data));

返回值   void

描述    初始化由参数list指定的链表，该函数必须在链表做其他操作之前调用，当调用list_destroy时，destroy参数提供了一种释放动态分配数据的方法。如果链表采用malloc动态分配的数据，destroy应该设置为free来释放这些数据

复杂度   O(1)


2、list_destroy

void list_destroy(List *list);

返回值   void

描述    销毁由参数list指定的链表，调用该函数以后任何函数都不能再执行，除非重新执行list_init函数。list_destroy将list中的所有元素都移除，每移除一个元素都会调用此函数

复杂度   O(n)  n为链表元素的个数


3、list_ins_next

int list_ins_next(List *list, ListElmt *element, const void *data);

返回值   如果插入元素成功返回0，否则返回-1

描述    在指定的list的element元素后面插入一个元素，如果element为NULL，则在链表的头部插入新的元素，该元素包含一个指向data的指针

复杂度   O(1)


4、list_rem_next

int list_rem_next(List *list, ListElmt *element, void **data);

返回值    如果移除元素成功返回0，否则返回-1

描述    移除在指定的list的element后面的那个元素，如果element为NULL，则移除链表的头元素，调用返回后，data指向已经移除元素的数据

复杂度   O(1)


5、list_size

int list_size(const List *list);

返回值    如果list中元素的个数

描述    这是一个宏，用来计算指定list中元素的个数

复杂度   O(1)


6、list_head

ListElmt *list_head(const List *list);

返回值    指向链表头元素的指针

描述    这是一个宏，返回由参数list指定的链表头元素的指针

复杂度   O(1)


7、list_tail

ListElmt *list_tail(const List *list) ((list)->tail);

返回值    指向链表尾元素的指针

描述    这是一个宏，返回由参数list指定的链表尾元素的指针

复杂度   O(1)


8、list_is_head

int list_is_head(const ListElmt *element);

返回值    如果element元素是链表头元素返回0，否则返回-1

描述    这是一个宏，用来判断element元素是否是list的头元素

复杂度   O(1)


9、list_is_tail

int list_is_tail(const ListElmt *element);

返回值    如果element元素是链表尾元素返回0，否则返回-1

描述    这是一个宏，用来判断element元素是否是list的尾元素

复杂度   O(1)


10、list_data

void *list_data(const ListElmt *element);

返回值    结点中保存的数据

描述    这是一个宏，返回由element元素中保存的数据

复杂度   O(1)


11、list_next

ListElmt *list_next(const ListElmt *element) ;

返回值    返回element所指定结点的下一个结点

描述    这是一个宏，返回链表中element所指定结点的下一个结点

复杂度   O(1)

单链表的实现和分析

抽象数据类型的头文件（list.h）：

#ifndef LIST_H
#define LIST_H
#include <stdlib.h>
//为单链表的结点定义一个结构体.
typedef struct ListElmt_ {
    void               *data;   //数据域
    struct ListElmt_   *next;    //指针域

} ListElmt;

//为单链表定义一个结构体.
typedef struct List_ {
    int                size;     //容量
    int                (*match)(const void *key1, const void *key2);    //匹配函数
    void               (*destroy)(void *data);    //撤销操作
    ListElmt           *head;   //头指针
    ListElmt           *tail;   //尾指针

} List;

//公共接口
void list_init(List *list, void (*destroy)(void *data));

void list_destroy(List *list);

int list_ins_next(List *list, ListElmt *element, const void *data);

int list_rem_next(List *list, ListElmt *element, void **data);

#define list_size(list) ((list)->size)

#define list_head(list) ((list)->head)

#define list_tail(list) ((list)->tail)

#define list_is_head(list, element) ((element) == (list)->head ? 1 : 0)

#define list_is_tail(element) ((element)->next == NULL ? 1 : 0)

#define list_data(element) ((element)->data)

#define list_next(element) ((element)->next)

#endif

初始化单链表：

void list_init(List *list, void (*destroy)(void *data)) {  //初始化list
    list->size = 0;
    list->destroy = destroy;   //设置为定义的析构函数
    list->head = NULL;
    list->tail = NULL;
    return;
}

回收单链表：

void list_destroy(List *list) {
//移除每一个元素
    while (list_size(list) > 0) {
           if (list_rem_next(list, NULL, (void **)&data) == 0 && list->destroy != NULL) {  //不断地移除链表的头结点
                  list->destroy(data);  //调用一个用户定义的函数来释放动态分配的数据.
           }
    }
    //现在没有操作了,释放结构体作为预防措施
    memset(list, 0, sizeof(List));
    return;
}

插入新节点作为指定结点的直接后继结点:

int list_ins_next(List *list, ListElmt *element, const void *data) {
    ListElmt *new_element;     //为结点动态分配存储空间
    if ((new_element = (ListElmt *)malloc(sizeof(ListElmt))) == NULL)  //假如分配失败
          return -1;
    // 将元素插入链表
    new_element->data = (void *)data;
    if (element == NULL) {
        //插入到链表的头部
        if (list_size(list) == 0)
            list->tail = new_element;
        new_element->next = list->head;
        list->head = new_element;
    } else {
        //插入到除了链表头部以外指定的其他地方
        if (element->next == NULL)
            list->tail = new_element;
        new_element->next = element->next;
        element->next = new_element;
    }
    list->size++; //表长增加
    return 0;
}

删除指定结点的直接后继结点:

int list_rem_next(List *list, ListElmt *element, void **data) {
    ListElmt *old_element;
    //不允许从一个空的list中移除元素.
    if (list_size(list) == 0)
        return -1;
    // 从list中移除元素.
    if (element == NULL) {
        // 移除表头的结点.
           *data = list->head->data;
        old_element = list->head;
        list->head = list->head->next;
        if (list_size(list) == 1)   //如果list只有一个元素，则直接删除尾结点
            list->tail = NULL;
    } else {
        // 移除非头结点.
        if (element->next == NULL)
            return -1;
        *data = element->next->data;
        old_element = element->next;
        element->next = element->next->next;
        if (element->next == NULL)  //移除指定结点后，后继为NULL，则用尾结点指向
            list->tail = element;
    }
    //释放分配的抽象数据类型.
    free(old_element);
    //调整list的长度.           *
    list->size--;
    return 0;
}

注意：list_size、list_head、list_tail、list_is_head、list_is_tail、list_data、list_next 这些宏实现了链表中的一些简单操作，它们提供了快速访问和检测结构体成员的能力。这些操作的时间复杂度都是O(1)

完整的测试代码如下：

// Completed on 2014.10.22 21:00
// Language: C99
//
// 版权所有（C）codingwu   (mail: [email protected])
// 博客地址：http://www.cnblogs.com/archimedes/
#include <stdio.h>
#include <stdlib.h>
#include "list.h"

static void print_list(const List *list) {
    ListElmt *element;
    int *data, i;
    fprintf(stdout, "List size is %d\n", list_size(list));
    i = 0;
    element = list_head(list);
    while (1) {
        data = list_data(element);
        fprintf(stdout, "list[%03d]=%03d\n", i, *data);
        i++;
        if (list_is_tail(element))
            break;
        else
            element = list_next(element);
    }
    return;
}

int main(int argc, char **argv) {

    List list;
    ListElmt *element;
    int *data, i;

    //初始化list
    list_init(&list, free);
    element = list_head(&list);
    for (i = 10; i > 0; i--) {
        if ((data = (int *)malloc(sizeof(int))) == NULL)
            return 1;
        *data = i;
        if (list_ins_next(&list, NULL, data) != 0)  //逐个插入元素
            return 1;

    }
    print_list(&list);    //打印初始list
    element = list_head(&list);  //指向头结点
    for (i = 0; i < 7; i++)
        element = list_next(element);

    data = list_data(element);
    fprintf(stdout, "Removing an element after the one containing %03d\n", *data);

    if (list_rem_next(&list, element, (void **)&data) != 0)  //删除指定结点
        return 1;
    print_list(&list);
    fprintf(stdout, "Inserting 011 at the tail of the list\n");
    *data = 11;
    if (list_ins_next(&list, list_tail(&list), data) != 0)   //插入指定结点
        return 1;
    print_list(&list);
    fprintf(stdout, "Removing an element after the first element\n");

    element = list_head(&list);
    if (list_rem_next(&list, element, (void **)&data) != 0)
       return 1;

    print_list(&list);

    fprintf(stdout, "Inserting 012 at the head of the list\n");

    *data = 12;
    if (list_ins_next(&list, NULL, data) != 0)
        return 1;

    print_list(&list);

    fprintf(stdout, "Iterating and removing the fourth element\n");

    element = list_head(&list);
    element = list_next(element);
    element = list_next(element);

    if (list_rem_next(&list, element, (void **)&data) != 0)
        return 1;

    print_list(&list);

    fprintf(stdout, "Inserting 013 after the first element\n");

    *data = 13;
    if (list_ins_next(&list, list_head(&list), data) != 0)
        return 1;

    print_list(&list);

    i = list_is_head(&list, list_head(&list));
    fprintf(stdout, "Testing list_is_head...Value=%d (1=OK)\n", i);
    i = list_is_head(&list, list_tail(&list));
    fprintf(stdout, "Testing list_is_head...Value=%d (0=OK)\n", i);
    i = list_is_tail(list_tail(&list));
    fprintf(stdout, "Testing list_is_tail...Value=%d (1=OK)\n", i);
    i = list_is_tail(list_head(&list));
    fprintf(stdout, "Testing list_is_tail...Value=%d (0=OK)\n", i);

    fprintf(stdout, "Destroying the list\n");
    list_destroy(&list);
    return 0;

}
时间： 2024-10-10 08:43:47

C实现通用数据结构--单链表的相关文章

python实现数据结构单链表

#python实现数据结构单链表 # -*- coding: utf-8 -*- class Node(object): """节点""" def __init__(self, elem): self.elem = elem self.next = None # 节点一开始初始化的时候并不知道下一个元素的地址,所以先设置为空 class SingLinkList(object): """单链表""

数据结构—单链表（类C语言描写叙述）

单链表 1.链接存储方法 链接方式存储的线性表简称为链表(Linked List). 链表的详细存储表示为: ① 用一组随意的存储单元来存放线性表的结点(这组存储单元既能够是连续的.也能够是不连续的) ② 链表中结点的逻辑次序和物理次序不一定同样.为了能正确表示结点间的逻辑关系,在存储每一个结点值的同一时候,还必须存储指示其后继结点的地址(或位置)信息(称为指针(pointer)或链(link)) 注意: 链式存储是最经常使用的存储方式之中的一个.它不仅可用来表示线性表.并且可用来表示各种非线性

C# 数据结构 - 单链表 双链表 环形链表

链表特点(单链表 双链表) 优点:插入和删除非常快.因为单链表只需要修改Next指向的节点,双链表只需要指向Next和Prev的节点就可以完成插入和删除操作. 缺点:当需要查找某一个节点的时候就需要一个节点一个节点去访问,这样所花的时候就比较多了.(顺序表可以弥补这缺点,但插入和删除就非常耗性能) 单链表 单链表的构成:必须要有一个链表头(head),每个节点里面有一个Next用于指向下一个节点(类似于指针).最后一个节点的Next为null来标识链表的尾. 如下图 代码实现 1 /* ----

C# 数据结构--单链表

什么是单链表 这两天看到很多有关单链表的面试题,对单链表都不知道是啥的我.经过学习和整理来分享一下啥是单链表和单链表的一些基本使用方法.最后看些网上有关单链表的面试题代码实例. 啥是单链表? 单链表是一种链式存取的数据结构,用一组地址任意的存储单元存放线性表中的数据元素.这组存储单元既可以是连续的,也可以是不连续的. 链表中的数据是以结点来表示的,每个结点的构成:元素(数据元素的映象) + 指针(指示后继元素存储位置),元素就是存储数据的存储单元,指针就是连接每个结点的地址数据. 链表的结点结构

数据结构单链表实现

<数据结构>中单链表的实现c代码 转自:http://blog.chinaunix.net/uid-22750250-id-1769905.html include.h /******************************************************************      程序中要用的头文件******************************************************************/ #include<st

数据结构-单链表-类定义2-C++

上一次的C++链表实现两个单链表的连接不太理想,此次听了一些视频课,自己补了个尾插法,很好的实现了两个链表的连接,当然了,我也是刚接触,可能是C++的一些语法还不太清楚,不过硬是花了一些时间尽量在数据结构中将c++的语言特点表现出来.一开始也是不愿意读c++的数据结构,只是一种挑战心里,不想读着读着感觉自己太low了,c++的内容更加丰富,所以还得多多练习...... 头文件 1 #ifndef LIST_H 2 #define LIST_H 3 #include <iostream> 4 5

Java数据结构——单链表

一.单链表的概念 单链表是一种链式存取的数据结构,用一组地址任意的存储单元存放线性表中的数据元素.这组存储单元可以是连续的,也可以是不连续的. 存储单元由两部分组成,数据源和指针,数据源放数据,指针指向下个存储单元. 二.单链表的结构 采用Node实体类类标识,其中data为存储的数据,next为下一个结点的指针. //链表的实体类 class Node{ public int data; public Node next; public Node(int data) { this.data =

大话数据结构---单链表

单链表在存储结构上与顺序存储的区别:不用开辟连续的存储空间,存储位置任意,只需要让数据的前驱知道它的位置就可以,而使用单链表示只需要知道单链表的第一个元素就能找到其他所有的元素,为了方便 一般会设置一个头指针指向第一个元素. 单链表的数据读取:通过头指针一个一个往后遍历 单链表的插入: 删除: 自定义单链表的简单实现: package com.neuedu.entity; /* * 项目名称:JavaSqList * @author:wzc * @date 创建时间:2017年9月2日 上午9:

数据结构——单链表

1.对于一个有数据的单链表,如果要对其初始化,使用下列操作: 1 void initList(sqlist &L){ #对于需要改变的变量或链表,使用引用型 2 L.length==0; 3 } //单链表长度重置为0 2.单链表有4中操作:归并,插入,删除,查找 归并的实现:(链表A,B是有序的,且归并后的C也是有序的)如下: 1 void merge(LNode *A,LNode *B,LNode *&C){ //将A B两个链表归并为一个新的单链表(链表C采用引用型) 2 LNode