C语言实现单链表的增删查改

最新推荐文章于 2024-05-13 18:48:45 发布
最新推荐文章于 2024-05-13 18:48:45 发布
阅读量1.7w 收藏 36
点赞数 17
分类专栏： c语言 数据结构 线性表 单链表 数据结构 文章标签： 线性表 单链表 链表 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40927789/article/details/79686922
版权

链表：一种链式存储的线性表，用一组地址任意的存储单元存放线性表的数据元素，称存储单元为一个节点。
链表分类：

单链表
双链表
双向循环链表

代码实现单链表的增删查改：
linklist.h文件

#pragma once

#include<stddef.h>

typedef char LType;

typedef struct LinkNode
{
    //数据域
    LType data;
    //指针域
    struct LinkNode* next;
}LinkNode;

LinkNode *head;

//初始化
void linklistInit(LinkNode **head);
//节点销毁
void DestroyNode(LinkNode *node);

//打印链表
void linklistPrint(LinkNode *head);
//逆序打印链表（递归）
void linklistReversePrint(LinkNode *head);

//尾插
LinkNode *linklistPushBack(LinkNode **head,LType value);
//尾删
void linklistPopBack(LinkNode **head);

//头插
void linklistPushFront(LinkNode **head,LType value);
//头删
void linklistPopFront(LinkNode **head);

//查找指定元素的下标，返回元素地址
LinkNode *linklistFind(LinkNode *head,LType to_find);

//指定位置之前插入指定元素（遍历）
void linklistInsertBefore(LinkNode **head,LinkNode*pos,LType value);
//指定位置之前插入指定元素（不遍历）
void linklistInsertBefore1(LinkNode**head,LinkNode*pos,LType value);
//指定位置之后插入指定元素（遍历）
void linklistInsertAfter(LinkNode **head,LinkNode *pos,LType value);

//删除指定元素（遍历）
void linklistErase(LinkNode **head,LinkNode *pos);
//删除指定元素（不遍历）
void linklistErase2(LinkNode **head,LinkNode *pos);

//删除指定元素，若有多个该元素则删除第一个
void linklistRemove(LinkNode **head,LType to_delete);

//判断链表是否为空，空则返回0否则返回1
int linklistEmpty(LinkNode *head);
//求链表元素个数
size_t linklistSize(LinkNode *head);

linklist.c文件

#include<stdio.h>
#include<stdlib.h>
#include"linklist.h"

#define Test_Header printf("\n-----%s-----\n",__FUNCTION__);

