嵌入式学习-数据结构-Day3-单链表

已于 2023-12-25 09:39:52 修改
阅读量358 收藏 10
点赞数 9
分类专栏： 嵌入式学习 文章标签： 学习 数据结构
于 2023-12-22 20:54:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56018621/article/details/135160957
版权

Day3

思维导图

在这里插入图片描述

单链表操作

head.h

#ifndef __HEAD_H__
#define __HEAD_H__

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
enum A 
{
	FALSE=-1,
	SUCCESS
};
typedef int datatype;
typedef struct Node
{
	datatype data;
	struct Node *next;
}*Linklist;

int null(Linklist p);
Linklist create_node();
Linklist insert_head(Linklist head,datatype element);
void output(Linklist head);
Linklist insert_tail(Linklist head,datatype element);
Linklist delete_head(Linklist head);
Linklist delete_tail(Linklist head);
int length(Linklist head);
Linklist insert_pos(Linklist head,int pos,datatype element);
Linklist delete_pos(Linklist head,int pos);
datatype find_pos(Linklist head,int pos);
void change_pos(Linklist head,int pos,datatype element);
void element_find(Linklist head,datatype element);
void element_change(Linklist head,datatype element,datatype new_element);
void element_delete(Linklist head,datatype element);
Linklist Unidirectional_list_inversion(Linklist head);
void Find_penultimate_nth(Linklist head,int n);
void single_list_sort(Linklist head);
Linklist free_space(Linklist head);
#endif

test.c

#include "head.h"

int null(Linklist p)
{
        return p==NULL?FALSE:SUCCESS;
}


Linklist create_node()
{
        Linklist p=(Linklist)malloc(sizeof(struct Node));
        if(null(p))
                return NULL;
        p->data=0;
        p->next=NULL;
        return p;
}

Linklist insert_head(Linklist head,datatype element)//头插
{
        Linklist s=create_node();
        if(null(s))
                return head;
        s->data=element;
        s->next=head;
        head=s;
        return head;
}

void output(Linklist head)//输出
{
        if(null(head))
                return;
        Linklist p=head;
        while(p!=NULL)
        {
                printf("%d\t",p->data);
                p=p->next;
        }
        puts("");
}

Linklist insert_tail(Linklist head,datatype element)//尾插
{
        Linklist s=create_node();
        if(null(s))
                return head;
        s->data=element;
        if(null(head))
                head=s;
        else
        {
                Linklist p=head;
                while(p->next!=NULL)
                {
                        p=p->next;
                }
                p->next=s;
        }
        return head;

}

Linklist delete_head(Linklist head)//头删
{
        if(null(head))
                return head;
        Linklist del=head;
        head=head->next;
        free(del);
        del=NULL;
        return head;
}

Linklist delete_tail(Linklist head)//尾删
{
        if(null(head))
                return head;
        else if(head->next==NULL)
        {
                free(head);
        }
        else
        {
                Linklist p=head;
                while(p->next->next!=NULL)
                {
                        p=p->next;
                }
                free(p->next);
                p->next=NULL;
        }
        return head;
}

int length(Linklist head)//长度
{
        Linklist p=head;
        int flag=0;
        while(p!=NULL)
        {
                p=p->next;
                flag++;
        }
        return flag;
}

Linklist insert_pos(Linklist head,int pos,datatype element)//任意位置插入
{
        //判断位置是否合法
        if(pos<1||pos>length(head))
                return head;
        //
        if(pos==1)
        {
                head=insert_head(head,element);
                return head;
        }
        //
        Linklist p=head;
        for(int i=1;i<pos-1;i++)
        {
                p=p->next;
        }
        //
        Linklist s=create_node();
        if(null(s))
                return head;
        s->data=element;
        //
        s->next=p->next;
        p->next=s;
        return head;
}

Linklist delete_pos(Linklist head,int pos)//任意位置删除
{
        if(null(head))
                return head;
        if(pos<1||pos>length(head))
                return head;
        if(pos==1)
        {
                head=delete_head(head);
                return head;
        }
        Linklist p=head;
        for(int i=1;i<pos-1;i++)
        {
                p=p->next;
        }
        Linklist s=p->next;
        p->next=s->next;
        free(s);
        s->next=NULL;
        return head;
}

datatype find_pos(Linklist head,int pos)//任意位置查找
{
        if(null(head))
                return FALSE;
        if(pos<1||pos>length(head))
                return FALSE;
        Linklist p=head;
        for(int i=1;i<pos;i++)
        {
                p=p->next;
        }
        return p->data;
}

