数据结构与算法 - 单链表

时间  2021-08-13
标签 node 数组 markdown 数据结构 函数 oop post spa 指针 code 栏目 Markdown 繁體版
原文   原文链接

本文首发于 我的博客node

对于非空的线性表和线性结构，具备如下特色：数组

  • 存在惟一的一个被称做 第一个 的数据元素
  • 存在惟一的一个被称做 最后一个 的数据元素
  • 除了第一个元素之外，其余每一个数据元素都有 一个前驱
  • 除了最后一个元素之外，其余每一个数据元素都有 一个后继

线性表是最基本也是最经常使用的一种线性结构，同时它也是其余数据结构的基础。尤为是 单链表 ，这篇文章主要讲述一下单链表的结构以及如何用 C语言 实现一个单链表。markdown

单链表的实现

单链表是一种线性数据结构，咱们考察的主要是它的初始化、添加、删除、遍历等方法数据结构

初始化

单向链表是由一个个节点组成的，每个节点都包含一个数据段和指针段，数据段主要保存节点的相关信息，指针段主要保存后继节点的地址。函数

#define ERROR 0
#define TRUE 1
#define FAILURE 0
#define SUCCESS 1

typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如 SUCCESS、FAILURE等 */
typedef int ListData;/* ListData类型根据实际状况而定，这里假设为int */

// 定义节点
typedef struct Node{
    ListData data;
    struct Node *next;
}Node;

typedef struct Node *LinkList;
// 初始化单链表
Status InitList(LinkList *L) {
    *L = (LinkList)malloc(sizeof(Node));
    if (*L == NULL) return ERROR;
    (*L)->next = NULL;
    return SUCCESS;
}
复制代码

添加节点

既然链表的节点已经定义并且链表的数据结构已经初始化，接下来咱们看看如何去添加元素，这里咱们看两种状况：oop

  • 不带头节点的单链表post

如图所示，咱们要对单链表进行插入操做的时候要进行额外判断，若是要在首元节点以前添加节点，就要挪动List指针，若是其余位置则不用。spa

  • 带头节点的单链表指针

这里带头节点的插入就很简单了，全部的地方一视同仁，而不须要额外去操做链表的指针。PS：其中头节点中的信息咱们不须要关心，由于它至关于咱们默认放进去的一个节点。code

因此后续咱们使用的单链表默认添加头节点。

咱们要插入节点，就要对链表进行修改，那么咱们须要把链表的指针做为参数传入。

// location from 1...
Status InsertNode(LinkList *L,int location,ListData data) {
    // 找到须要location-1位置的节点
    Node *pre = *L;
    // 由于0位置被头节点占了，因此要从1位置开始
    int currentLocation = 1;
    while (pre && currentLocation < location) {
        pre = pre->next;
        currentLocation ++;
    }
    if (!pre || currentLocation < location) return ERROR;

    // 根据data生成一个新节点
    Node *insertNode = (Node *)malloc(sizeof(Node));
    insertNode->data = data;
    // 让新节点的next 指向 pre->next
    insertNode->next = pre->next;
    // 让前一个节点的next指向新节点
    pre->next = insertNode;
    return SUCCESS;
}
复制代码

此处逻辑跟图上一一对应，接下来咱们要验证就要打印链表每一个位置的值，咱们添加一个打印的方法，咱们只是打印链表，不必把传递指针。

// 打印方法 咱们不用修改链表 无需传指针
Status printList (LinkList L) {
    LinkList p = L->next;
    while (p) {
        printf("%d\n",p->data);
        p = p->next;
    }
    return SUCCESS;
}
复制代码

咱们验证一下：

int main(int argc, const char * argv[]) {
    LinkList L;
    Status status = InitList(&L);
    printf("s is %d\n",status);
    // 插入元素
    for (int i = 10; i >= 1; i --) {
        InsertNode(&L, 1, i);// 此处1表示，老是从头节点后面插入新节点，也就是头插法，比较简单，由于尾插法还要保留链表长度
    }
    // 打印链表
    printList(L);
    return 0;
}
复制代码

打印结果以下：

删除节点

结果如咱们所愿，链表建立以及插入读取都正常，接下来咱们看看链表是如何删除节点的：

  • 建立临时变量指向咱们即将删除的节点，一方面为了找到下一个节点，另一个方面为了释放内存，不然就内存泄漏了。
  • 直接将临时变量的上一个节点直接指向临时变量的下一个节点
  • 释放临时变量
