图解无头单向非循环链表【数据结构】

最新推荐文章于 2023-01-06 20:33:45 发布
最新推荐文章于 2023-01-06 20:33:45 发布
阅读量1.6k 收藏 10
点赞数 15
分类专栏： 数据结构与算法 文章标签： 数据结构 链表 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a2076188013/article/details/123470353
版权

0.前言🐑

🌵🌵
大家好啊，2天不见，甚是想念，呜呜网课要结束了，今天就要开始线下上课了，ε=(´ο｀*)))唉，美好生活不复返了。话不多说，今天开始回顾链表中的无头单向非循环链表。
在这里插入图片描述

🌵🌵
在这里插入图片描述

本节重点：

  1. 链表&顺序表对比
  2. 单链表各个接口的实现

1.链表 🐱

链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。

关于顺序表的不足：

  1. 扩容有性能消耗且有可能存在空间浪费。
    扩容时，如果扩小了，大量插入数据时，频繁扩容，性能消耗较大；如果扩大了，又会存在空间浪费。
    例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。
  2. 头部或中间插入数据时，需要挪动数据，降低效率

链表优点

  1. 按需申请内存,不存在空间浪费
  2. 任意位置O(1)时间插入删除数据

链表缺点

  1. 不支持下标的随机访问

总结：顺序表和链表相辅相成,使用要看具体应用场景

2.单链表🐶

image-20220308205422839

struct SListNode
{
	int data;
	struct SListNode* next;
};
void Test()
{
	struct SListNode* node1 = (struct SListNode*)malloc(sizeof(struct SListNode));
	struct SListNode* node2 = (struct SListNode*)malloc(sizeof(struct SListNode));
	struct SListNode* node3 = (struct SListNode*)malloc(sizeof(struct SListNode));
	struct SListNode* node4 = (struct SListNode*)malloc(sizeof(struct SListNode));

	printf("%p\n", node1);
	printf("%p\n", node2);
	printf("%p\n", node3);
	printf("%p\n", node4);
}
//node1 等其实只是结点地址

image-20220206204249510

地址均不连续，堆上使用的空间地址由高到低

逻辑结构&物理结构

链表逻辑结构线性，但物理结构是非线性的。

pList(头结点)是指针变量，存的是第一个节点的地址

当我们看到链表的实现都有箭头指向下一个节点，但实际上是没有箭头的，只不过是把下一个节点的地址存到了当前节点的next的值

image-20220312152236359

链表组合

  1. 单向双向

    image-20220312152933377

  2. 带头不带头
    image-20220312152947221

  3. 循环非循环
    image-20220312153002206

最多有8种组合

虽然有这么的组合，但实际中最常用的只有2种：
image-20220312153039673

  1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。

  2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了。

3.单链表实现🐦

定义

typedef int SListDataType;
typedef struct SListNode // Single Link List
{
    SListDataType data;
    struct SListNode *next; //存储下一个节点的地址
} SListNode;

创建节点

SListNode *CreateNewNode(SListDataType x)
{
    SListNode *newNode = (SListNode *)malloc(sizeof(SListNode));
    if (newNode == NULL)
    {
        printf("malloc newNode fail\n");
        exit(-1);
    }
    else
    {
        newNode->data = x;
        newNode->next = NULL;
    }
    return newNode;
}

打印

void SListPrint(SListNode* pList)
{
    //不需要assert(plist)
	SListNode* cur = pList;
	while (cur != NULL)
    {
		printf("%d->", cur->data); 
		cur = cur->next;//cur->next里面存的就是下一个结点的地址
	}
	printf("NULL\n");
}

提问：这里需要用断言吗？为什么不需要？

记住：一定不能为空的才需要用断言，此处既是链表为空，那我们就什么也不打印就好了啊，断言太暴力了。

提问：这里需要传二级指针吗？为什么？

可以传，但没必要，Print只是打印数据，不会修改数据，因此不需要传二级指针。

查找

查找不需要修改，也就不用传址调用，也就不需要传二级指针。

但如果传了也没问题。

//单链表查找
SListNode *SListFind(SListNode *plist, SListDataType x)
{
    SListNode *cur = plist;
    // while(cur != NULL)
    while (cur)
    {
        if (cur->data == x)
        {
            return cur;
            //查找兼具修改的作用
        }
        cur = cur->next;
    }
    return NULL;
}

效果展示：

image-20220313102858303

尾删

  1. 没有节点，无法删除，直接return

  2. 一个节点，直接free掉并置空即可，但注意需要对实参进行操作，所以需要传实参地址，也就是传二级指针
    注意：free 之后要置空，因为free掉的是指针指向的内容，但指针还是指向那块空间的，因此要把指针置空

  3. 多个节点

    多个节点时，删除尾节点需要把prev->next置为NULL 再把tail free掉。

    image-20220312184332156