void change_pos(Linklist head,int pos,datatype element)//任意位置修改
{
        if(null(head))
                return;
        if(pos<1||pos>length(head))
                return;
        Linklist p=head;
        for(int i=1;i<pos;i++)
        {
                p=p->next;
        }
        p->data=element;

}

void element_find(Linklist head,datatype element)//单向链表任意元素查找
{
        if(null(head))
                return;
        int arr[100];
        int flag=0;
        Linklist p=head;
        for(int i=1;i<=length(head);i++)
        {
                if(p->data==element)
                {
                        arr[flag]=i;
                        flag+=1;
                }
                p=p->next;
        }
        if(flag==0)
        {
                puts("error element!");
        }
                else
        {
                for(int i=0;i<flag;i++)
                        printf("pos is:%d\n",arr[i]);
        }
}

void element_change(Linklist head,datatype element,datatype new_element)//单向链表任意元素修改
{
        if(null(head))
                return;
        int arr[100];
        int flag=0;
        Linklist p=head;
        for(int i=1;i<=length(head);i++)
        {
                if(p->data==element)
                {
                        p->data=new_element;
                        arr[flag]=i;
                        flag+=1;
                }
                p=p->next;
        }
        if(flag==0)
        {
                puts("error element!");
        }
}

Linklist element_delete(Linklist head,datatype element)//单向链表任意元素删除
{
        if(null(head))
                return head;
        int arr[100];
        int flag=0;
        Linklist p=head;
        for(int i=1;i<=length(head);i++)
        {
                if(p->data==element)
                {
                        arr[flag]=i;
                        flag+=1;
                }
                p=p->next;
        }
        if(flag==0)
        {
                puts("error element!");
                return head;
        }
        else
        {
                if(arr[0]==1)
                {
                        head=delete_head(head);
                        for(int i=1;i<flag;i++)
                        {
                                delete_pos(head,arr[i]-1);
                                arr[i+1]-=1;
                        }
                }
                else
                {
                        for(int i=0;i<flag;i++)
                        {
                                delete_pos(head,arr[i]);
                                arr[i+1]-=1;
                        }
                }
        }
        return head;
}


Linklist Unidirectional_list_inversion(Linklist head)//单向链表逆置
{
        if(null(head))
                return head;
        if(length(head)==1)
                return head;
        Linklist p=head;
        p=head->next;
        head->next=NULL;
        while(p!=NULL)
        {
                Linklist t=p;
                p=p->next;
                t->next=head;
                head=t;
        }
        return head;
}

void Find_penultimate_nth(Linklist head,int n)//单向链表查找倒数第n个节点
{
        if(null(head))
                return;
        if(length(head)<n)
                return;
        Linklist p=head;
        Linklist q=head;
        for(int i=0;i<n;i++)
        {
                p=p->next;
        }
        while(p!=NULL)
        {
                p=p->next;
                q=q->next;
        }
        printf("The penultimate %dTH node is:%d\n",n,q->data);
}

void single_list_sort(Linklist head)//单向链表排序-冒泡
{
        if(null(head)||length(head)==1)
                return;
        int len=length(head);
        Linklist p=head;
        for(int i=1;i<len;i++)
        {
                p=head;
                for(int j=0;j<len-i;j++)
                {
                        if(p->data < p->next->data)
                        {
                                datatype t=p->data;
                                p->data=p->next->data;
                                p->next->data=t;
                        }
                        p=p->next;
                }
        }
}

Linklist free_space(Linklist head)//释放内存
{
        if(null(head))
                return NULL;
        for(int i=0;i<length(head);i++)
        {
                head=delete_tail(head);
        }
        free(head);
        head=NULL;
        return head;
}

main.c

#include "head.h"

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

        //头插和尾插
        int n;
        datatype element;
        printf("please enter n:");
        scanf("%d",&n);
        for(int i=0;i<n;i++)
        {
                printf("please enter %d element:",i+1);
                scanf("%d",&element);
        //      head=insert_head(head,element);//头插
                head=insert_tail(head,element);//尾插
        }

        output(head);

        //头删
//      head=delete_head(head);
//      output(head);

        //尾删
//      head=delete_tail(head);
//      output(head);

        //按位置插入