//初始化函数
void linklistInit(LinkNode **head)
{
    *head = NULL;
}
//创建新节点函数
LinkNode *CreateNode(LType value)
{
    //为新节点申请空间
    LinkNode *new_node = (LinkNode*)malloc(sizeof(LinkNode));
    //给新节点赋值
    new_node->data = value;
    //将新节点的next指向空
    new_node->next = NULL;
    return new_node;
}
//销毁一个节点
void DestroyNode(LinkNode *node)
{
    free(node);
}
//顺序打印链表元素
void linklistPrint(LinkNode *head)
{
    if(head == NULL)
    {
        //空链表无需打印
        return;
    }
    LinkNode *cur = head;
    //遍历链表
    while(cur != NULL)
    {
        //打印元素和其对应的地址
        printf("%c|%p\n",cur->data,cur);
        //移动cur,以达到遍历链表的目的
        cur = cur->next;
    }
    printf("\n\n");
}
//逆序打印链表（递归思想）
void linklistReversePrint(LinkNode *head)
{
    if(head == NULL)
    {
        //空链表无需打印，也是递归的出口
        return;
    }   
    linklistReversePrint(head->next);
    printf("%c|%p ",head->data,head);
    printf("\n");
}
//尾插函数
LinkNode *linklistPushBack(LinkNode **head,LType value)
{
    //非法输入
    if(head == NULL)
    {
        return NULL;
    }
    //空链表
    if(*head == NULL)
    {
        //直接创建一个新的节点完成元素插入
        *head = CreateNode(value);
        return NULL;
    }
    else
    {
        LinkNode *cur = *head;
        //遍历链表，让cur指向最后一个元素
        while(cur->next != NULL)
        {
            cur = cur->next;
        }
        //创建一个新节点
        LinkNode *new_node = CreateNode(value);
        //将最后一个元素的next指向新节点
        cur->next = new_node;
        return new_node;
    }
}
//尾删函数
void linklistPopBack(LinkNode **head)
{
    //非法输入
    if(head == NULL)
    {
        return;
    }
    //空链表没有可删除的元素
    if(*head == NULL)
    {
        return;
    }
    //只有一个元素
    if((*head)->next == NULL)
    {
        //直接删除节点
        DestroyNode(*head);
        //将头结点置空
        *head = NULL;
        return;
    }
    else
    {
        LinkNode *cur = *head;
        //遍历链表，使cur指向倒数第二个元素
        while(cur->next->next != NULL)
        {
            cur = cur->next;
        }
        //创建指针指向最后一个元素，即我们需要删除的元素
        LinkNode *to_delete = cur->next;
        //将该节点销毁
        DestroyNode(to_delete);
        //将倒数第二个元素的next指向空
        cur->next = NULL;
    }
    return;
}
//头插函数
void linklistPushFront(LinkNode **head,LType value)
{
    //非法输入
    if(head == NULL)
    {
        return;
    }
    //空链表
    if(*head == NULL)
    {
        //直接创建一个新节点完成插入
        *head = CreateNode(value);
        return;
    }
    else
    {
        //创建一个新的指针指向头结点
        LinkNode *new_node = *head;
        //创建一个新的头结点
        *head = CreateNode(value);
        //将新的头结点的next指向旧的头结点
        (*head)->next = new_node;
    }
    return;
}
//头删函数
void linklistPopFront(LinkNode **head)
{
    //非法输入
    if(head == NULL)
    {
        return;
    }
    //空链表没有可删除的元素
    if(*head == NULL)
    {
        return;
    }
    else
    {
        //创建一个新的指针指向第二个元素
        LinkNode *new_node = (*head)->next;
        //将头结点的next指向空
        (*head)->next = NULL;
        //删除该头结点
        DestroyNode(*head);
        //将第二个元素设置成新的头结点
        *head = new_node;
    }
    return;
}
//查找链表中指定元素的地址
LinkNode *linklistFind(LinkNode *head,LType to_find)
{
    int count = 0;
    LinkNode *find = head;
    //空链表
    if(head == NULL)
    {
        return;
    }
    else
    {
        //循环遍历链表
        for(;find->next != NULL;find = find->next)
        {
            if(find->data == to_find)
            {
                count++;
                //找到了返回该元素的地址
                return find;
            }
        }
    }
    //如果count计数为0，说明没有链表中不存在想要查找的元素
    if(count == 0)
    {
        printf("this value is non-existence\n");
    }
    //没找到返回空
    return NULL;
}