如果用多个节点的代码去针对单个节点的情况，会产生解引用空指针的情况。

void SListPopBack(SListNode** ppList)
{
    //1.没有节点，无法删除，直接return
    if(*ppList == NULL)
    {
        return;
    }
    //2.单个节点
    else if((*ppList)->next == NULL)
    {
        free(*ppList);
        *ppList = NULL;
    }
    //3.多个节点
    else
    {
        SListNode* prev = NULL;
        SListNode* tail = *ppList;
        while (tail->next != NULL)
        {
            prev = tail;
            tail = tail->next;
        }
        free(tail);
        tail = NULL;
        prev->next = NULL;//尾删时要将最后一个结点的上一个结点的next置为NULL才行
    }
}

效果展示：

image-20220312184604987

传引用：

void SListPopBack(SListNode*& pList)
{
    //1.没有节点，无法删除，直接return
    if(pList == NULL)
    {
        return;
    }
    //2.单个节点
    else if((pList)->next == NULL)
    {
        free(pList);
        pList = NULL;
    }
    //3.多个节点
    else
    {
        SListNode* prev = NULL;
        SListNode* tail = pList;
        while (tail->next != NULL)
        {
            prev = tail;
            tail = tail->next;
        }
        free(tail);
        tail = NULL;
        prev->next = NULL;//尾删时要将最后一个结点的上一个结点的next置为NULL才行
    }
}

效果展示：

image-20220312184806531

头删

  1. 没有节点：
    直接return

  2. 单个节点：

    image-20220313101343552

  3. 多个节点：
    image-20220313101316249

void SListPopFront(SListNode **ppList)
{
    // 1.没有节点
    if (*ppList == NULL)
    {
        return;
    }
    // 2.单个节点
    // 3.多个节点
    //先写多个节点的情况，再去比较单个节点能否适用，发现恰好可以匹配。
    //保存plist->next，如果直接free plist就找不到后面的空间了
    SListNode *next = (*ppList)->next;
    free(*ppList);//这里只是释放了*ppList指向的那块空间内容，但*ppList还是指向那块空间的。
    *ppList = next;
}

效果展示：

image-20220313101546985

传引用：

void SListPopFront(SListNode *&pList)
{
    // 1.没有节点
    if (pList == NULL)
    {
        return;
    }
    // 2.单个节点
    // 3.多个节点
    //先写多个节点的情况，再去比较单个节点能否适用，发现恰好可以匹配。
    //保存plist->next，如果直接free plist就找不到后面的空间了
    SListNode *next = pList->next;
    free(pList); //这里只是释放了*ppList指向的那块空间内容，但*ppList还是指向那块空间的。
    pList = next;
}

效果展示：

image-20220313101838150

头插

image-20220312171831564

void SListPushFront(SListNode *&pList, SListDataType x)
{
    //即使传进来的是NULL也能解决
    SListNode *newNode = CreateNewNode(x);
    newNode->next = pList; //pList指向的就是第一个节点，其实存的也就是第一个节点的地址
    pList = newNode;
}

如果头插时链表为空，也是可以的。
pList == NULL，newNode->next 指向NULL，然后再让pList指向newNode，完美解决。

image-20220312172747038

传引用的写法：

void SListPushFront(SListNode *&plist, SListDataType x)
{
    //即使传进来的是NULL也能解决
    SListNode *newNode = CreateNewNode(x);
    newNode->next = plist; //*pplist 其实就是 plist
    plist = newNode;
}

image-20220312175413772

尾插

  1. 链表本身为空，直接插入就好。
  2. 链表不为空，遍历找到尾。
    image-20220312171121540
  3. 注意需要用二级指针，因为在判断空链表的情况时，需要对实参sList进行操作，才需要传址调用。
    *ppList 其实就是 pList
void SListPushBack(SListNode **ppList, SListDataType x)
{
    //同样不需要断言空，因为本来就有可能传空链表
    SListNode* newNode = CreateNewNode(x);
    //1.空链表
    if(*ppList == NULL)
    {
        *ppList = newNode;//也就是把newNode的地址覆盖掉sList原来的NULL地址
        //要修改sList必须传址调用
    }
    //2.正常链表，去找尾
    else
    {
        SListNode* tail = *ppList;//不能直接修改plist,plist一改就找不到链表了
        while (tail->next != NULL)
        {
            tail = tail->next;
        }
        //出来时tail->next 指向的是NULL
        tail->next = newNode;
    }
}