/*      int pos;
        printf("enter the insert_pos:");
        scanf("%d",&pos);
        printf("enter the element:");
        scanf("%d",&element);
        head=insert_pos(head,pos,element);
        output(head);
*/

        //按位置删除
/*      int pos;
        printf("enter the delete_pos:");
        scanf("%d",&pos);
        head=delete_pos(head,pos);
        output(head);
*/

        //按位置查找
/*      int pos;
        printf("enter the find_pos:");
        scanf("%d",&pos);
        datatype find_pos_data=find_pos(head,pos);
        printf("the data is:%d\n",find_pos_data);
*/

        //按位置修改
/*      int pos;
        printf("enter the change__pos:");
        scanf("%d",&pos);
        printf("enter the element:");
        scanf("%d",&element);
        change_pos(head,pos,element);
        output(head);
*/

        //单链表按任意元素查找
/*      printf("enter the find_element:");
        scanf("%d",&element);
        element_find(head,element);
*/

        //按元素修改
/*      printf("enter the element:");
        scanf("%d",&element);
        datatype new_element;
        printf("enter the new_element:");
        scanf("%d",&new_element);
        element_change(head,element,new_element);
        output(head);
*/

        //按元素删除
/*      printf("enter the element:");
        scanf("%d",&element);
        head=element_delete(head,element);
        output(head);

*/

        //逆置
/*      head=Unidirectional_list_inversion(head);
        output(head);
*/

        //查找倒数第n个节点
/*      printf("enter The penultimate NTH node's pos is:");
        scanf("%d",&n);
        Find_penultimate_nth(head,n);
*/

        //单链表排序-冒泡
        single_list_sort(head);
        output(head);


        free_space(head);

        return 0;
}

实现结果

头插

在这里插入图片描述

尾插

在这里插入图片描述

头删

在这里插入图片描述

尾删

在这里插入图片描述

按位置查找

在这里插入图片描述

按位置插入

在这里插入图片描述

按位置删除

在这里插入图片描述

按位置修改

在这里插入图片描述

按元素查找

在这里插入图片描述

按元素修改

在这里插入图片描述

按元素删除

在这里插入图片描述

查找倒数第n个节点

在这里插入图片描述

逆置在这里插入图片描述
排序

在这里插入图片描述

