嵌入式C语言基础链表

什么是链表？
链表其实就是一种数据结构，所谓的数据结构就是数据存放的思想。
数组、链表优缺点：
增加一个元素或者删除一个元素都很难，因为地址是连续的，删除一个元素可能会挪动多个元素，不灵活。但是对于链表来说就很轻松了，链表的每一个节点都是一个结构体，可以通过指针指向的方式将链表串起来，很灵活。

链表和数组的引入：

#include <stdio.h>
#include <stdlib.h>
//只要是通过指针的凡是访问结构体中的数据都要用->
struct Text//用链表的形式存储数据
{int data;struct Text* next;
};
int main()
{int i;int array[]={1,2,3,4};//用数组的方式实现数据的存储,访问到数组的首地址就可以输出整个数组//因为数组的地址是连续的for(i=0;i<sizeof(array)/sizeof(array[0]);i++){printf("%d",array[i]);}putchar('\n');struct Text t1={1,NULL};struct Text t2={2,NULL};struct Text t3={3,NULL};//下面几行代码是将上面定义的几个结构体串起来，形成链表t1.next=&t2;//指针是存放别人的地址t1里的指针变量指向t2的地址t2.next=&t3;//这样就将三个结构体联系了起来printf("use t1 printf four number:\n");printf("%d %d %d\n",t1.data,t1.next->data,t1.next->next->data);//t1.next就是指向t2的一个指针（我理解的就是相当于struct Text * p）//然后通过->这种方式去访问结构体中的数据，然后t1.next->next就是相当于//指向t3的一个指针，也要通过->这种方式去访问里面的数据system("pause");return 0;
}

链表的动态输出：