//在指定位置之前插入指定元素（遍历）函数
//时间复杂度为O(n)
void linklistInsertBefore(LinkNode **head,LinkNode *pos,LType value)
{
    //非法输入
    if(head == NULL)
    {
        return;
    }
    //空链表
    if(*head == NULL)
    {
        //直接创建一个新的节点
        *head = CreateNode(value);
        return;
    }
    //如果是头结点位置
    if(pos == *head)
    {
        //则进行头插
        linklistPushFront(head,value);
        return;
    }
    //如果为空
    if(pos == NULL)
    {
        //则进行尾插
        linklistPushBack(head,value);
        return;
    }
    else
    {
        LinkNode *cur = *head;
        //遍历链表
        while(cur->next != NULL)
        {
            //cur的下一个位置就是pos
            if(cur->next == pos)
            {
                //创建一个指针，以value值创建节点
                LinkNode *pre = CreateNode(value);
                //将cur的next修改指向新的节点的位置
                cur->next = pre;
                //将新节点的next指向pos，就在pos位置之前插入了新元素
                pre->next = pos;
                return;
            }
            //将cur移向下一个元素，以达到遍历链表的目的   
            cur = cur->next;
        }
    }
}
//在指定位置之前插入指定元素（不遍历）函数
//时间复杂度为O(1)
void linklistInsertBefore1(LinkNode **head,LinkNode *pos,LType value)
{
    //非法输入
    if(head == NULL)
    {
        return;
    }
    //空链表
    if(*head == NULL)
    {
        //直接创建一个新的节点
        *head = CreateNode(value);
        return;
    }
    //如果是头结点位置
    if(pos == *head)
    {
        //则进行头插
        linklistPushFront(head,value);
        return;
    }
    //如果位置为空
    if(pos == NULL)
    {
        //则进行尾插
        linklistPushBack(head,value);
        return;
    }
    else
    {
        //定义一个新指针指向pos的下一个位置
        LinkNode *cur = pos->next;
        //用pos位置的值创建一个新的节点
        LinkNode *new_node = CreateNode(pos->data);
        //将pos位置的值修改为value
        pos->data = value;
        //将pos的next指向新的节点
        pos->next = new_node;
        //将新节点的next指向pos的next，即指向cur
        new_node->next = cur;
    }
}
//在指定位置之后插入指定元素
void linklistInsertAfter(LinkNode **head,LinkNode *pos,LType value)
{
    //非法输入
    if(head ==NULL)
    {
        return;
    }
    //空链表
    if((*head) == NULL)
    {
        //直接以value值创建一个头结点
        *head = CreateNode(value);
        return;
    }
    //如果pos位置为空
    if(pos == NULL)
    {
        //则进行尾插
        linklistPushBack(head,value);
        return;
    }
    //如果pos为头结点的位置
    if(pos == *head)
    {
        //则进行头插
        linklistPushFront(head,value);
        return;
    }
    else
    {
        //创建一个新的指针指向头结点
        LinkNode *cur = *head;
        //遍历链表
        while(cur->next != NULL)
        {
            //cur的下一个位置就是pos
            if(cur->next == pos)
            {
                //以value值创建一个新的节点
                LinkNode *new_node = CreateNode(value);
                //新节点的next指向pos位置的next
                new_node->next = pos->next;
                //pos的next修改指向新的节点
                pos->next = new_node;
            }
            //移动cur
            cur = cur->next;
        }
    }
}
//删除指定位置的元素（遍历）函数
//时间复杂度为O（n）
void linklistErase(LinkNode **head,LinkNode *pos)
{
    //非法输入
    if(head == NULL)
    {
        return;
    }
    //空链表
    if(*head == NULL)
    {
        return;
    }
    //如果pos位置为空
    if(pos == NULL)
    {
        //则进行尾删
        linklistPopBack(head);
        return;
    }
    //如果pos为头结点的位置
    if(pos == *head)
    {
        //则进行头删
        linklistPopFront(head);
        return;
    }
    else
    {
        //创建新的指针指向头结点
        LinkNode *cur = *head;
        //遍历链表，遍历完成以后cur的下一个位置就是pos
        while(cur->next != pos)
        {
            cur = cur->next;
        }
        //将cur的next指向pos的next
        cur->next = pos->next;
        //销毁pos节点
        DestroyNode(pos);
    }
}
删除指定位置的元素（遍历）函数
//时间复杂度为O(1)
void linklistErase2(LinkNode **head,LinkNode *pos)
{
    //非法输入
    if(head == NULL)
    {
        return;
    }
    //空链表无法删除
    if(*head == NULL)
    {
        return;
    }
    //如果pos位置为空
    if(pos == NULL)
    {
        //则进行尾删
        linklistPopBack(head);
        return;
    }
    //如果pos为头结点位置
    if(pos == *head)
    {
        //则进行头删
        linklistPopFront(head);
        return;
    }
    else
    {
        //创建一个新的指针指向pos的next
        LinkNode *to_delete = pos->next;
        //将pos的下一个位置的元素赋给pos
        pos->data = to_delete->data;
        //再将pos的next指向其下一个元素的next
        pos->next = to_delete->next;
        //将pos的下一个位置节点删除
        DestroyNode(to_delete);
    }
}
//删除指定元素，若存在多个元素则只删除第一个函数
void linklistRemove(LinkNode **head,LType to_delete)
{
    //非法输入
    if(head == NULL)
    {
        return;
    }
    //空链表没有可删除的元素
    if(*head == NULL)
    {
        return;
    }
    //如果头结点的元素是要删除的元素
    if((*head)->data == to_delete)
    {
        //则进行头删
        linklistPopFront(head);
        return;
    }
    LinkNode *cur = *head;
    //遍历链表
    while(cur != NULL && cur->next != NULL)
    {
        //要删除的元素是cur的下一个元素
        if(cur->next->data == to_delete)
        {
            //定义一个新的指针指向cur的下一个元素（待删除元素）的位置
            LinkNode *to_remove = cur->next;
            //将cur的next指向其下一个元素（待删除元素）的下一个位置
            cur->next = to_remove->next;
            //删除新的节点（即一开始定义的指向待删除元素的指针）
            DestroyNode(to_remove);
            return;
        }
        cur = cur->next;
    }
}
//判断链表是否为空链表
int linklistEmpty(LinkNode *head)
{
    //为空返回0否则返回1
    return head == NULL?0:1;
}
//求链表中元素个数，返回元素个数
size_t linklistSize(LinkNode *head)
{
    //空链表返回0
    if(head == NULL)
    {
        return 0;
    }
    size_t count = 0;
    LinkNode *cur = head;
    //遍历链表
    for(;cur != NULL;cur = cur->next)
    {
        count++;
    }
    return count;
}