带上头节点可以不用传址调用,因为不需要修改plist

演示效果：
image-20220312163431160

如果不想用二级指针，也可以传引用。

void SListPushBack(SListNode *&pList, SListDataType x)
{
    //同样不需要断言空，因为本来就有可能传空链表
    SListNode* newNode = CreateNewNode(x);
    //1.空链表
    if(pList == NULL)
    {
        pList = newNode;//也就是把newNode的地址覆盖掉pList原来的NULL地址
        //传进来空链表,要修改plist必须传址调用
    }
    //2.正常链表，去找尾
    else
    {
        SListNode* tail = pList;//不能直接修改plist，plist一改就找不到链表了
        while (tail->next != NULL)
        {
            tail = tail->next;
        }
        //出来时tail->next 指向的是NULL
        tail->next = newNode;
    }
}

效果展示：

image-20220312164704049

pos后插入

2种插入方式：

image-20220313103619697

注意要操作顺序，如果先让pos-> next 指向了newNode 之后就找不到pos的下一个了。

第二种：

将pos的下一个临时保存起来就行，这样顺序就没关了。

//在pos后面插入
void SListInserAfter(SListNode *pos, SListDataType x)
{
    assert(pos);
    SListNode *newNode = CreateNewNode(x);
    //注意顺序不要反了
    newNode->next = pos->next;
    pos->next = newNode;
}

//或者临时保存 pos->next
//在pos后面插入
void SListInserAfter(SListNode *pos, SListDataType x)
{
    assert(pos);
    SListNode *newNode = CreateNewNode(x);
    SListNode* next = pos->next;//这样就无需关心顺序问题了
    pos->next = newNode;
    newNode->next = next;
}

效果展示：

image-20220313104333843

pos前插入

除了要让 newNode 指向pos，还需pos之前的节点指向 newNode ，因此需要找到pos的前一个位置，只能从头开始遍历，非常麻烦且不实用。

  1. 多个节点的情况：
    image-20220313105407537
  2. 如果pos是第一个节点呢？
    如果还让prev指向newNode，那就发生了空指针解引用的问题。可以直接用 if 过滤掉这种情况。
    pos是第一个节点的，其实就相当于是头插，但是头插的话，需要改变实参的sList，要让传进来的pList指向newNode，因此还需要传二级指针或者传引用。
    image-20220313105638396
void SListInserBefore(SListNode** ppList, SListNode* pos, SListDataType x)
{
    assert(pos);
    SListNode* newNode = CreateNewNode(x);
    if(*ppList == pos)//相当于头插
    {
        newNode->next = pos;
        *ppList = newNode;
    }
    else
    {
        SListNode* prev = NULL;
        SListNode* cur = *ppList;
        while (cur != pos)
        {
            prev = cur;
            cur = cur->next;
        }
        prev->next = newNode;
        newNode->next = cur;
    }
}

效果展示：

image-20220313112442381

传引用的写法：

void SListInserBefore(SListNode *&pList, SListNode *pos, SListDataType x)
{
    assert(pos);
    SListNode *newNode = CreateNewNode(x);
    if (pList == pos) //相当于头插
    {
        newNode->next = pos;
        pList = newNode;
    }
    else
    {
        SListNode *prev = NULL;
        SListNode *cur = pList;
        while (cur != pos)
        {
            prev = cur;
            cur = cur->next;
        }
        prev->next = newNode;
        newNode->next = cur;
    }
}

效果展示：

image-20220313113716275

提问：

在一个无头(不告诉头指针)单链表的某一个节点前面插入一个值x,怎么插?

这里没告诉头，就不能从头开始遍历去找pos的前一个了。
其实我们可以先后插，然后交换data

image-20220207001858221

pos后擦除

  1. 只有一个节点：
    没有可删除的，直接return

  2. 多个节点
    image-20220313113327733

    先记录pos的下一个节点，如何让pos指向它的下一个节点的下一个节点，再free 之前记录的pos的下一个节点并置空。

  3. 后一个为空时，同样适用。

void SListEraseAfter(SListNode *pos)
{
    assert(pos);
    //只有一个节点的情况
    if (pos->next == NULL)
    {
        return;
    }
    else
    {
        SListNode *next = pos->next;
        pos->next = next->next;
        free(next);
        next = NULL;
    }
}

pos擦除

  1. 多个节点，需要找pos位置的前一个节点prev，然后free pos，让prev指向pos后面的那个
    image-20220313124625229

  2. pos指向的是第一个节点，其实就相当于头删，需要改变实参，因此传二级指针或传引用。需要先保存pList的下一个节点，然后free pos，再让pList指向next

    image-20220313124804700

