嵌入式-单向链表

已于 2024-08-04 20:43:58 修改
阅读量343 收藏 9
点赞数 3
文章标签： 链表 c语言 数据结构
于 2024-08-01 23:55:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74969398/article/details/140859983
版权

链表增删改查

linklistfunc.c文件

#include <stdio.h>
#include <stdlib.h>
#include "./linklistfunc.h"

                                                                  
//创建单链表
Linklist* create_linklist(void)
{
    //申请堆空间
    Linklist *head = (Linklist*)malloc(sizeof(Linklist));
//判断链表是否为空
    if(NULL == head)
    {
        printf("链表为空，创建数据链表失败\n");
        return NULL;
    }

    //初始化头结点中的len
    head->text.len = 0;
    head->next= NULL;

    return head;


}

//从头部插入
void insert_linklist(Linklist *head,datatype num)
{
    //先创建结点
    Linklist* temp =(Linklist*)malloc(sizeof(Linklist));
    
    if(NULL == temp)
    {
    printf("创建结点失败，头插失败\n");
    return ;

    }
    temp->text.data = num;//数据域赋值
    temp->next = NULL;//指针域赋值

//先让temp的next指针存储head->这个结点的首地址
    temp->next = head->next;

    head->next =temp;//头结点的指针域存储temp结点的地址

//更新头结点中链表的长度
    head->text.len++;
    
    return ;
}


//头删法
void delete_linklist(Linklist *head)
{                                                              
    //判断链表是否为空
    if(head->next==NULL)
    {
        printf("链表为空，删除失败\n");

        return;
    }

    //先将要释放的结点地址另存
    Linklist*temp=head->next;
    head->next=head->next->next;//head->next=temp->next;

    //释放结点
    free(temp);
    temp = NULL;

    //更新头结点中链表长度
    head->text.len--;

    return ;
}
//尾删法                                           
void delete_linklist2(Linklist* head)
{
    //判断链表是否为空
    if(head->next==NULL)
    {
        printf("链表为空，删除失败\n");
        return;
    }

    //循环方式找到倒数2个结点p
    Linklist* p=head;
    while(p->next->next != NULL)
    {
        p=p->next;
    }

//释放结点
    Linklist* temp=p->next;
    p->next = NULL;

    free(temp);

    //free(p->next);
    p->next= NULL;

    //更新头结点中链表的长度
    head->text.len--;

    return;
}
//尾插法插入数据
void insert_linklist2(Linklist *head,datatype num)
{
    //先创建结点                                                     
    Linklist* temp =(Linklist*)malloc(sizeof(Linklist));

    if(NULL == temp)
    {
    printf("创建结点失败，尾插失败\n");
    return ;

    }
    temp->text.data = num;//数据域赋值
    temp->next = NULL;//指针域赋值


    Linklist* p = head;
    while(p->next != NULL)//判断p->next是否为NULL,空则跳出循环
    {
        p = p->next;
    }
    temp->next =p->next;//temp->next=NULL;
    p->next=temp;

    //更新头结点中链表的长度
    head->text.len++;

    return ;

}
 //遍历链表
 void show_linklist(Linklist* head)
 {
     Linklist *p = head;
     while(p->next != NULL)                                              
     {
         p=p->next;
         printf("%d ",p->text.data);
     }
     putchar(10);
     return ;
 }


 //按位置插入Bitwise按位
 void insert_linklistBitwise(Linklist* head,datatype num,int n)
 {
 
 //判断插入的位置是否合法
 if(n<1 || n>head->text.len+1)
     {
         printf("插入位置非法\n");
     }
 //向第n个位置插入，则需要找到第n-1个位置插入
 //若在找的途中，p指向NULL,则代表插入位置非法
 
     Linklist *p = head;
     for(int i=0;i<n-1;i++)
     {
         p=p->next;
         if(NULL == p)
         {
             printf("插入位置非法\n");
 
             return ;
         }
     }
     //先创建结点
     Linklist* temp =(Linklist*)malloc(sizeof(Linklist));
 
     if(NULL == temp)
     {
     printf("创建结点失败，按位置插入失败\n");
     return ;
 
     }
     temp->text.data = num;//数据域赋值
     temp->next = NULL;//指针域赋值


    temp->next=p->next;
    p->next = temp;

    //更新头结点中链表的长度
    head->text.len++;                                          

    return ;
}