Status DeleteNode (LinkList *L ,int location,ListData *deleteData) {
    Node *pre = *L;
    int currentLocation = 1;
    // 仍是找到location-1位置的节点
    while (pre && currentLocation < location) {
        pre = pre->next;
        currentLocation++;
    }
    if (!pre || currentLocation < location) return ERROR;
    // 建立临时变量 保存即将被删除的节点
    Node *temp = pre->next;
    if (!temp) return ERROR;
    // 前驱节点指向后驱节点
    pre->next = temp->next;
    // 将咱们删除的内容返回出去
    *deleteData = temp->data;
    // 释放内存
    free(temp);
    return SUCCESS;
}
//在main方法中添加以下代码验证
// 删除第五个节点
    ListData data;
    DeleteNode(&L, 5, &data);
    printf("删除第五个元素后的链表是 :\n");
    printList(L);
    printf("被删除的值是 %d\n",data);
复制代码

清空单链表

  1. 指针指向首元节点 注意不是头节点 ，并将该节点释放
  2. 指针偏移到下一个节点 中间节点
  3. 释放下一个节点 中间节点
  4. 指针以此类推到 尾节点
  5. 释放 尾结点
  6. 头节点指向 NULL 此处若是不处理，头节点的 next就是 野指针了
Status clearList(LinkList *L) {
    // 因为第一个是头节点，咱们从第二个节点开始删除，这个地方能够根据实际状况来
    Node *pre = (*L)->next;
    Node *nextNode;
    while (pre) {
        // 用一个临时变量保存当前要删除的节点指向的下一个节点，有点像递归的意思
        nextNode = pre->next;
        // 释放
        free(pre);
        // 将要删除的指针偏移到下一个指针
        pre = nextNode;
    }
    // 此处将头节点指向NULL ，不然就出现野指针了
    (*L)->next = NULL;
    return SUCCESS;
}
复制代码

头插法初始化

根据名字就知道了，从表头处添加节点，以前一篇文章 @synchronized底层探索 里的数据结构用的就是哈希表，内部就是经过头插法进行操做的。

Status InitFromHead(LinkList *L,int n) {
    *L = (LinkList)malloc(sizeof(Node));
    if (*L == NULL) return ERROR;
    (*L)->next = NULL;
    Node *pre = *L;
    for (int i = 1; i <= n; i ++) {
        Node *temp = (Node *)malloc(sizeof(Node));
        temp->data = i;
        temp->next = pre->next;
        pre->next = temp;
    }
    return SUCCESS;
}

// 在main中添加以下，会倒序打印30---1 就是头插法
    clearList(&L);
    InitFromHead(&L, 30);
    printf("链表是 :\n");
    printList(L);
复制代码

上述打印结果会从30倒序到1，足以证实是头插法。

尾插法初始化

尾插法就是从链表尾部依次插入数据，这样就跟咱们日常的数组的逻辑差很少了，至关于addObject,这里跟头插法不一样的是，头插法依赖头节点，此处依赖尾节点，因此咱们要用一个临时的指针指向尾结点并依次保存。

Status InitFromTail(LinkList *L,int n) {
    *L = (LinkList)malloc(sizeof(Node));
    if (*L == NULL) return ERROR;
    // 初始化的时候尾结点就是头节点
    Node *tail = *L;
    for (int i = 1; i <= n; i ++) {
        Node *temp = (Node *)malloc(sizeof(Node));
        temp->data = i;
        temp->next = NULL;
        tail->next = temp;
        // 尾节点偏移
        tail = tail->next;
    }
    return SUCCESS;
}
// 在main函数中添加以下代码
    clearList(&L);
    InitFromTail(&L, 30);
    printf("链表是 :\n");
    printList(L);
复制代码

如此尾插法，打印就会按照增序打印从1到30。

我又把方法稍微变化了一下，添加了一个从尾部添加节点的方法，这样把元素的添加放到外围，内部只关心须要从链表尾部添加什么节点便可:

// 尾部添加节点
Status AddNodeToTheTail(LinkList *L,ListData data) {
    Node *temp = *L;
    while (temp->next) {
        temp = temp->next;
    }
    if (!temp) return ERROR;
    Node *add = (Node *)malloc(sizeof(Node));
    add->data = data;
    add->next = NULL;
    temp->next = add;
    return SUCCESS;
}
// main函数中添加以下代码
    clearList(&L);
    for (int i = 0; i < 20; i ++) {
        AddNodeToTheTail(&L, i);
    }
    printf("链表是 :\n");
    printList(L);
复制代码

可是细心的观察你会发现，这个往链表尾部添加节点的方法的关键点在于先要找到尾节点，无非是经过循环直到找到一个节点的 next 是 NULL ,对于这个方法若是要初始化一个包含100个数字的的链表就要循环1+2+3+....+100 = 5050次，而用它上面那个函数添加的话只用循环100次，这个函数的时间复杂度O(n^2) 而上面那个是 O(n),因此这个方法只能针对初始化以后须要从尾部额外添加一个节点使用。