void SListEraseCur(SListNode** ppList, SListNode* pos)
{
    //pos指向第一个节点，相当于头删
    if(pos == *ppList)
    {
        SListNode* next = (*ppList)->next;
        free(*ppList);
        *ppList = next;
    }
    else
    {
        SListNode* prev = NULL;
        SListNode* cur = *ppList;
        while (cur != pos)
        {
            prev = cur;
            cur = cur->next;
        }
        //出来时cur指向的pos，prev指向pos前一个
        prev->next = cur->next;
        free(cur);
        cur = NULL;
    }
}

效果展示：

image-20220313130036329

void SListEraseCur(SListNode *&pList, SListNode *pos)
{
    // pos指向第一个节点，相当于头删
    if (pos == pList)
    {
        SListNode *next = pList->next;
        free(pList);
        pList = next;
    }
    else
    {
        SListNode *prev = NULL;
        SListNode *cur = pList;
        while (cur != pos)
        {
            prev = cur;
            cur = cur->next;
        }
        //出来时cur指向的pos，prev指向pos前一个
        prev->next = cur->next;
        free(cur);
        cur = NULL;
    }
}

效果展示：

image-20220313130356764

4.源代码：🐘

SLinkList.h

#pragma once
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>

typedef int SListDataType;
typedef struct SListNode // Single Link List
{
    SListDataType data;
    struct SListNode *next; //存储下一个节点的地址
} SListNode;

void SListPrint(SListNode *pList);
SListNode *CreateNewNode(SListDataType x);
// void SListPushBack(SListNode **ppList, SListDataType x);
void SListPushBack(SListNode *&pList, SListDataType x);
void SListPushFront(SListNode *&pList, SListDataType x);
// void SListPushFront(SListNode** pplist, SListDataType x);

// void SListPopBack(SListNode** ppList);
void SListPopBack(SListNode *&pList);

// void SListPopFront(SListNode **ppList);
void SListPopFront(SListNode *&pList);

SListNode *SListFind(SListNode *plist, SListDataType x);

void SListInserAfter(SListNode *pos, SListDataType x);

// void SListInserBefore(SListNode** ppList, SListNode* pos, SListDataType x);
void SListInserBefore(SListNode *&pList, SListNode *pos, SListDataType x);

void SListEraseAfter(SListNode *pos);

void SListEraseCur(SListNode *&pList, SListNode *pos);
// void SListEraseCur(SListNode** ppList, SListNode* pos);

SLinkList.cpp

#include "SLinkList.h"
void SListPrint(SListNode *pList)
{
    //不需要assert(plist)
    SListNode *cur = pList;
    while (cur != NULL)
    {
        printf("%d->", cur->data);
        cur = cur->next; // cur->next里面存的就是下一个结点的地址
    }
    printf("NULL\n");
}
SListNode *CreateNewNode(SListDataType x)
{
    SListNode *newNode = (SListNode *)malloc(sizeof(SListNode));
    if (newNode == NULL)
    {
        printf("malloc newNode fail\n");
        exit(-1);
    }
    else
    {
        newNode->data = x;
        newNode->next = NULL;
    }
    return newNode;
}
// void SListPushBack(SListNode **ppList, SListDataType x)
// {
//     //同样不需要断言空，因为本来就有可能传空链表
//     SListNode* newNode = CreateNewNode(x);
//     //1.空链表
//     if(*ppList == NULL)
//     {
//         *ppList = newNode;//也就是把newNode的地址覆盖掉pList原来的NULL地址
//         //传进来空链表,要修改plist必须传址调用
//     }
//     //2.正常链表，去找尾
//     else
//     {
//         SListNode* tail = *ppList;//不能直接修改plist，plist一改就找不到链表了
//         while (tail->next != NULL)
//         {
//             tail = tail->next;
//         }
//         //出来时tail->next 指向的是NULL
//         tail->next = newNode;
//     }
// }

void SListPushBack(SListNode *&pList, SListDataType x)
{
    //同样不需要断言空，因为本来就有可能传空链表
    SListNode *newNode = CreateNewNode(x);
    // 1.空链表
    if (pList == NULL)
    {
        pList = newNode; //也就是把newNode的地址覆盖掉pList原来的NULL地址
        //传进来空链表,要修改plist必须传址调用
    }
    // 2.正常链表，去找尾
    else
    {
        SListNode *tail = pList; //不能直接修改plist，plist一改就找不到链表了
        while (tail->next != NULL)
        {
            tail = tail->next;
        }
        //出来时tail->next 指向的是NULL
        tail->next = newNode;
    }
}