//尾插的测试函数
void TestPushBack()
{
    Test_Header;
    //初始化链表
    linklistInit(&head);
    //尾插a b c d
    linklistPushBack(&head,'a');
    linklistPushBack(&head,'b');
    linklistPushBack(&head,'c');
    linklistPushBack(&head,'d');
    linklistPrint(head);
}
//尾删的测试函数
void TestPopBack()
{
    Test_Header;
    //尾删3次
    linklistPopBack(&head);
    linklistPopBack(&head);
    linklistPopBack(&head);
    linklistPrint(head);
}
//头插的测试函数
void TestPushFront()
{
    Test_Header;
    //头插b c d
    linklistPushFront(&head,'b');
    linklistPushFront(&head,'c');
    linklistPushFront(&head,'d');
    linklistPrint(head);
}
//头删的测试函数
void TestPopFront()
{
    Test_Header;
    //头删3次
    linklistPopFront(&head);
    linklistPopFront(&head);
    linklistPopFront(&head);
    linklistPrint(head);
}

测试结果如图：
这里写图片描述

//查找指定元素的地址的测试函数
void TestFind()
{
    Test_Header;
    //尾插一个b
    linklistPushBack(&head,'b');
    printf("链表中的元素为:\n")
    linklistPrint(head);
    //查找元素a和c在链表中的地址
    LinkNode *ret1 = linklistFind(head,'a');
    LinkNode *ret2 = linklistFind(head,'c');
    printf("find address:a->%p c->%p\n",ret1,ret2);
}

测试结果如图：
这里写图片描述

/在指定位置之前插入指定元素（遍历）的测试函数
void TestInsertBefore()
{
    Test_Header;
    //期待打印出的链表元素
    printf("A a b x c d e\n");
    //尾插入一个c和d
    linklistPushBack(&head,'c');
    linklistPushBack(&head,'d');
    //指定位置为空时插入e（进行尾插）
    linklistInsertBefore(&head,NULL,'e');
    //指定位置为第一个位置时插入A（进行头插）
    linklistInsertBefore(&head,head,'A');
    //找到c元素的地址
    LinkNode *pos = linklistFind(head,'c');
    //在c位置之前插入x
    linklistInsertBefore(&head,pos,'x');
    linklistPrint(head);
}
//在指定位置之前插入指定元素（不遍历）的测试函数
void TestInsertBefore1()
{
    Test_Header;
    //期待打印出的链表元素
    printf("m A a b x n c d e o\n");
    //指定位置为空时插入o（进行尾插）
    linklistInsertBefore1(&head,NULL,'o');
    //指定位置为第一个位置时插入m（进行头插）
    linklistInsertBefore1(&head,head,'m');
    //找到c元素的地址
    LinkNode *pos = linklistFind(head,'c');
    //在c位置之前插入y
    linklistInsertBefore1(&head,pos,'n');
    linklistPrint(head);
}

测试结果如下：
这里写图片描述

//在指定位置之后插入指定元素的测试函数
void TestInsertAfter()
{
    Test_Header;
    //期待打印出的链表元素
    printf("B m A a b x n c y d e o E\n");
    //指定位置为空时插入E（进行尾插）
    linklistInsertAfter(&head,NULL,'E');
    //指定位置为第一个位置时插入B（进行头插）
    linklistInsertAfter(&head,head,'B');
    //找到c元素的地址
    LinkNode *pos = linklistFind(head,'c');
    //在c位置之后插入y
    linklistInsertAfter(&head,pos,'y');
    linklistPrint(head);
}

测试结果如图：
这里写图片描述

//删除指定位置元素(遍历)函数测试
void TestErase()
{
    Test_Header;
    //期待打印出的链表元素
    printf("m A a b x n y d e o\n");
    //若pos为空则执行尾删
    linklistErase(&head,NULL);
    //尝试删除第一个位置的元素
    linklistErase(&head,head);
    //找到c元素的地址
    LinkNode *pos = linklistFind(head,'c');
    //尝试删除c元素位置的元素，即删除c
    linklistErase(&head,pos);
    linklistPrint(head);
}
//删除指定位置元素(不遍历)函数测试
void TestErase2()
{
    Test_Header;
    //期待打印出的链表元素
    printf("A a b x y d e\n");
    //若pos为空则执行尾删
    linklistErase2(&head,NULL);
    //尝试删除第一个位置的元素
    linklistErase2(&head,head);
    //找到n元素的地址
    LinkNode *pos = linklistFind(head,'n');
    //尝试删除n元素位置的元素，即删除n
    linklistErase2(&head,pos);
    linklistPrint(head);
}