//按位置删除
void delete_linklistBitwise(Linklist* head,int n)
{
    //判断链表是否为空
    if(NULL ==head->next)
    {
        printf("链表为空，删除失败\n");

        return ;
    }
    //判断删除位置是否合法
    if(n<1)
    {
        printf("删除位置非法\n");

        return;
    }
    //找到要删除的位置的前一个结点位置
    //删除第n个位置，则需要找到第n-1个位置
    Linklist *p = head;
    for(int i=0;i<n-1;i++)
    {
        p=p->next;

        if(p->next == NULL)
        {
            printf("当前插入的位置非法\n");
            return ;
        }

    }

                                                     
    //p指向的是要删除的结点的前一个位置
    Linklist* temp=p->next;
    p->next=temp->next;
    free(temp);
    temp=NULL;

    //更新头结点中链表的长度
    head->text.len--;

    return ;
}

 //直接插入排序（升序）
 void insert_linklistsort(Linklist *head,datatype num)
 {
     Linklist* p=head;
     while(p->next !=NULL)
     {
         if(num<p->next->text.data)
         {
             break;
         }
         p=p->next;
     }
     //创建结点
     Linklist* temp=(Linklist*)malloc(sizeof(Linklist));
     if(temp ==NULL)
     {
         printf("插入节点失败");
         return ;
     }
     temp->text.data=num;//数据域
     temp->next=NULL;//指针域
 
 
     //插入数据
     temp->next=p->next;
     p->next = temp;
 
     //更新结点
     head->text.len++;
 
 
     return ;
 }


//链表翻转(头删头插)(不使用辅助链表）
void recycle_linklist(Linklist* head)
{
    //从源头链表做头删，“新链表”做头插
    //新链表实际上是将原链表的头结点单独独立出来       

    Linklist *p,*q;
    p = head->next;
    head->next = NULL;
    //循环头插法，将结点P插入到新的链表中
    while(p!=NULL)
    {
        q=p->next;//将p结点的最后一个结点备份

        p->next = head->next;
        head->next=p;

        p=q;

    }

    printf("链表翻转完成\n");

    return ;
}


//找中结点：快慢指针
datatype middlenode_linklist(Linklist *head)
{
    if(head->next ==  NULL)
    {
        printf("链表为空，没有空间结点\n");
        return (datatype)-1;
    }
    Linklist *low,*fast;
    low=fast=head->next;

    while(fast!=NULL&&fast->next!=NULL)
    {
        low=low->next;
        fast=fast->next->next;

    }
//返回的值就是中间结点
    return low->text.data;
}

//释放链表
void free_linklist(Linklist **phead)
{
//循环头删，直到链表为空
//最后释放头结点，将头指针置为NULL
    //phead指向head
    //*phead代表访问head空间
    Linklist* temp =NULL;
    while((*phead)->next!=NULL)
    {
        temp=(*phead)->next;
        (*phead)->next = temp->next;
        free(temp);
        (*phead)->text.len--;
    }
    free(*phead);
    *phead = NULL;
    return;

}

linklistfunc.h

 #ifndef __LINKLIST__
 #define __LINKLIST__
 
 
 typedef int datatype;
 
 
 
 //结构体
 typedef struct lklist
 {
     union
     {
         int len;//若是头结点，则是用len存储链表长度
         datatype data;//若是有效数据结点，则用data存放有效数据
 
     }text;//数据域
 
     struct lklist* next;//指针域
 }Linklist;                                                               
//创建单链表
Linklist* create_linklist(void);

//从头部插入
void insert_linklist(Linklist *head,datatype num);
                                                                    

//遍历链表
void show_linklist(Linklist* head);

//尾插法插入数据
void insert_linklist2(Linklist *head,datatype num);

//头删法
void delete_linklist(Linklist *head);

//尾删法
void delete_linklist2(Linklist* head);

//按位置插入Bitwise按位
void insert_linklistBitwise(Linklist* head,datatype num,int n);

//按位置删除
 void delete_linklistBitwise(Linklist* head,int n);


//直接插入排序（升序）
void insert_linklistsort(Linklist *head,datatype num);

//链表翻转(头删头插)(不使用辅助链表）
void recycle_linklist(Linklist* head);

//找中结点：快慢指针
datatype middlenode_linklist(Linklist *head);