void SListPushFront(SListNode *&pList, SListDataType x)
{
    //即使传进来的是NULL也能解决
    SListNode *newNode = CreateNewNode(x);
    newNode->next = pList; // pList指向的就是第一个节点，其实存的也就是第一个节点的地址
    pList = newNode;
}

// void SListPopBack(SListNode** ppList)
// {
//     //1.没有节点，无法删除，直接return
//     if(*ppList == NULL)
//     {
//         return;
//     }
//     //2.单个节点
//     else if((*ppList)->next == NULL)
//     {
//         free(*ppList);
//         *ppList = NULL;
//     }
//     //3.多个节点
//     else
//     {
//         SListNode* prev = NULL;
//         SListNode* tail = *ppList;
//         while (tail->next != NULL)
//         {
//             prev = tail;
//             tail = tail->next;
//         }
//         free(tail);
//         tail = NULL;
//         prev->next = NULL;//尾删时要将最后一个结点的上一个结点的next置为NULL才行
//     }
// }

void SListPopBack(SListNode *&pList)
{
    // 1.没有节点，无法删除，直接return
    if (pList == NULL)
    {
        return;
    }
    // 2.单个节点
    else if ((pList)->next == NULL)
    {
        free(pList);
        pList = NULL;
    }
    // 3.多个节点
    else
    {
        SListNode *prev = NULL;
        SListNode *tail = pList;
        while (tail->next != NULL)
        {
            prev = tail;
            tail = tail->next;
        }
        free(tail);
        tail = NULL;
        prev->next = NULL; //尾删时要将最后一个结点的上一个结点的next置为NULL才行
    }
}
// void SListPopFront(SListNode **ppList)
// {
//     // 1.没有节点
//     if (*ppList == NULL)
//     {
//         return;
//     }
//     // 2.单个节点
//     // 3.多个节点
//     //先写多个节点的情况，再去比较单个节点能否适用，发现恰好可以匹配。
//     //保存plist->next，如果直接free plist就找不到后面的空间了
//     SListNode *next = (*ppList)->next;
//     free(*ppList);//这里只是释放了*ppList指向的那块空间内容，但*ppList还是指向那块空间的。
//     *ppList = next;
// }

void SListPopFront(SListNode *&pList)
{
    // 1.没有节点
    if (pList == NULL)
    {
        return;
    }
    // 2.单个节点
    // 3.多个节点
    //先写多个节点的情况，再去比较单个节点能否适用，发现恰好可以匹配。
    //保存plist->next，如果直接free plist就找不到后面的空间了
    SListNode *next = pList->next;
    free(pList); //这里只是释放了*ppList指向的那块空间内容，但*ppList还是指向那块空间的。
    pList = next;
}

//单链表查找
SListNode *SListFind(SListNode *plist, SListDataType x)
{
    SListNode *cur = plist;
    // while(cur != NULL)
    while (cur)
    {
        if (cur->data == x)
        {
            return cur;
            //查找兼具修改的作用
        }
        cur = cur->next;
    }
    return NULL;
}

// //在pos后面插入
// void SListInserAfter(SListNode *pos, SListDataType x)
// {
//     assert(pos);
//     SListNode *newNode = CreateNewNode(x);
//     //注意顺序不要反了
//     newNode->next = pos->next;
//     pos->next = newNode;
// }

//或者临时保存 pos->next
//在pos后面插入
void SListInserAfter(SListNode *pos, SListDataType x)
{
    assert(pos);
    SListNode *newNode = CreateNewNode(x);
    SListNode *next = pos->next; //这样就无需关心顺序问题了
    pos->next = newNode;
    newNode->next = next;
}

// void SListInserBefore(SListNode** ppList, SListNode* pos, SListDataType x)
// {
//     assert(pos);
//     SListNode* newNode = CreateNewNode(x);
//     if(*ppList == pos)//相当于头插
//     {
//         newNode->next = pos;
//         *ppList = newNode;
//     }
//     else
//     {
//         SListNode* prev = NULL;
//         SListNode* cur = *ppList;
//         while (cur != pos)
//         {
//             prev = cur;
//             cur = cur->next;
//         }
//         prev->next = newNode;
//         newNode->next = cur;
//     }
// }

void SListInserBefore(SListNode *&pList, SListNode *pos, SListDataType x)
{
    assert(pos);
    SListNode *newNode = CreateNewNode(x);
    if (pList == pos) //相当于头插
    {
        newNode->next = pos;
        pList = newNode;
    }
    else
    {
        SListNode *prev = NULL;
        SListNode *cur = pList;
        while (cur != pos)
        {
            prev = cur;
            cur = cur->next;
        }
        prev->next = newNode;
        newNode->next = cur;
    }
}