测试结果如图：
这里写图片描述

//逆序打印链表函数测试
void TestReversePrint()
{
    Test_Header;
    linklistReversePrint(head);
}
//删除指定元素，若存在多个该元素则只删除第一个的函数测试
void TestRemove()
{
    Test_Header;
    //期待打印的元素
    printf("a x y b d\n");
    //找到元素y的地址
    LinkNode *pos = linklistFind(head,'y');
    //在元素y之后插入b
    linklistInsertAfter(&head,pos,'b');
    //尝试删除末尾的元素
    linklistRemove(&head,'e');
    //尝试删除第一个元素
    linklistRemove(&head,'A');
    //尝试删除元素x
    linklistRemove(&head,'x');
    //尝试删除元素b原链表中有两个b
    linklistRemove(&head,'b');
    linklistPrint(head);
}

测试结果如图：
这里写图片描述

//求链表元素个数函数测试
void TestSize()
{
    Test_Header;
    size_t size = linklistSize(head);
    linklistPrint(head);
    printf("size:%lu\n",size);
}
//判断链表是否为空测试函数
void TestEmpty()
{
    Test_Header;
    //返回0说明链表为空，返回1说明链表不为空
    int ret1 = linklistEmpty(head);
    printf("%d\n",ret1);
}

测试结果如图：
这里写图片描述

