Bootstrap

数据结构之链表

文章目录

1.1链表的概念及结构

概念：

  1. 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的
    在这里插入图片描述
    在这里插入图片描述
  2. 实际中要实现的链表的结构非常多样，以下情况组合起来就有8种链表结构：
    1、单向、双向
    2、带头、不带头
    3、循环、非循环
    在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述
  3. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多(单链表最多缺陷)。
  4. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了。

1.2逻辑结构和物理结构

  1. 逻辑结构：逻辑结构是我们想象出来的，比如指针是没有一条线指向变量的地址的，那是我们虚构出来的，是为了方便我们的理解…
    在这里插入图片描述
  1. 物理结构：物理结构是变量实实在在在内存中如何存储的
    在这里插入图片描述

1.3单链表的优势

  1. 首先来说说动态顺序表的优劣势
    优势：连续的物理空间，方便下标随机访问
    缺陷：1.插入数据，空间不够时，需要扩容
    2.头部或中间插入和删除时，需要挪动数据，时间复杂度为O(n)
    3.可能存在一点的空间浪费，当扩容越来越大时
    4.不能按需申请和释放空间
    在这里插入图片描述
  2. 基于顺序表的劣势，所以设计出了链表，它们是相辅相成的
    因为顺序表尾插尾删的时间复杂度都是O(1)，而头插头删时间复杂度是O(n)。但是单链表的头插和头删时间复杂度是O(1)，尾插尾删是O(n)。所以说它们是相辅相成的。
  3. 单链表的优势：不需要扩容，插入新数据时直接重新开辟节点，解决了内存浪费和不能按需申请的问题，头插头删时间复杂度为O(1)
    单链表的缺陷：不能随机访问，只能往前走，尾插尾删时需要找尾节点，高速缓冲命中率低
1.4单链表的实现

单链表的实现

  1. 头文件
    开始创建的节点是这样的,每个长方形就是一个节点(结构体指针)
  2. 这里很多接口都传二级指针，是因为测试时结构体指针初始化要传"结构体指针的地址"也就是二级指针，才能改变结构体指针所指向的内容。
    ps：phead是头节点，指向(存储)第一个节点的地址
    在这里插入图片描述
#Slist.h
#ifndef SLIST_H_
#define SLIST_H_

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef int SLTDataType;

typedef struct SList
{
    SLTDataType data;   //数据域
    struct SList *next; //指针域
} SListNode;

void SListPrint(SListNode *phead);                                        //显示链表内容
void SListPushBack(SListNode **pphead, SLTDataType x);                    //尾插
void SListPushFront(SListNode **pphead, SLTDataType x);                   //头插
void SListPopBack(SListNode **pphead);                                    //尾删
void SListPopFront(SListNode **pphead);                                   //头删
SListNode *SListFind(SListNode *phead, SLTDataType x);                    //查找值为x的节点
void SListInsert(SListNode **pphead, SListNode *pos, SLTDataType x);      //在pos节点前面插入一个新的节点
void SListErase(SListNode **pphead, SListNode *pos);                      //删除pos节点前面的节点
void SListInsertAfter(SListNode **pphead, SListNode *pos, SLTDataType x); //在pos节点后面插入一个新的节点
void SListEraseAfter(SListNode **pphead, SListNode *pos);                 //删除pos后一个节点的数据
void SListDestory(SListNode **pphead);                                    //释放链表

#endif

实现函数接口：SListPrint()

void SListPrint(SListNode *phead)
{
    //链表一开始为空，无需判断
    SListNode *cur = phead;
    //遍历链表
    while (cur != NULL)
    {
        printf("%d->", cur->data);
        //每次保存下一个节点的地址
        cur = cur->next;
    }
    printf("NULL\n");
}

在这里插入图片描述

实现独立函数接口：BuySListNode() 这个函数是创建新节点

SListNode *BuySListNode(SLTDataType x)
{
    //动态开辟新节点
    SListNode *newNode = (SListNode *)malloc(sizeof(SListNode));
    //判断堆区是否已满，已满则malloc()返回NULL
    if (newNode == NULL)
    {
        printf("malloc fail!!!\n");
        exit(EXIT_FAILURE);
    }
    else
    {
        //不为空则把数据给到新节点
        newNode->data = x;
        newNode->next = NULL;
    }
    return newNode;
}