//释放链表
void free_linklist(Linklist **phead);

//直接插入排序（升序）
void insert_linklistsort(Linklist *head,datatype num);

//链表翻转(头删头插)(不使用辅助链表）
void recycle_linklist(Linklist* head);

//找中结点：快慢指针
datatype middlenode_linklist(Linklist *head);

//释放链表
void free_linklist(Linklist **phead);



#endif

linklist_main.c

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

#include "./linklistfunc.h"

int main(int argc, const char *argv[])
{
    Linklist* head;

    head = create_linklist();

    //头部插入数据
    insert_linklist(head,10);
    insert_linklist(head,20);
    insert_linklist(head,30);
    insert_linklist(head,40);
    insert_linklist(head,50);
    insert_linklist(head,60);
    insert_linklist(head,70);
    insert_linklist(head,80);
    show_linklist(head);
 
 //尾插
     insert_linklist2(head,500);
     insert_linklist2(head,600);
     show_linklist(head);
                                                          
     //头删
     delete_linklist(head);
     show_linklist(head);
 
 //尾删
     delete_linklist2(head);
     show_linklist(head);
 
 //按位置插入
     insert_linklistBitwise(head,100,3);
     show_linklist(head);
 
 
 
 //按位置删除
     delete_linklistBitwise(head,4);
     show_linklist(head);
 


    //直接插入排序（升序）
    insert_linklistsort(head,90);   
    show_linklist(head);

    insert_linklistsort(head,12);                       
    show_linklist(head);

    insert_linklistsort(head,100);
    show_linklist(head);

    insert_linklistsort(head,9);    
    show_linklist(head);

    insert_linklistsort(head,99);
    show_linklist(head);





    //链表翻转
    recycle_linklist(head);
    show_linklist(head);
    
    

//快慢指针
    middlenode_linklist(head);
    show_linklist(head);

    //释放链表
    free_linklist(&head);
    printf("%p \n",head);



     return 0;
 }