单向循环链表

看到 循环 两个字咱们就大概知道了，就是全部的节点组成一个 闭合的环，看起来应该是这样：

由于上面的单链表咱们选用了使用头节点的方式，下面我没使用不带头节点的方式实现单向循环链表。具体以代码体现，其原理跟单向链表差很少，有不清楚的结合单向链表的图链接首位便可。

初始化

这里咱们采用符合咱们正常逻辑的尾插法来实现单向循环链表的初始化，由于咱们使用不带头节点的方式，这里咱们就要对链表的首元节点进行判断：

  • 首元节点不存在，初始化并建立赋值给链表地址
  • 存在即找到当前链表的尾节点，依次插入后续节点
// 输入的方式尾插法建立单向循环链表
Status InitList(LinkList *L) {
    int number;
    Node *tail = NULL;
    while (1) {
        scanf("%d",&number);
        // 输入0结束建立
        if (number == 0) break;
        if (*L == NULL) {
            *L = (LinkList)malloc(sizeof(Node));
            if (*L == NULL)return ERROR;
            (*L)->data = number;
            (*L)->next = *L;
            tail = *L;
        } else {
            //找尾结点  方法1
            for (tail = *L; tail->next != *L; tail = tail->next);
            Node *temp = (Node *)malloc(sizeof(Node));
            if (!temp) return ERROR;
            temp->data = number;
            temp->next = *L;
            tail->next = temp;
            if (tail == NULL) return ERROR;
            //方法2
            Node *node = (Node *)malloc(sizeof(Node));
            if (!node) return ERROR;
            node->data = number;
            node->next = *L;
            tail->next = node;
            tail = tail->next;
        }
    }
    return SUCCESS;
}
复制代码

上述咱们找尾节点展现了两种方法：

  • 方法①：每次从首元节点依次循环直至找到 节点的next = 首元节点 便是当前的尾结点。

  • 方法②：用一个临时变量指向尾节点（初始化的时候尾结点指向首元节点），每次插入新节点，临时变量进行偏移继续指向尾结点。

    显然方法②的时间复杂度更小一点 O(n)，方法①每插入一个新数据都要循环遍历整个链表其时间复杂度是O(n^2) 。

插入节点

插入节点的逻辑其实跟单向链表差很少，无非就是指针的一些指向，可是这里要注意一些细节点：

  • 插入新的首元节点，就要找到尾节点，而后尾节点指向新首元节点，新首元节点指向原首元节点，链表地址指向新首元节点。

  • 其余地方同单向链表逻辑

void InsertNode(LinkList *List,int location, ListData data) {
    // 建立待插入节点
    Node *insertNode = (Node *)malloc(sizeof(Node));
    if (insertNode == NULL) return;
    insertNode->data = data;
    insertNode->next = NULL;
    if (location == 1) {
        // 找到最后一个节点即尾结点
        Node *tail = NULL;
        for (tail = *List; tail->next != *List; tail = tail->next);
        insertNode->next = tail->next;
        tail->next = insertNode;
        *List = insertNode;
    } else {
        Node *preNode = *List;
        // 找到插入位置的的前一个节点
        for (int i = 1; preNode->next != *List && i != location-1; preNode = preNode->next,i++);
        insertNode->next = preNode->next;
        preNode->next = insertNode;
    }
}
复制代码

删除节点

删除节点一样咱们也要对首元节点的处理单独拎出来：

Status DeleteNode(LinkList *List,int location,ListData *deleteData) {
    Node *temp = *List;
    if (temp == NULL) return ERROR;
    Node *target;
    if (location == 1) {// 删除首元节点
        // 找到尾节点
        for (target = *List; target->next != *List; target = target->next);
        if (target == *List) {
            target->next = NULL;
            *List = NULL;
            *deleteData = temp->data;
            free(target);
            return SUCCESS;
        }
        target->next = temp->next;
        *List = target->next;
        *deleteData = temp->data;
        free(temp);
    } else {
        // 找到待删除节点的前一个节点
        target = *List;
        int i;
        for (i = 1,target = *List; i < location-1; i ++) {
            target = target->next;
        }
        Node *deleteNode = target->next;
        target->next = deleteNode->next;
        *deleteData = deleteNode->data;
        free(deleteNode);
    }
    return SUCCESS;
}
复制代码

总结

至此咱们 单链表 、单向循环链表 的一系列方法都已实现，使用头节点、不使用头节点 的方式都有，最后对比咱们发现使用头节点让咱们对于处理链表的插入数据以及删除数据的处理会更简单，由于没有针对首节点的单独处理，针对此你们能够根据具体状况自行斟酌。其实还有不少方法和实现等着你去发掘，但愿这篇文章能将单链表的概念和实现讲清楚。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程