void SListEraseAfter(SListNode *pos)
{
    assert(pos);
    //只有一个节点的情况
    if (pos->next == NULL)
    {
        return;
    }
    else
    {
        SListNode *next = pos->next;
        pos->next = next->next;
        free(next);
        next = NULL;
    }
}

// void SListEraseCur(SListNode** ppList, SListNode* pos)
// {
//     //pos指向第一个节点，相当于头删
//     if(pos == *ppList)
//     {
//         SListNode* next = (*ppList)->next;
//         free(*ppList);
//         *ppList = next;
//     }
//     else
//     {
//         SListNode* prev = NULL;
//         SListNode* cur = *ppList;
//         while (cur != pos)
//         {
//             prev = cur;
//             cur = cur->next;
//         }
//         //出来时cur指向的pos，prev指向pos前一个
//         prev->next = cur->next;
//         free(cur);
//         cur = NULL;
//     }
// }

void SListEraseCur(SListNode *&pList, SListNode *pos)
{
    // pos指向第一个节点，相当于头删
    if (pos == pList)
    {
        SListNode *next = pList->next;
        free(pList);
        pList = next;
    }
    else
    {
        SListNode *prev = NULL;
        SListNode *cur = pList;
        while (cur != pos)
        {
            prev = cur;
            cur = cur->next;
        }
        //出来时cur指向的pos，prev指向pos前一个
        prev->next = cur->next;
        free(cur);
        cur = NULL;
    }
}

Test.cpp

#include "SLinkList.h"
void Test1()
{
    SListNode *sList = NULL;
    SListPrint(sList); // NULL
}
void Test2()
{
    SListNode *sList = NULL; //空链表
    // SListPushBack(&sList, 1);
    // SListPushBack(&sList, 2);
    // SListPushBack(&sList, 3);
    SListPushBack(sList, 1);
    SListPushBack(sList, 2);
    SListPushBack(sList, 3);
    SListPrint(sList);

    // SListPushFront(&sList, 2);
    // SListPushFront(&sList, 3);
    SListPushFront(sList, 1);
    SListPushFront(sList, 2);
    SListPushFront(sList, 3);
    SListPrint(sList);
}
void Test3()
{
    SListNode *sList = NULL; //空链表
    SListPushBack(sList, 1);
    SListPushBack(sList, 2);
    SListPushBack(sList, 3);
    // SListPrint(sList);
    // SListPopBack(&sList);
    // SListPrint(sList);
    SListPrint(sList);
    SListPopBack(sList);
    SListPrint(sList);
    // SListPopFront(&sList);
    SListPopFront(sList);
    SListPrint(sList);
}
void Test4()
{
    SListNode *sList = NULL; //空链表
    SListPushBack(sList, 1);
    SListPushBack(sList, 2);
    SListPushBack(sList, 3);
    SListPrint(sList);
    SListPopFront(sList);
    SListPrint(sList);
    SListPopFront(sList);
    SListPrint(sList);
    SListPopFront(sList);
    SListPrint(sList);
    SListPopFront(sList);
    SListPrint(sList);
}
void Test5()
{
    SListNode *sList = NULL; //空链表
    SListPushBack(sList, 1);
    SListPushBack(sList, 2);
    SListPushBack(sList, 3);
    SListPrint(sList);
    SListNode *pos = SListFind(sList, 3);
    if (pos)
    {
        pos->data = 30;
        printf("找到了并修改为30\n");
    }
    else
    {
        printf("找不到\n");
    }
    SListPrint(sList);
}
void Test6()
{
    SListNode *sList = NULL; //空链表
    SListPushBack(sList, 1);
    SListPushBack(sList, 2);
    SListPushBack(sList, 3);
    SListPrint(sList);
    SListNode *pos = SListFind(sList, 2);
    SListInserAfter(pos, 10);
    SListPrint(sList);

    // SListInserBefore(&sList, pos, 20);
    // SListPrint(sList);
    // SListNode *pos2 = SListFind(sList, 1);
    // SListInserBefore(&sList, pos2, 100);
    // SListPrint(sList);

    SListInserBefore(sList, pos, 20);
    SListPrint(sList);
    SListNode *pos2 = SListFind(sList, 1);
    SListInserBefore(sList, pos2, 1000);
    SListPrint(sList);

    SListNode *pos3 = SListFind(sList, 1000);
    SListEraseAfter(pos3);
    SListPrint(sList);
}