陈小也~
关注
内嵌双向链表的设计与实现
实力程序员
06-09 222
前一篇文章《双向链表，还能这么实现》，介绍了双向链表如何彻底消除内部的NULL指针，从而代码实现更加简洁，并且不增加任何额外的内存。 实际项目中，对双向链表的需求场景非常多，并且有很多变体的实现。今天介绍内嵌双向链表。先说说场景的需求： 双向链表的经典实现结构，如下图所示： 链表本身维护各个节点，业务使用者需要将自己的数据结构以指针的方式放入链接节点中。 这意味着，向链表增加一个数据，需要做两次内存分配：一次是链表节点自身的内存分配，另一次是业务数据结构的内存分配。 在一些对性能要求严苛的场景中，希望
内嵌式链表的实现
xingqilui126com的专栏
10-18 1339
内嵌式双向链表的实现，记录下来留着以后用得到的地方，应该适用于大部分场景！ >>>>>list.h>>>>> #ifndef _LIST_H_ #define _LIST_H_ typedef struct tagDTQ_NODE { struct tagDTQ_NODE *pstPrev; struct tagDTQ_NODE *pstNext; }DTQ_NODE_S;
Linux内嵌链表（sys/queue.h）详解
热门推荐
tissar的博客
02-11 1万+
Linux 内嵌链表（sys/queue.h）详解queue 简介SLISTSTAILQLISTTAILQCIRCLEQ例程 queue 简介 C语言不像C++语言可以使用STL，在编程中需要用到链表时，通常需要程序员重新设计链表的结构体。不统一的编程规范会增加代码的阅读难度，而且链表的正确性需要验证。 头文件queue.h为C语言中的链表提供了更加标准规范的编程接口。如今的版本多为伯克利加州大...
嵌入式链表
12-11
这是一个万能的链表，将其嵌入到自己的结构体当中使用，免去编写一个结构体一套操作函数之苦。
嵌入式-单向循环链表
m0_74969398的博客
08-04 152
头插法、尾删法、头删法、尾插法、按位插入、按位删除、遍历。linklist_main.c文件。linklistfunc.c文件。linklistfunc.h文件。
嵌入式c语言单向链表
weixin_46146281的博客
04-13 187
注意：这种方法是判断prev指向的是不是尾节点，current保存的地址是不是尾节点的下一项NULL，current本身指向的就是尾节点的next，当current指向NULL时循环已经退出了，此时prev保存的就是为尾节点，prev的next指向的就是新的节点。注意：这种方法是判断current保存的下一个地址是不是NULL，current本身指向的是尾节点，在current后面就是新的节点。链表是结合结构体和指针的综合应用，学习之前务必复习结构体和指针的相关知识。找到尾节点后添加新节点到链表尾部。
数据结构-单向链表(C语言)
m0_49408252的博客
07-22 1863
snode_t;为使链表具有通用性，在节点中只定义指针部分，数据部分通过自定义结构体的方式定义。char* name;node使得my_data_t可作为节点链接在链表中，my_data_t中数据可随实际情况改变。} slist_t;单向链表中定义head和tail分别指向链表的头和尾。
数据结构-单向循环链表
没出过地球
06-11 2106
定义：单向环形链表是指在单链表的基础上，最后一个节点的指针域指向链表的第一个节点，从而构成一个闭合的环。结构：每个节点包含一个数据域和一个指针域。数据域用于存储数据，指针域用于指向下一个节点。在单向环形链表中，最后一个节点的指针域指向第一个节点，形成环状结构。
算法面试题总结_嵌入式-常用知识&面试题库_大厂面试真题.doc
08-07
7. 判断链表是否相交：本题目考察了链表和算法的知识，要求判断俩个单向链表是否相交。解决方法是使用双指针算法，分别从两个链表的头节点开始遍历，如果两个链表相交，则会在某个节点相遇。 8. 怪题：本题目考察了...
进程线程_嵌入式-常用知识&面试题库_大厂面试真题.pdf
08-07
管道的特点是只能在有亲缘关系的进程之间通信，单向通信，接收数据流与数据格式无关，一般而言，进程退出时管道即被释放，因此管道的生命周期会随进程的关闭而消亡。 2. 信号 信号机制是 UNIX 系统中最古老的进程...
朝歌宽带笔试题_嵌入式-常用知识&面试题库_大厂面试真题.doc
08-07
- 在单向链表中节点`P`之前插入节点`S`，需要先保存`P`的前一个节点，然后将`S`的`next`指针设置为`P`，并更新前一个节点的`next`指针为`S`。 5. **冒泡排序**： - 冒泡排序是一种简单的排序算法，通过不断交换...
天元特通题_嵌入式-常用知识&面试题库_大厂面试真题.docx
08-07
嵌入式系统常用知识面试题库 1. 输出代码分析： 在 64 位系统下，代码的输出结果是：10 5 8 4 8 解释：sizeof(str) 输出 str 数组的大小，等于 10；strlen(str) 输出字符串 "hello" 的长度，等于 5；sizeof(p) ...
cpp代码-双向链表的CRUD
07-16
这种设计使得我们可以双向遍历链表，而不仅仅是单向。 1. **创建（Create）**： 创建双向链表涉及初始化头节点，并逐个添加新节点。首先，我们需要定义链表节点的结构体，包括数据、前向和后向指针。然后，可以...
链表嵌套（单向）
记忆中的美丽瞬间
08-19 3899
链表嵌套 测试环境:Visual-Studil Ultimate 2013 头文件：stdafx.h内容   #include #include #include structCAN_DEVICES*insert_DEVICE_LIST(structCAN_DEVICES*Temp);//子链表加入数据 voidprint_Device_List(structCAN_DEVIC
嵌入式双向链表理解
qq_40180744的博客
09-11 286
给自己复习用的 #include <stdio.h> #include <string.h> /* 定义一个节点结构体，三个成员分别是节点数据、指向上一个节点的struct LIST_NODE指针、指向下一个节点的struct LIST_NODE指针 */ typedef struct LIST_NODE { int data; struct LIST_NODE *pxNext; struct LIST_NODE *pxPrevious; }ListNode;
C语言 | Leetcode C语言题解之第435题无重叠区间
最新发布
m0_59237910的博客
09-25 657
C语言 | Leetcode C语言题解之第435题无重叠区间
C语言入门：构建单向链表
"这篇教程介绍了如何使用C语言创建单向链表，并提供了C语言的基础知识，包括计算机语言的种类和C语言的特点。" 在计算机编程中，链表是一种基础的数据结构，尤其在C语言中广泛使用。单向链表是由一系列节点组成，每...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值