//以下为测试函数调用
int main()
{
    TestPushBack();
    TestPopBack();
    TestPushFront();
    TestPopFront();
    TestFind();
    TestInsertBefore();
    TestInsertBefore1();
    TestInsertAfter();
    TestErase();
    TestErase2();
    TestReversePrint();
    TestRemove();
    TestSize();
    TestEmpty();
    return 0;
}
小心眼儿猫
关注
  • 17
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言 单链表的增删查改（附：c++版本实现）
凡事都是靠练习
02-02 4258
单链表的增删查改，讲解基本接口的实现
单链表的增删查改
2201_75755162的博客
11-18 49
链表与顺序表不同的是，链表有节点，且链表在空间中的从顺序不是连续的，链表通过地址对其进行访问。因此，链表的每一个节点地址都是随机的，每一个节点的地址即存此结点的这个地址，也存下一个结点的地址。
2024年最全C C++ 链表（单链表）_c+，想跳槽涨薪的必看
最新发布
2401_84978578的博客
05-13 232
先生成两个node类的实例，node1和node2，分别将它们的value初始化为1和2，再用&运算符取出node2的首地址，赋值给node1.next。这样我们就可以先拿到node1的next指针，在通过“->”运算符访问node2的value值，输出就是2。结点已经定义好了，现在需要创建链表了，上面已经说了，除了结点外，头指针是链表不可缺少的。了，但是这样创建结点并连接会发现效率很低，node1和node2是我们提前声明好的，而我们如果创建更多结点的话显然这种方式并不合适。细心的人已经发现，这。
链表的实现
qq_44888950的博客
11-05 562
文章目录1 链表1.1 链表的概念及结构1.2 链表的实现 1 链表 1.1 链表的概念及结构 链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。 之所以叫链表，因为其结构就类似于链条，每个节点包括一个value和指向下一个节点的引用。 1.2 链表的实现 这里主要实现的是不带头的非循环链表 创建节点： class ListNode1{ public int val; public ListNode1 next; //有参构造，给val赋
单链表的基本实现(详细图解+解说)
Eliauk_U的博客
03-16 4836
目录 一.前言： 二.链表的结构实现: 三.单链表的功能实现-增删查..... 1.结点的申请 2.数据的头插 3.数据的打印 4.数据的尾插 5.数据的头删 6.数据的尾删 7.数据的查找 8.数据的指定插入和指定删除 9.链表的销毁 四.后言 一.前言： 我们都知道，顺序表是一块连续的可以存放数据的存储空间，其可以通过下标或指针解引用的方式快速访问某个位置的数据，但是由于空间的连续性，想要灵活的插入和删除数据便较为困难。 区别于顺序表，链表由一个个独立的可以存放数..
链表(C语言）
weixin_61196797的博客
04-30 3894
前言 本次我们介绍链表的创建及增，删，改，查。 ` 一、链表是什么？ 首先我们来了解一下线性存储结构。线性存储结构是一种最常见的存储结构。其特点是数据元素之间存在一一对应的关系。线性存储结构又分为两种，即顺序存储结构和链式存储结构。 1.首先，我们来了解一下顺序存储结构。顺序存储的线性表称为顺序表（数组）。其原理是逻辑上相邻的元素在物理位置上也相邻。 我们可以理解为一堆按照一定顺序摆放的书。我们在知道它的排列规律之后就可以通过它的排列规律来找到我们想找到的那本书。我们也可以通过一本一本的去找，来找到我们想要
C语言数据结构单链表的增删查改
04-29
C语言数据结构单链表的增删查改
单链表 ，增删查改，视频课程，截图分享，
06-18
在C语言中，单链表可以使用结构体来实现，例如： ```c typedef struct Node { int data; struct Node* next; } Node; ``` 其中，`data`是数据域，`next`是指针域，用于指向下一个节点。 单链表的插入操作可以通过...
C语言实现图书管理系统.docx
10-21
本系统的数据结构主要基于单链表，这是一种动态数据结构，能够高效地处理增删查改操作。单链表的特点是每个元素（节点）包含实际的数据以及指向下一个元素的指针。 首先，我们需要定义数据结构来存储图书信息。`...
C语言程序设计-实验5-单链表版-实验指导书1
08-08
结构体可以用来表示商品，链表可以用来存储多个商品信息，通过菜单系统让用户进行增删查改等操作。理解并实践这些知识点，将加深你对C语言数据结构和控制流程的理解，对后续的编程学习大有裨益。
链表头插法
m0_47170940的博客
03-23 3976
#include <stdio.h> #include <stdlib.h> typedef struct Node{ int date; //数据域 struct Node *next; //存储节点的地址 }LNode,*Linklist; Linklist Creat_list(Linklist head); void Illustrate(Linklist head)//输出每个节点的数据域 函数 { Linklist tem = head;//
C语言对链表的基本操作（1、创建表 2、创建节点 3、表头插入 4、表尾插入 5、打印表）
weixin_40933653的博客
03-25 3719
1. 链表的结构体定义（结点定义） 链表的一个结点首先肯定包含一个数据域和一个指针域，数据域用来存放结点数据，指针域存放的是指向下一个结点的地址。当然，头节点例外，其实，头结点和普通结点一样，只不过头结点只存放了指向下一个结点的地址（即首结点）。 2、创建节点 为插入做准备，学习数据的时候，一定要把功能划分明确 3、表头插入 // 插在头结点之后 插队插入，不能越过头结点 // 插队插入，不能越过头结点 只需要强调一点，头插法是在头结点尾部，尾插法是在链表尾部插入，这个不要理解错了。其...
c++实现单链表基本操作
u011200403的博客
02-13 1万+
程序媛决定好好学习写代码 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种
头插法建立链表(C语言版)
热门推荐
SevenDown777的博客
02-06 1万+
上次用尾插法建立的链表，这次改用头插法建立，代码如下： #include #include //头插法建立链表 //定义链表结点 typedef struct node{ int data; struct node *next; }Lnode; //创建n个结点的链表，因为要通过参数改变指针变量， //所以形参采用二重指针形式，生成链表带有头结点； void
单链表的增删查改操作
m0_67198282的博客
03-17 1487
单链表——只能单向访问的链表 每个结点中存放数据和下个结点的地址 我们今天来实现单链表简单的增删查改操作 1.准备工作 在开始前我们首先创建一个包含数据和地址的结构体结点 typedef int Slisttype;//使得数据类型修改方便 typedef struct SlistNode { Slisttype data;//结点中存储的数据 struct SlistNode* next;//下个结点的地址 }SlistNode; 然后我们再创建第一个结点（NULL） .
c++之链表篇1：单向链表的创建，打印，删除，插入，销毁等基本操作
迷途中的前进
10-07 5634
在牛客网上刷题的过程遇到很多链表的问题，所以自己又结合着传智播客上的视频把链表整理了一下。 #include using namespace std; //链表的的结点 struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(NULL) { } }; //创建一个单向链表 L
单链表的增删查改的c语言代码实现
04-20
可以的，以下是单链表的增删查改的c语言代码实现： 单链表的定义： ``` typedef struct Node{ int data; //存放链表的数据 struct Node *next; //指向下一个链表节点的指针 }*LinkedList, Node; ``` 链表节点的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值