void Test7()
{
    SListNode *sList = NULL; //空链表
    SListPushBack(sList, 1);
    SListPushBack(sList, 2);
    SListPushBack(sList, 3);
    SListPrint(sList);
    // SListNode *pos1 = SListFind(sList, 2);
    // SListEraseCur(&sList, pos1);
    // SListPrint(sList);
    // SListNode *pos2 = SListFind(sList, 1);
    // SListEraseCur(&sList, pos2);
    // SListPrint(sList);
    SListNode *pos1 = SListFind(sList, 2);
    SListEraseCur(sList, pos1);
    SListPrint(sList);
    SListNode *pos2 = SListFind(sList, 3);
    SListEraseCur(sList, pos2);
    SListPrint(sList);
}
int main(int argc, char const *argv[])
{
    Test7();
    system("pause");
    return 0;
}

5.尾声🐜

🌵🌵
今天的单链表就回顾到这里啦。
写文不易，如果有帮助烦请点个赞~ 👍👍👍

🌹🌹Thanks♪(･ω･)ﾉ🌹🌹

👀👀由于笔者水平有限，在今后的博文中难免会出现错误之处，本人非常希望您如果发现错误，恳请留言批评斧正，希望和大家一起学习，一起进步ヽ(￣ω￣(￣ω￣〃)ゝ，期待您的留言评论。
附GitHub仓库链接
在这里插入图片描述

TauCeti0207
关注
专栏目录
链表（一）——无头单向非循环链表实现
C、Java知识分享
08-11 403
初始链表
图解无头单向非循环链表和带头双向循环链表
zhaocx111222333的博客
01-17 806
图解无头单向非循环链表和带头双向循环链表单链表(单向不带头)数据节点和头结点新增节点函数和初始化基本操作1.尾插2.尾删3.头插4.头删5.任意位置新增节点6.任意位置删除7.寻找数据8.销毁链表带头双向循环链表数据节点和头节点新增节点函数和初始化基本操作(删除和增加)1.尾插2.尾删3.头插4.头删5.在任意位置删除6.在任意位置增加 链表是一种重要的数据结构,其概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链 接次序实现的 。 这里介绍两种链表: 无头单
链表详解（一）—— 无头单向非循环链表
2021dragon的博客
04-08 3052
文章目录链表介绍初始化链表打印单链表增加数据单链表的头插单链表的尾插删除数据单链表的头删单链表的尾删 链表介绍 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 实际中，链表的结构多种多样： 1、带头，不带头。 2、单向，双向。 3、循环，非循环。 通过以上的这些情况组合起来，就有八种
无头单向非循环链表（C语言实现）
qq_61939403的博客
03-20 3150
文章目录：链表引入链表介绍三级目录 链表引入 问：上次我们看了顺序表，那么顺序表有些什么优缺点呢？ 优点： 顺序表是连续的物理空间，方便下标的随机访问。 缺点： 1.增容需要申请新空间，拷贝数据，释放旧的空间。会有一定消耗。 2.头部或者中间位置插入或者删除数据，需要挪动数据，效率较低。 3.可能存在一定空间占用，浪费空间，不能按需申请和释放空间。 为了解决上诉问题，我们引入了链表。首先我们先来看看单链表。 链表介绍 链表是一种物理存储结构上非连续、非顺序的存储结构、数据元素的逻辑顺序是通过链表中的指针链接
线性表之无头单向非循环链表
m0_62171658的博客
03-06 735
线性表之无头单向非循环链表详解
【数据结构】无头单向非循环链表
卑微楽的开发之路
09-28 150
链表 首先我们来思考一个问题: 为什么要有链表这种结构呢? 上次我们写了顺序表, 其实本质上也就是一个数组, 它已经可以完成数据的存储和访问了, 但是它还存在一些不可避免的问题 1. 顺序表的中间和头部的插入删除的时间复杂度都是O(n), 复杂度太高 2. 增容的时候需要申请新的空间, 还要完成数据从旧空间到新空间的数据拷贝过程, 再释放旧空间, 消耗非常大 3. ...
【C语言】链表详解（无头单向非循环）
杨同学的博客
07-29 1845
学习链表之前，先让我们来思考一个问题为什么有了顺序表，还需要有链表这样的数据结构呢？顺序表存在的一些问题顺序表在中间/头部的插入删除，要挪动很多数据，时间复杂度为O(N)，效率太低了。增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。增容一般是一次增长2倍，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。为了更好的解决上述问题，引入了链表。...
【数据结构入门】带头双向循环链表（List）详解（定义、增、删、查、改） | 配有大量图解，超详细哦~
codewinter的博客
09-10 2554
文章目录（1）前言（2）带头双向循环链表的实现1）双向链表的定义2）双向链表的初始化3）双向链表的销毁4）打印双向链表5）双向链表的尾插6）双向链表的尾删7）双向链表的头插8）双向链表的头删9）查找双向链表中的元素10）在指定pos位置之前插入元素11）删除指定pos位置的元素12）双向链表的判空13）获取双向链表的元素个数 学习双向链表之前，建议先学习下顺序表和单链表，配合这两篇文章食用更佳哦： 【数据结构入门】顺序表（SeqList）详解（初始化、增、删、查、改） 【数据结构入门】无头单向非循环链表（S
【数据结构】链表LinkedList
qq_61862008的博客
11-18 1152
链表以及LinkedList介绍
线性表之带头双向循环链表
m0_62171658的博客
03-06 1441
初学者必备：线性表之带头双向循环链表接口实现和一些链表必备思想
无头单向非循环链表
persistence_Y的博客
06-30 201
首先创建一个头文件存放所需要的函数功能的声明slist.h #ifndef _SLIST_H #define _SLIST_H #include <stdio.h> #include <stdlib.h> #include <assert.h> #include <malloc.h> typedef int SLTDataType; typede...
链表之无头单向非循环链表
m0_48810566的博客
10-25 196
链表之无头单向非循环链表 链表的概念及结构 链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。 实际中链表的结构非常多样，以下情况组合起来就有8种链表结构： 1.单向、双向 2.带头、不带头 3.循环、非循环 主要掌握两种： 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如 哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。 无头双向链表：在Java的集合框架库中LinkedList底层实现就是无头双向循环链表
【数据结构入门】无头单向非循环链表（SList）详解（定义、增、删、查、改） | 图解链表，超生动详细哦~
codewinter的博客
08-28 2920
文章目录（1）链表介绍1）为什么引入链表2）链表的概念及结构3）链表的分类（2）无头单向非循环链表的实现1）单链表的定义2）动态申请一个节点3）打印单链表4）单链表尾插5）单链表头插6）单链表尾删7）单链表头删8）在单链表中查找指定值的节点9）单链表在pos位置之后插入10）单链表删除指定pos位置的节点11）单链表删除指定pos位置之后的节点12）求单链表长度13）判断单链表是否为空12）求单链表长度13）判断单链表是否为空 学习链表之前，建议先学习下顺序表，配合这篇文章食用更佳哦： 【数据结构入门】顺序
【数据结构：链表】——无头单向非循环链表的实现（C语言）
紫阳战君的博客
07-28 394
1、什么是链表？ 链表：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。 详细了解： 链表的详解 注： 实际上链表的结构是多样的，总共有8种链表结构。 1.单项、双向 2.带头、不带头 3.循环、不循环 虽然有八种数据结构但是生活中我们常用的结构也就是这两种链表结构：无头单向非循环链表、带头双向循环链表。 无头单向非循环链表：...
链式存储（无头单向不循环链表）
zhang21722668的博客
08-28 532
1.链表的分类（8种） 单向 | 双向 有头 | 没有头 有循环 | 无循环 2.顺序表 和 链表优缺点 顺序表 随机下标访问 链表 便于增删（不是尾巴） 3.概念 一个个空间 空间中承载的数据 空间之间用链式结构串起来（next）next==NULL 表示结尾 4.链表 增删(改)查 Push Back | Front | Pos Pop Back | Front ...
【数据结构】无头单向非循环链表的实现
ly_6699的博客
01-21 209
无头单向非循环链表的特点：不带头结点，只有next指针，不循环 SList.h #ifndef __SLIST_H__ #define __SLIST_H__ #define _CRT_SECURE_NO_WARNINGS 1 #include &lt;stdlib.h&gt; #include &lt;stdio.h&gt; #include &lt;assert.h&gt; #include...
无头单向非循环链表的实现
Hb_key的博客
08-25 332
简介 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域，由于不必按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。 分...
【数据结构】单链表（无头单向非循环链表）的实现
最新发布
m0_52347974的博客
01-06 441
单链表
【数据结构】链表的实现 之 无头单向非循环链表的实现
LXL7868的博客
04-23 258
接口方法： public interface ILinked { //头插法 void addFirst(int data); //尾插法 void addLast(int data); //任意位置插入,第一个数据节点为0号下标 void addindex(int index,int data);...
链表数据结构详解：单链表、双向链表与循环链表
在某些特定场景下，如处理循环数据流，循环链表尤为适用。 链表的核心操作包括插入、删除和查找。在单链表中，插入操作需要找到插入位置的前一个节点，更新其Next指针；删除操作则需要找到待删除节点及其前一个节点...
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值