#include <stdio.h>
#include <stdlib.h>
//只要是通过指针的凡是访问结构体中的数据都要用->
struct Text//用链表的形式存储数据
{int data;struct Text* next;
};void printLink(struct Text *head)//链表的动态输出函数，struct Text *head是链表的头
{struct Text*Point;Point=head;while(Point!=NULL){printf("%d ",Point->data);Point=Point->next;//head是第一个节点的指针，输出完第一个链表的内容后，将链表的头部往后移一个，变为指向第二个节点的指针//head->next是指向下一个链表的头}putchar('\n');}
int main()
{int i;int array[]={1,2,3,4};//用数组的方式实现数据的存储,访问到数组的首地址就可以输出整个数组//因为数组的地址是连续的for(i=0;i<sizeof(array)/sizeof(array[0]);i++){printf("%d",array[i]);}putchar('\n');struct Text t1={1,NULL};struct Text t2={2,NULL};struct Text t3={3,NULL};//下面几行代码是将上面定义的几个结构体串起来，形成链表t1.next=&t2;//指针是存放别人的地址t1里的指针变量指向t2的地址t2.next=&t3;//这样就将三个结构体联系了起来printLink(&t1);//将第一个链表的地址传入动态输出函数system("pause");return 0;
}

链表的查找和节点个数的计算：

#include <stdio.h>
#include <stdlib.h>
//只要是通过指针的凡是访问结构体中的数据都要用->
struct Text//用链表的形式存储数据
{int data;struct Text* next;
};void printLink(struct Text *head)//链表的动态输出函数，struct Text *head是链表的头
{struct Text*Point;Point=head;while(Point!=NULL){printf("%d ",Point->data);Point=Point->next;//head是第一个节点的指针，输出完第一个链表的内容后，将链表的头部往后移一个，变为指向第二个节点的指针//head->next是指向下一个链表的头}putchar('\n');}
void countLink(struct Text* head)//链表计算节点个数函数
{int cont=0;struct Text* Point;Point=head;while(head!=NULL){cont++;head=head->next;}printf("链表节点数为：%d\n",cont);}
void serchLink(struct Text*head,int data)
{while(head!=NULL){if(head->data==data){printf("存在此节点\n");return;}head=head->next;}printf("无此节点\n");
}
int main()
{int i;int input;int array[]={1,2,3,4};//用数组的方式实现数据的存储,访问到数组的首地址就可以输出整个数组//因为数组的地址是连续的for(i=0;i<sizeof(array)/sizeof(array[0]);i++){printf("%d",array[i]);}putchar('\n');struct Text t1={1,NULL};struct Text t2={2,NULL};struct Text t3={3,NULL};//下面几行代码是将上面定义的几个结构体串起来，形成链表t1.next=&t2;//指针是存放别人的地址t1里的指针变量指向t2的地址t2.next=&t3;//这样就将三个结构体联系了起来printLink(&t1);countLink(&t1);printf("请输入要查找的节点：\n");scanf("%d",&input);serchLink(&t1,input);system("pause");return 0;
}

从指定节点后插入节点：

#include <stdio.h>
#include <stdlib.h>
//只要是通过指针的凡是访问结构体中的数据都要用->
struct Text//用链表的形式存储数据
{int data;struct Text* next;
};void printLink(struct Text *head)//链表的动态输出函数，struct Text *head是链表的头
{struct Text*Point;Point=head;while(Point!=NULL){printf("%d ",Point->data);Point=Point->next;//head是第一个节点的指针，输出完第一个链表的内容后，将链表的头部往后移一个，变为指向第二个节点的指针//head->next是指向下一个链表的头}putchar('\n');}
void countLink(struct Text* head)//链表计算节点个数函数
{int cont=0;struct Text* Point;Point=head;while(head!=NULL){cont++;head=head->next;}printf("链表节点数为：%d\n",cont);}
void serchLink(struct Text*head,int data)
{while(head!=NULL){if(head->data==data){printf("存在此节点\n");return;}head=head->next;}printf("无此节点\n");
}void InsertFromBhind(struct Text*head,struct Text*newLink,int data)
{struct Text* Point;Point=head;while(Point!=NULL){if(Point->data==data){newLink->next=Point->next;//head->next是插入位置后一个节点的指针，就是head->next指向插入位置的后一个节点Point->next=newLink;//修改插入位置前一个节点内的指针指向，指向新节点的地址，将链表串起来printLink(head);return;}Point=Point->next;}printf("无此节点\n");
}
int main()
{int i;int input;int link;struct Text t1={1,NULL};struct Text t2={2,NULL};struct Text t3={3,NULL};struct Text t4={4,NULL};//下面几行代码是将上面定义的几个结构体串起来，形成链表t1.next=&t2;//指针是存放别人的地址t1里的指针变量指向t2的地址t2.next=&t3;//这样就将三个结构体联系了起来printLink(&t1);countLink(&t1);printf("请输入要查找的节点：\n");scanf("%d",&input);serchLink(&t1,input);printf("请输入在哪个节点后插入；\n");scanf("%d",&link);InsertFromBhind(&t1,&t4,link);system("pause");return 0;
}

在指定节点前插入节点：

#include <stdio.h>
#include <stdlib.h>
//只要是通过指针的凡是访问结构体中的数据都要用->
struct Text//用链表的形式存储数据
{int data;struct Text* next;
};void printLink(struct Text *head)//链表的动态输出函数，struct Text *head是链表的头
{struct Text*Point;Point=head;while(Point!=NULL){printf("%d ",Point->data);Point=Point->next;//head是第一个节点的指针，输出完第一个链表的内容后，将链表的头部往后移一个，变为指向第二个节点的指针//head->next是指向下一个链表的头}putchar('\n');}
void countLink(struct Text* head)//链表计算节点个数函数
{int cont=0;struct Text* Point;Point=head;while(head!=NULL){cont++;head=head->next;}printf("链表节点数为：%d\n",cont);}
void serchLink(struct Text*head,int data)
{while(head!=NULL){if(head->data==data){printf("存在此节点\n");return;}head=head->next;}printf("无此节点\n");
}
void InsertFromBefore(struct Text*head,struct Text*newlink,int data)
{struct Text*Point;Point=head;if(head!=NULL && head->data==data){newlink->next=head;printLink(newlink);return;}while(Point->next!=NULL){//因为是在指定节点前插入节点//所以要通过指定节点的前一个节点插入//Point就是指向，指定节点前一个节点的指针//Point->next是指向，指定的插入节点的指针，也就是在这个节点前插入节点if(Point->next->data==data){newlink->next=Point->next;Point->next=newlink;printLink(head);return;}Point=Point->next;}
}int main()
{int i;int input;int link;struct Text t1={1,NULL};struct Text t2={2,NULL};struct Text t3={3,NULL};struct Text t4={4,NULL};//下面几行代码是将上面定义的几个结构体串起来，形成链表t1.next=&t2;//指针是存放别人的地址t1里的指针变量指向t2的地址t2.next=&t3;//这样就将三个结构体联系了起来printLink(&t1);countLink(&t1);printf("请输入要查找的节点：\n");scanf("%d",&input);serchLink(&t1,input);printf("请输入在哪个节点前插入；\n");scanf("%d",&link);InsertFromBefore(&t1,&t4,link);system("pause");return 0;
}

静态链表的删除和修改：

#include <stdio.h>
#include <stdlib.h>
//只要是通过指针的凡是访问结构体中的数据都要用->
struct Text//用链表的形式存储数据
{int data;struct Text* next;
};void printLink(struct Text *head)//链表的动态输出函数，struct Text *head是链表的头
{struct Text*Point;Point=head;while(Point!=NULL){printf("%d ",Point->data);Point=Point->next;//head是第一个节点的指针，输出完第一个链表的内容后，将链表的头部往后移一个，变为指向第二个节点的指针//head->next是指向下一个链表的头}putchar('\n');}
void countLink(struct Text* head)//链表计算节点个数函数
{int cont=0;struct Text* Point;Point=head;while(head!=NULL){cont++;head=head->next;}printf("链表节点数为：%d\n",cont);}
void serchLink(struct Text*head,int data)//查找函数
{while(head!=NULL){if(head->data==data){printf("存在此节点\n");return;}head=head->next;}printf("无此节点\n");
}void changeLink(struct Text*head,int data,int data2)//改函数
{struct Text*Point=head;while(Point!=NULL){if(Point->data==data){printf("此节点存在可改\n");Point->data=data2;printLink(head);return;}Point=Point->next;}printf("无此节点\n");
}void delLink(struct Text*head,int data)
{struct Text*Point=head;if(head->data==data){head=head->next;//将第二个节点指定为数组头，那么第一个节点就需要释放掉避免造成内存泄漏//free(Point);   //将这个地址释放掉，可以通过Point指针将之前的head的内存空间释放掉//free可以将指针指向的内存空间释放掉，但是释放掉之后最好将指针指向NULL//因为free只是把指针所指的内存给释放掉，但并没有把指针本身干掉。//free只能释放malloc开辟的内存空间printLink(head);return;}while(Point->next!=NULL){//head->next是指向要删除的那个节点的指针if(Point->next->data==data){Point->next=Point->next->next;//如果是动态创建，就要新定义一个指针//通过新定义的指针把(Ponit->next)free掉printLink(head);return;}Point=Point->next;}printf("没有找到\n");
}
int main()
{int i;int input;int link;struct Text t1={1,NULL};struct Text t2={2,NULL};struct Text t3={3,NULL};struct Text t4={4,NULL};//下面几行代码是将上面定义的几个结构体串起来，形成链表t1.next=&t2;//指针是存放别人的地址t1里的指针变量指向t2的地址t2.next=&t3;//这样就将三个结构体联系了起来printLink(&t1);countLink(&t1);printf("请输入要查找的节点：\n");scanf("%d",&input);serchLink(&t1,input);printf("请输入要删除哪个节点；\n");scanf("%d",&link);delLink(&t1,link);printf("修改哪个节点；\n");scanf("%d",&link);changeLink(&t1,link,100);//这些所有的函数并不修改main函数中的节点system("pause");return 0;
}

链表的动态创建之头插法（每插进来一个节点就将它当做头结点，就像栈一样）

#include <stdio.h>
#include <stdlib.h>struct Text
{int data;struct Text*next;
};
void printLink(struct Text *head)//链表的动态输出函数，struct Text *head是链表的头
{struct Text*Point;Point=head;while(Point!=NULL){printf("%d ",Point->data);Point=Point->next;//head是第一个节点的指针，输出完第一个链表的内容后，将链表的头部往后移一个，变为指向第二个节点的指针//head->next是指向下一个链表的头               }putchar('\n');}
struct Text *creatFromHead(struct Text*head,struct Text*newnode)//节点头插法插入函数
//节点创建函数和插入节点函数分开写，有利于后面节点的插入
{if(head==NULL){head=newnode;}else{newnode->next=head;head=newnode;}return head;
}
struct Text*creatLink(struct Text*head)//链表节点创建函数
{struct Text*newnode=NULL;while(1){//不断创建新的节点，直到输入的数字为0newnode=(struct Text*)malloc(sizeof(struct Text));newnode->next=NULL;printf("请输入data：\n");scanf("%d",&(newnode->data));if(newnode->data==0){free(newnode);//新创建的节点里的data等于0;所以不把他插入链表中//将它指向的内存空间释放掉printf("链表创建结束\n");return head;}head=creatFromHead(head,newnode);}
}
int main()
{struct Text *head=NULL;printLink(creatLink(head));system("pause");return 0;
}

尾插法插入节点：

#include <stdio.h>
#include <stdlib.h>struct Text
{int data;struct Text*next;
};
void printLink(struct Text *head)//链表的动态输出函数，struct Text *head是链表的头
{struct Text*Point;Point=head;while(Point!=NULL){printf("%d ",Point->data);Point=Point->next;//head是第一个节点的指针，输出完第一个链表的内容后，将链表的头部往后移一个，变为指向第二个节点的指针//head->next是指向下一个链表的头               }putchar('\n');}
struct Text *insertFromBehind(struct Text*head,struct Text*newnode)//节点尾插法插入函数
{struct Text* p=NULL;p=head;if(p==NULL){//如果没有这句话，如果P为空指针，继续往下执行p->next对空指针进行操作，会出现段错误head=newnode;return head;}while(p->next!=NULL){p=p->next;}p->next=newnode;return head;
}
struct Text*creatLink(struct Text*head)//链表节点创建函数
{struct Text*newnode=NULL;while(1){//不断创建新的节点，直到输入的数字为0newnode=(struct Text*)malloc(sizeof(struct Text));newnode->next=NULL;printf("请输入data：\n");scanf("%d",&(newnode->data));if(newnode->data==0){free(newnode);//新创建的节点里的data等于0;所以不把他插入链表中//将它指向的内存空间释放掉printf("链表创建结束\n");return head;}head=insertFromBehind(head,newnode);}
}
int main()
{struct Text *head=NULL;printLink(creatLink(head));system("pause");return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/272276.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

docker pull 从仓库拉取镜像

docker pull 从仓库拉取镜像

docker pull 要拉取的镜像名 等价于 docker pull 要拉取的镜像名:lastest 拉取固定的镜像&#xff1a;docker pull 要拉取的镜像名:版本号 省略lastest表设计就是拉取的最新的
阅读更多...
理解js中的原型链，prototype与__proto__的关系

理解js中的原型链，prototype与__proto__的关系

说到prototype&#xff0c;就不得不先说下new的过程。 我们先看看这样一段代码&#xff1a; 1<script type"text/javascript">2 var Person function () { };3 var p new Person();4</script>很简单的一段代码&#xff0c;我们来看看这个new究竟做了什…
阅读更多...
C#抓取网页HTML内容

C#抓取网页HTML内容

using System; using System.Collections.Generic; using System.Linq; using System.Web; using System.Net; using System.Text; using System.IO; using System.Text.RegularExpressions; namespace Web { /// <summary> /// 公共方法类 /// </summary> p…
阅读更多...
项目一感应垃圾桶(Wemos)

项目一感应垃圾桶(Wemos)

硬件材料&#xff1a; Wemos D1、SG90舵机、HC-SR04、杜邦线若干、蜂鸣器3.3V&#xff08;可有可无&#xff09; 软件材料&#xff1a; arduino IDE编译器、USB转串口驱动 Wemos D1&#xff1a; 特性&#xff1a; 基于ESP-8266EX及arduino做的一个融合arduino兼容&#xff0…
阅读更多...
docker删除本地所有镜像

docker删除本地所有镜像

docker rmi -f ${docker images -qa}
阅读更多...
PAT1069. The Black Hole of Numbers

PAT1069. The Black Hole of Numbers

//这是到水题&#xff0c;之前因为四位数的原因一直不能A&#xff0c;看了别人的程序&#xff0c;才明白&#xff0c;不够四位的时候没考虑到&#xff0c;坑啊。。。。。脸打肿 #include<cstdio>#include<algorithm>using namespace std;int main(){ //freopen(&qu…
阅读更多...
WiFi避障小车

WiFi避障小车

硬件清单&#xff1a; Wemos D1&#xff08;支持AP模式也就是路由模式和STA模式也就是上网设备&#xff09;、超声波模块、小车、L9110s步进电机控制器 软件&#xff1a; eclipse、arduino IDE WiFi配置参考博文 ESP8266WiFi库: 从上图中可以看出ESP8266WiFi库主要包含Stati…
阅读更多...
yum常用命令整理

yum常用命令整理

yum命令的形式一般如下。要说明的是以下演示中所使用到的PACKAGE、GROUP都是变量&#xff0c;需要保证运行yum命令的主机能连接外网&#xff0c;否则大部分命令将由于没有网络连接而不能输出结果。yum [options] [command] [package]#以下演示中大写的单词是变量1.安装操作yum …
阅读更多...
CSS3 2D 转换

CSS3 2D 转换

CSS3 2D 转换 先看兼容性 transform属性向应用元素应用2d 或者 3d装换&#xff1b;该属性允许我们进行旋转&#xff0c;缩放&#xff0c;移动或者倾斜&#xff1b; 基本语法&#xff1a; transform: none|transform-functions;transform-function&#xff1a;这东东有n的函数可…
阅读更多...
程序猿最喜欢说的30句话

程序猿最喜欢说的30句话

虽然代码总会有这个那个问题&#xff0c;但程序猿却总有谜一般的从容和自信。上图来自&#xff1a;《当程序出问题时程序员最喜欢说的30句话》来看看程序猿经常说的话&#xff1a;1、在我的电脑上是正常的啊。。。2、不可能出现这种情况的3、快了&#xff0c;已经完成了90%。4、…
阅读更多...
linux环境下Ncurses实现贪吃蛇游戏

linux环境下Ncurses实现贪吃蛇游戏

游戏说明&#xff1a; linux环境下基于Ncurses图形库的C语言小游戏。 Ncurses介绍&#xff1a; Ncurses(new curses)是一套编程库&#xff0c;它提供了一系列的函数以便使用者调用它们去生成基于文本的用户界面。 Ncurses是一个能提供功能键定义(快捷键),屏幕绘制以及基于文本…
阅读更多...
docker镜像底层是文件联合系统

docker镜像底层是文件联合系统

阅读更多...
韩顺平循序渐进学java 第13讲 抽象类.接口

韩顺平循序渐进学java 第13讲 抽象类.接口

13.1抽象类 13.1.1 概念 当父类的一些方法不能确定时&#xff0c;可以用abstract关键字来修饰该方法&#xff0c;称为抽象方法&#xff0c;用abstract来修饰该类&#xff0c;称为抽象类。 13.1.2 抽象类-深入讨论 抽象类是java中一个比较重要的类&#xff1a; 1、用abstract关键…
阅读更多...
C#实现简体繁体转换代码示例

C#实现简体繁体转换代码示例

//简体转繁体 public static string _ConvertChinTrad(string strInput) { EncodeRobert edControl new EncodeRobert(); string strResult ""; if (strInput null) return strResult; if (strInput.ToString().Length > 1) strResult edControl.SCTCConvert(…
阅读更多...
java基础JDK的安装和环境变量的配置

java基础JDK的安装和环境变量的配置

JRE和JDK&#xff1a; JRE是java程序运行时环境&#xff0c;包含JVM&#xff08;相当于java在不同操作系统上运行时java和操作系统之间的翻译&#xff0c;保证java程序的跨平台&#xff09;和运行时所需要的核心库。所以我们想要运行一个已有的java程序&#xff0c;那么只需要…
阅读更多...
docker镜像为什么要采用分层结构

docker镜像为什么要采用分层结构

阅读更多...
C#通过SMTP发送邮件代码示例

C#通过SMTP发送邮件代码示例

1、新建SMTP.cs类库文件 public class SMTP { /// <summary> /// SMTP服务器 /// </summary> public string smtp { get; set; } /// <summary> /// SMTP服务器端口 /// </summary> public int port { get; set; } /// <summary> /// 发件人 ///…
阅读更多...
docker下载tomact

docker下载tomact

docker run -it -p 8080:8080 tomcat 比如下载tomcat,你现在去访问&#xff0c;先访问docker里面的tomcat, 左边的8080是对外暴露的服务端口&#xff0c;对应着右边的8080是tomact的实际端口 下载tomcat 启动tomcat docker run -it -p 8080:8080 tomcat
阅读更多...
Wijmo 2016年蓝图

Wijmo 2016年蓝图

2015年很快就过去了&#xff0c;这是 Wijmo 重要的一年&#xff0c;尤其是对 Wijmo5。脱离传统的小部件&#xff0c;重新写一套 JS 控件&#xff0c;现在看来这个决定是正确的。用 TypeScript 写 Wijmo5&#xff0c;意味着我们没有任何依赖&#xff0c;不再需要 jQuery&#xf…
阅读更多...
IDEA安装和运行HelloWorld

IDEA安装和运行HelloWorld

IDEA安装&#xff1a; IDEA中Hello World步骤&#xff1a; ① ②点击创建空项目&#xff0c;下一步 ③ ④在打开后会弹出以下界面&#xff0c;然后点击新建模块 ⑤点击新建模块后出现以下界面&#xff0c;选择java并选择JDK的安装路径。 ⑥然后修改模块名称&#xff0c;点击…
阅读更多...
最新文章

Copyright @ 2022~2023