CherylYYYYYY
关注
  • 9
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
嵌入式学习-02-数据结构和算法 (链表)
03-15
嵌入式学习-02-数据结构和算法 (链表)
嵌入式学习-02-数据结构和算法 (数组)
03-15
嵌入式学习-02-数据结构和算法 (数组)
嵌入式学习-数据结构-Day6
m0_56018621的博客
12-27 598
【代码】嵌入式学习-数据结构-Day6。
嵌入式学习DAY20 --- 数据结构（单链表）
SpringWJN的博客
03-22 185
嵌入式入门学习笔记，遇到的问题以及心得体会！ DAY18 笔记： 存储结构：不连续的链式存储 逻辑结构：线性 一对一 运算：创建、增加、删除、修改、排序、销毁 Struct LinkNode //描述每一个节点的 { Data_t data; Struct LinkNode *pNext; }; Struct Link //描述单链表的 { Struct LinkNode *pHead; } 链表的插入： 删除一个节点： 销毁链表： 代码实现： 第一步：编辑一个link.h文件用来定
嵌入式学习DAY20 --- 数据结构（单链表）_ifndef linknode(1)
m0_54903333的博客
04-27 540
int main()//创建一个单链表printf(“创建单链表失败!\n”);return -1;//定义数据结构元素的类型//定义节点的结构体//节点的数据//指向下一个节点的指针}LinkNode;//定义单链表的结构体//指向首节点的指针int count;//}Link;LINK_OK//创建//插入//删除//修改//打印//销毁//倒置//写入。
2024年网安最新嵌入式学习DAY20 --- 数据结构（单链表）_ifndef linknode
2401_84254364的博客
05-03 579
while(pTmp!return;int main()//创建一个单链表printf(“创建单链表失败!\n”);return -1;//定义数据结构元素的类型//定义节点的结构体//节点的数据//指向下一个节点的指针}LinkNode;//定义单链表的结构体//指向首节点的指针int count;//}Link;
最新嵌入式学习DAY20 --- 数据结构（单链表）_ifndef linknode(2)
2401_84301853的博客
05-04 969
while(pTmp!return;int main()//创建一个单链表printf(“创建单链表失败!\n”);return -1;//定义数据结构元素的类型//定义节点的结构体//节点的数据//指向下一个节点的指针}LinkNode;//定义单链表的结构体//指向首节点的指针int count;//}Link;
2024年最全嵌入式学习DAY20 --- 数据结构（单链表）_ifndef linknode
2401_84297560的博客
05-01 117
所以：我们需要做的是在程序刚刚运行起来，还没有对链表有任何操作时，先把文件中的数据先读入链表，然后你可以对链表进行各种操作，等到程序结束之间，你再将链表的全部写入清空后的文件就可以了。3、删除操作：因为我们不可能只把文件中的某一个数据给删掉，我们需要先操作链表，把链表中的某个节点给删掉，然后重新以只写的方式打开文件，此时文件原来的东西就没了，再把整个链表写入文件。2、将插入的元素的值保存到文件中，再次运行时，之前插入的值可以从文件中读出来，继续插入。3、文件不存在，说明之前没有操作过，创建文件。
【嵌入式学习】数据结构-Day2-顺序表
BH6AEV的博客
12-21 1451
在链式存储结构中，线性表的元素在内存中可以是不连续的，通过指针来连接各个元素。：数据元素之间存在一对一的逻辑关系(数组，地铁的座位)头节点无直接前驱，尾节点无直接后继，中间节点存储在唯一的前驱唯一的后继。：数据元素之间存在一对多的逻辑关系(族谱，公司架构)头结点无直接前驱，尾节点无直接后继，中间节点存在唯一的直接前驱，多个后继。线性结构是一种元素之间存在一对一的关系，即每个元素都有唯一的直接前驱和直接后继。线性表：顺序表，链表，数组，栈，队列，字符串。数据类型(整数，小数，字符，字符串，汉字)
嵌入式学习DAY21 --- 数据结构（双向链表、栈、队列）_队列、栈
2401_84264491的博客
04-27 548
第三步：main.c。
嵌入式学习DAY21 --- 数据结构（双向链表、栈、队列）_队列、栈(1)
2301_76223478的博客
04-29 760
return;while(pTmp!第三步：main.cint main()Int count;Int iTop;//栈顶元素的下标，初始值：-1，表示没有元素Int iFront;//队头的下标Int iRear;//队尾的下标Int count;//当前队列的元素个数int iTop;}Stack;
嵌入式学习-01C语言day11
03-14
嵌入式学习-01C语言day11
嵌入式学习-01C语言day07
03-08
嵌入式学习-01C语言day07
嵌入式学习-01C语言day05
03-08
嵌入式学习-01C语言day05
学习整理 docker
最新发布
wonder_dog的博客
05-31 63
nexus。
强化学习——学习笔记3
qq_52302919的博客
05-29 1213
先上图：在上述流程图中所说的Q表即为下表：假设我们在玩一个小游戏，该游戏有上下左右不同的动作，同时也会有不同的状态，比如游戏结束等。Q表也可以称为状态-价值函数QsaQ(s,a)Qsa：这个表格的每一行代表每个 state上述例子中的游戏结束等，每一列代表每个 action上述例子中的上下左右，表格的数值就是在各个 state 下采取各个 action 时能够获得的最大的未来期望奖励。
书籍学习|基于SprinBoot+vue的书籍学习平台(源码+数据库+文档)
JIngJaneIL的博客
05-28 1058
首先,论文一开始便是清楚的论述了平台的研究内容。其次,剖析平台需求分析,弄明白“做什么”,分析包括业务分析和业务流程的分析以及用例分析,更进一步明确平台的需求。然后在明白了平台的需求基础上需要进一步地设计平台,主要包罗软件架构模式、整体功能模块、数据库设计。本项目软件架构选择B/S模式和java技术，总体功能模块运用自顶向下的分层思想。再然后就是实现平台并进行代码编写实现功能。论文的最后章节总结一下自己完成本论文和开发本项目的心得和总结。通过书籍学习平台将会使书籍学习各个方面的工作效率带来实质性的提升。
oracle中的INTERVAL函数学习总结
weixin_42821740的博客
05-30 324
简单学懂interval函数
嵌入式 image-initrd 启动流程
04-01
嵌入式 image-initrd 启动流程如下： 1. 开机自检过程完成后，ROM BIOS 会读取 boot loader，将其加载到系统内存中。 2. boot loader 会读取系统内存中的 kernel image 和 initrd image，并将它们加载到内存中。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值