实现函数接口：SListPushBack()

void SListPushBack(SListNode **pphead, SLTDataType x)
{
    //判断二级指针是否为空
    assert(pphead);
    //创建新节点
    SListNode *newNode = BuySListNode(x);
    //节点为空时直接链接
    if (*pphead == NULL)
    {
        *pphead = newNode;
    }
    else
    {
        //不为空时：找尾->链接
        SListNode *tail = *pphead;
        while (tail->next != NULL)
        {
            tail = tail->next;
        }
        //链接
        tail->next = newNode;
    }
}
  1. 节点为空时
    在这里插入图片描述
  2. 节点不为空时
    在这里插入图片描述

实现函数接口：SListPushFront()

void SListPushFront(SListNode **pphead, SLTDataType x)
{
    //判断二指针是否为空
    assert(pphead);
    SListNode *newNode = BuySListNode(x);
    if (*pphead == NULL)
    {
        *pphead = newNode;
    }
    else
    {
        newNode->next = *pphead;
        *pphead = newNode;
    }
}
  1. 链表节点尾空时
    在这里插入图片描述
  2. 链表节点不为空时
    在这里插入图片描述

实现函数接口：SListPopBack()

oid SListPopBack(SListNode **pphead)
{
    assert(pphead);
    //如果节点为空，那么不需要删除
    if (*pphead == NULL)
    {
        //结束函数
        return;
    }
    //只有一个节点时，直接释放节点，然后置为NULL
    else if ((*pphead)->next == NULL)
    {
        free(*pphead);
        *pphead = NULL;
    }
    else
    {
        //多个节点
        SListNode *tail = *pphead;
        SListNode *prev = NULL;
        //找尾前一个节点
        while (tail->next != NULL)
        {
            prev = tail;
            tail = tail->next;
        }
        free(tail);
        prev->next = NULL;
    }
}

在这里插入图片描述

函数接口：SListPopFront()

void SListPopFront(SListNode **pphead)
{
    assert(pphead);
    if (*pphead == NULL)
    {
        return;
    }
    else
    {
        //保存头节点的next节点，否则free后会找不到
        SListNode *next = (*pphead)->next;
        free(*pphead);
        *pphead = next;
    }
}

函数接口：SListFind()

SListNode *SListFind(SListNode *phead, SLTDataType x)
{
    SListNode *cur = phead;
    while (cur != NULL)
    {
        //逐个节点判断是否有相等的data
        if (cur->data == x)
        {
            return cur;
        }
        cur = cur->next;
    }
    return NULL;
}

函数接口：SListInsert()

void SListInsert(SListNode **pphead, SListNode *pos, SLTDataType x)
{
    assert(pphead);
    assert(pos);
    SListNode *newNode = BuySListNode(x);
    if (*pphead == NULL)
    {
        return;
    }
    else if ((*pphead)->next == pos)
    {
        //复用头插函数接口
        SListPushFront(pphead, x);
    }
    else
    {
        SListNode *prev = *pphead;
        //找pos前面的节点
        while (prev->next != pos)
        {
            prev = prev->next;
        }
        //链接新节点
        newNode->next = pos;
        prev->next = newNode;
    }
}

在这里插入图片描述

函数接口：SListErase()

void SListErase(SListNode **pphead, SListNode *pos)
{
    assert(pphead);
    assert(pos);
    //节点为空即不用删除
    if (*pphead == NULL)
    {
        return;
    }
    else
    {
        SListNode *prev = *pphead;
        while (prev->next != pos)
        {
            prev = prev->next;
        }
        prev->next = pos->next;
        free(pos);
        pos = NULL;
    }
}

在这里插入图片描述

函数接口：SListInsertAfter()

void SListInsertAfter(SListNode **pphead, SListNode *pos, SLTDataType x)
{
    assert(pphead);
    assert(pos);
    if (*pphead == NULL)
    {
        return;
    }
    else
    {
        SListNode *newNode = BuySListNode(x);
        newNode->next = pos->next;
        pos->next = newNode;
    }
}

在这里插入图片描述

函数接口：SListEraseAfter()

void SListEraseAfter(SListNode **pphead, SListNode *pos)
{
    assert(pphead);
    assert(pos);
    if (pos->next == NULL)
    {
        return;
    }
    else
    {
        SListNode *next = pos->next;
        if (next)
        {
            pos->next = next->next;
            free(next);
            next = NULL;
        }
    }
}

在这里插入图片描述

最后一个接口：SListDestory()

void SListDestory(SListNode **pphead)
{
    assert(pphead);
    SListNode *cur = *pphead;
    while (cur != NULL)
    {
        //保存上一个节点地址
        SListNode *next = cur->next;
        free(cur);
        cur = next;
    }
    *pphead = NULL;
}
1.5完整代码
#Slist.h
#ifndef SLIST_H_
#define SLIST_H_

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef int SLTDataType;

typedef struct SList
{
    SLTDataType data;   //数据域
    struct SList *next; //指针域
} SListNode;

void SListPrint(SListNode *phead);                                        //显示链表内容
void SListPushBack(SListNode **pphead, SLTDataType x);                    //尾插
void SListPushFront(SListNode **pphead, SLTDataType x);                   //头插
void SListPopBack(SListNode **pphead);                                    //尾删
void SListPopFront(SListNode **pphead);                                   //头删
SListNode *SListFind(SListNode *phead, SLTDataType x);                    //查找节点
void SListInsert(SListNode **pphead, SListNode *pos, SLTDataType x);      //在pos节点前面插入一个新的节点
void SListErase(SListNode **pphead, SListNode *pos);                      //删除pos节点前面的节点
void SListInsertAfter(SListNode **pphead, SListNode *pos, SLTDataType x); //在pos节点后面插入一个新的节点
void SListEraseAfter(SListNode **pphead, SListNode *pos);                 //删除pos后一个节点的数据
void SListDestory(SListNode **pphead);                                    //释放链表
#endif

#Slist.c
#include "SList.h"

void SListPrint(SListNode *phead)
{
    //链表一开始为空，无need判断
    SListNode *cur = phead;
    while (cur != NULL)
    {
        printf("%d->", cur->data);
        cur = cur->next;
    }
    printf("NULL\n");
}

SListNode *BuySListNode(SLTDataType x)
{
    SListNode *newNode = (SListNode *)malloc(sizeof(SListNode));
    if (newNode == NULL)
    {
        printf("malloc fail!!!\n");
        exit(EXIT_FAILURE);
    }
    else
    {
        newNode->data = x;
        newNode->next = NULL;
    }
    return newNode;
}

void SListPushBack(SListNode **pphead, SLTDataType x)
{
    //判断二级指针是否为空
    assert(pphead);
    //创建新节点
    SListNode *newNode = BuySListNode(x);
    //节点为空时直接链接
    if (*pphead == NULL)
    {
        *pphead = newNode;
    }
    else
    {
        //不为空时：找尾->链接
        SListNode *tail = *pphead;
        while (tail->next != NULL)
        {
            tail = tail->next;
        }
        //链接
        tail->next = newNode;
    }
}

void SListPushFront(SListNode **pphead, SLTDataType x)
{
    //判断二指针是否为空
    assert(pphead);
    SListNode *newNode = BuySListNode(x);
    if (*pphead == NULL)
    {
        *pphead = newNode;
    }
    else
    {
        newNode->next = *pphead;
        *pphead = newNode;
    }
}

void SListPopBack(SListNode **pphead)
{
    assert(pphead);
    //如果节点为空，那么不需要删除
    if (*pphead == NULL)
    {
        return;
    }
    else if ((*pphead)->next == NULL)
    {
        free(*pphead);
        *pphead = NULL;
    }
    else
    {
        SListNode *tail = *pphead;
        SListNode *prev = NULL;
        //找尾上一个节点
        while (tail->next != NULL)
        {
            prev = tail;
            tail = tail->next;
        }
        free(tail);
        prev->next = NULL;
    }
}

void SListPopFront(SListNode **pphead)
{
    assert(pphead);
    if (*pphead == NULL)
    {
        return;
    }
    else
    {
        SListNode *next = (*pphead)->next;
        free(*pphead);
        *pphead = next;
    }
}

SListNode *SListFind(SListNode *phead, SLTDataType x)
{
    SListNode *cur = phead;
    while (cur != NULL)
    {
        if (cur->data == x)
        {
            return cur;
        }
        cur = cur->next;
    }
    return NULL;
}

void SListInsert(SListNode **pphead, SListNode *pos, SLTDataType x)
{
    assert(pphead);
    assert(pos);
    SListNode *newNode = BuySListNode(x);
    if (*pphead == NULL)
    {
        return;
    }
    else if ((*pphead)->next == pos)
    {
        SListPushFront(pphead, x);
    }
    else
    {
        SListNode *prev = *pphead;
        while (prev->next != pos)
        {
            prev = prev->next;
        }
        newNode->next = pos;
        prev->next = newNode;
    }
}

void SListErase(SListNode **pphead, SListNode *pos)
{
    assert(pphead);
    assert(pos);
    //节点为空即不用删除
    if (*pphead == NULL)
    {
        return;
    }
    else
    {
        SListNode *prev = *pphead;
        while (prev->next != pos)
        {
            prev = prev->next;
        }
        prev->next = pos->next;
        free(pos);
        pos = NULL;
    }
}

void SListInsertAfter(SListNode **pphead, SListNode *pos, SLTDataType x)
{
    assert(pphead);
    assert(pos);
    if (*pphead == NULL)
    {
        return;
    }
    else
    {
        SListNode *newNode = BuySListNode(x);
        newNode->next = pos->next;
        pos->next = newNode;
    }
}

void SListEraseAfter(SListNode **pphead, SListNode *pos)
{
    assert(pphead);
    assert(pos);
    if (pos->next == NULL)
    {
        return;
    }
    else
    {
        SListNode *next = pos->next;
        if (next)
        {
            pos->next = next->next;
            free(next);
            next = NULL;
        }
    }
}

void SListDestory(SListNode **pphead)
{
    assert(pphead);
    SListNode *cur = *pphead;
    while (cur != NULL)
    {
        //保存上一个节点地址
        SListNode *next = cur->next;
        free(cur);
        cur = next;
    }
    *pphead = NULL;
}

#Test.c
#include "Slist.h"
int main()
{
    //尾插
    SListNode *sl = NULL;
    SListPushBack(&sl, 1);
    SListPushBack(&sl, 2);
    SListPushBack(&sl, 3);
    SListPushBack(&sl, 4);
    SListPushBack(&sl, 5);
    SListPrint(sl);

    //头插
    SListPushFront(&sl, 0);
    SListPushFront(&sl, -1);
    SListPushFront(&sl, -2);
    SListPrint(sl);

    //尾删
    SListPopBack(&sl);
    SListPopBack(&sl);
    SListPrint(sl);

    //头删
    SListPopFront(&sl);
    SListPopFront(&sl);
    SListPopFront(&sl);
    SListPrint(sl);

    //查找
    SListNode *pos = SListFind(sl, 3);
    if (pos == NULL)
    {
        printf("没找到...\n");
    }
    else
    {
        printf("找到了: %p\n", pos);
    }

    //随机插入
    SListInsert(&sl, pos, 100);
    SListPrint(sl);

    //随机删除
    SListErase(&sl, pos);
    SListPrint(sl);

    // pos位置后面插入新节点
    SListNode *pos2 = SListFind(sl, 1);
    SListInsertAfter(&sl, pos2, 200);
    SListPrint(sl);

    //删除pos后一位的节点
    SListEraseAfter(&sl, pos2);
    SListPrint(sl);

    //释放链表
    SListDestory(&sl);
    SListPrint(sl);
    return 0;
}

单链表相关知识已经干完了，如有错误请大家指出，感谢！！！

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
YOLO V8-Segment 【单张图片推理】推理详解及部署实现
深度剖析图像处理—边缘检测
【北京迅为】《i.MX8MM嵌入式Linux开发指南》-第三篇 嵌入式Linux驱动开发篇-第五十七章 Linux中断实验
Stable Diffusion系列课程二：ControlNet
opencv 实现图像的旋转
Axure交互效果--显示和隐藏
（10）深入理解pandas的核心数据结构：DataFrame高效数据清洗技巧
24年深圳杯&东三省数学建模联赛赛题浅析
SSM源码分析之Spring03-IOC实现原理
Asp.net-UpdatePanel异步刷新后JS失效的解决方法
;