嵌入式学习-线性表Day02-链表

最新推荐文章于 2024-10-09 17:30:46 发布
最新推荐文章于 2024-10-09 17:30:46 发布
阅读量175 收藏 5
点赞数 1
文章标签： 学习 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Xiaomo1536/article/details/142791778
版权

链表

特点:内存不连续，通过指针进行连接

解决：长度固定问题，插入、删除麻烦的问题

1）逻辑结构 ： 线性结构

2）存储结构 ：链式存储

3）操作 ： 增删改查

单向链表

结构体：

struct node_t

{

int data;//数据域

struct node_t * next;//指针域，存放下一个节点地址

}；

分类

1）有头单向链表

存在一个头节点，数据域无效，指针域有效

遍历有头单向链表：

#include<stdio.h>
typedef struct node_t
{
    int data;
    struct node_t *next;
}link_node_t,* link_list_t;
//link_list_t == link_node_t *
int main(int argc, char const *argv[])
{
    //1.定义3个节点
    link_node_t a = {1,NULL};
    link_node_t b = {2,NULL};
    link_node_t c = {3,NULL};
    //2.将节点进行连接
    a.next = &b;
    b.next = &c;
    //3.定义一个头节点指向第一个节点
    link_node_t s ;
    s.next = &a;
    //4.定义一个头指针指向头结点
    // link_node_t * h = &s;
    
    link_list_t h = &s;
    //5.遍历有头单向链表
    //方法1：直接遍历有头单向链表
    /*
    while(h->next != NULL)
    {
        h=h->next;
        printf("%d ",h->data);
    }
    
    */
   //方法2：先变成无头，再遍历
   h=h->next;
   while (h!= NULL)
   {
     printf("%d ",h->data);
     h=h->next;
   }
   printf("\n");

    return 0;
}
2）无头单向链表

所有节点的数据域、指针域都有效

遍历无头单向链表：

#include<stdio.h>
typedef struct node_t
{
    int data;
    struct node_t *next;
}link_node_t,* link_list_t;
//link_list_t == link_node_t *
int main(int argc, char const *argv[])
{
    //1.定义3个节点
    link_node_t a = {1,NULL};
    link_node_t b = {2,NULL};
    link_node_t c = {3,NULL};
    //2.将节点进行连接
    a.next = &b;
    b.next = &c;

    //3.定义一个头指针指向第一个结点
    // link_node_t * h = &a;
    
    link_list_t h = &a;

    //4.遍历无头单向链表
    while(h != NULL)
    {
        printf("%d ",h->data);
        h=h->next; 
    }
    printf("\n");

    return 0;
}

操作函数

linklist.h

#ifndef _LINKLIST_H_
#define _LINKLIST_H_

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

typedef int datatype;
typedef struct node_t
{
	datatype data;//数据域
	struct node_t *next;//指针域,指向自身结构体的指针
}link_node_t,*link_list_t;

//1.创建一个空的单向链表(有头单向链表)
link_node_t *CreateEpLinkList();
//2.向单向链表的指定位置插入数据
//p保存链表的头指针 post 插入的位置 data插入的数据
int InsertIntoPostLinkList(link_node_t *p,int post, datatype data);
//3.遍历单向链表
void ShowLinkList(link_node_t *p);
//4.求单向链表长度的函数
int LengthLinkList(link_node_t *p);
//5.删除单向链表中指定位置的数据 post 代表的是删除的位置
int DeletePostLinkList(link_node_t *p, int post);
//6.判断单向链表是否为空 1代表空 0代表非空
int IsEpLinkList(link_node_t *p);
//7.修改指定位置的数据 post 被修改的位置 data修改成的数据
int ChangePostLinkList(link_node_t *p, int post, datatype data);
//8.查找指定数据出现的位置 data被查找的数据 //search 查找
int SearchDataLinkList(link_node_t *p, datatype data);
//9.删除单向链表中出现的指定数据,data代表将单向链表中出现的所有data数据删除
int DeleteDataLinkList(link_node_t *p, datatype data);
//10.转置链表
void ReverseLinkList(link_node_t *p);
//11.清空单向链表
void ClearLinkList(link_node_t *p);
#endif
1）创建一个空的（有头）单向链表

2）向post位置插入一个数据

  1. 先遍历找到要插入节点的前一个节点，假设这个节点为A；A的下一个节点为B；将C插入A与B之间；
  2. 先让C的指针域指向B；
  3. 再让A的指针域指向C；

（注意：顺序不可以调换）

3）删除指定位置的数据

4）单向链表的转置

转置的思想：

(1) 将头节点与当前链表断开，断开前保存下头节点的下一个节点，保证后面链表能找得到，定义一个q保存头节点的下一个节点，断开后前面相当于一个空的链表，后面是一个无头的单向链表

(2) 遍历无头链表的所有节点，将每一个节点当做新节点插入空链表头节点的下一个节点(每次插入的头节点的下一个节点位置)

linklist.c

#include "linklist.h"

// 1.创建一个空的单向链表(有头单向链表)
link_node_t *CreateEpLinkList()
{
    // 1.开辟空间用来存放头结点
    link_list_t p = (link_list_t)malloc(sizeof(link_node_t));
    if (p == NULL)
    {
        perror("CreateEpLinkList ERR");
        return NULL;
    }
    // 2.初始化
    p->next = NULL;
    return p;
}
// 4.求单向链表长度的函数
int LengthLinkList(link_node_t *p)
{
    int num = 0;
    while (p->next != NULL)
    {
        p = p->next;
        num++;
    }
    return num;
}
// 2.向单向链表的指定位置插入数据
// p保存链表的头指针 post 插入的位置 data插入的数据
int InsertIntoPostLinkList(link_node_t *p, int post, datatype data)
{
    // 0.容错判断
    if (post < 0 || post > LengthLinkList(p))
    {
        perror("InsertIntoPostLinkList err");
        return -1;
    }
    // 1.将头指针指向被插入位置的前一个节点
    for (int i = 0; i < post; i++)
        p = p->next;
    // 2.创建一个新节点，存放数据
    link_list_t pnew = (link_list_t)malloc(sizeof(link_node_t));
    if (pnew == NULL)
    {
        perror("pnew malloc err");
        return -1;
    }
    pnew->data = data;
    pnew->next = NULL;
    // 3.将新节点插入链表中（先连后面，再连前面）
    pnew->next = p->next;
    p->next = pnew;
    return 0;
}
//6.判断单向链表是否为空 1代表空 0代表非空
int IsEpLinkList(link_node_t *p)
{
    return p->next == NULL;
}
// 5.删除单向链表中指定位置的数据 post 代表的是删除的位置
int DeletePostLinkList(link_node_t *p, int post)
{
    // 0.容错判断
    if (post < 0 || post >= LengthLinkList(p))
    {
        perror("DeletePostLinkList err");
        return -1;
    }
    // 1.将头指针指向被删除位置的前一个节点
    for (int i = 0; i < post; i++)
        p = p->next;
    // 2.进行删除操作
    // 1）定义一个指针pdel指向被删除位置
    link_list_t pdel = p->next;
    // 2）跨过被删除节点
    p->next = pdel->next;
    // 3）释放被删除节点
    free(pdel);
    pdel = NULL;
    return 0;
}
//3.遍历单向链表
void ShowLinkList(link_node_t *p)
{
    while (p->next !=NULL)
    {
        p=p->next;
        printf("%d ",p->data);
    }
    printf("\n");
    
}
//7.修改指定位置的数据 post 被修改的位置 data修改成的数据
int ChangePostLinkList(link_node_t *p, int post, datatype data)
{
    //0.容错判断
    if(post < 0 || post >=LengthLinkList(p))
    {
        perror("ChangePostLinkList");
        return -1;
    }
    //1.将头指针指向被修改的节点
    for(int i=0;i<=post;i++)
        p=p->next;
    //2.修改数据
    p->data = data;
    return 0;

}
//8.查找指定数据出现的位置 data被查找的数据 //search 查找
int SearchDataLinkList(link_node_t *p, datatype data)
{
    //1.定义变量记录查找位置
    int post=0;
    //2.遍历链表，查找数据
    while(p->next != NULL)
    {
        p=p->next;
        if(p->data == data)
            return post;
        post++;
    }
    return -1;
}
//9.删除单向链表中出现的指定数据,data代表将单向链表中出现的所有data数据删除
int DeleteDataLinkList(link_node_t *p, datatype data)
{
    //1.定义一个指针q指向头结点的写一个节点，此时可以看做q指向一个无头单向链表
    link_list_t q = p->next;
    //2.用q遍历链表，将每一个节点的数据域与data作比较，如果相同就删除该节点
    while(q != NULL)
    {
        if(q->data == data)//如果相等，删除
        {
            p->next = q->next;
            free(q);
            q = p->next;
        }
        else//如果不相等，指针向后移动
        {
            p=p->next;
            q=p->next;
        }
    }
    return 0;
}
//11.清空单向链表
void ClearLinkList(link_node_t *p)
{
    while (!IsEpLinkList(p))
        DeletePostLinkList(p,0);
    
}
//10.转置链表
//解题思想：
//(1) 将头节点与当前链表断开，断开前保存下头节点的下一个节点，
//保证后面链表能找得到，定义一个q保存头节点的下一个节点，
//断开后前面相当于一个空的链表，后面是一个无头的单向链表

//(2) 遍历无头链表的所有节点，将每一个节点当做新节点
//插入空链表头节点的下一个节点(每次插入的头节点的下一个节点位置)
void ReverseLinkList(link_node_t *p)
{
    //1.断开前
    link_list_t q = p->next;
    link_list_t temp = NULL;
    //2.断开链表
    p->next = NULL;
    //3.遍历无头单向链表，依次插入头节点后面
    while ( q != NULL)
    {
        temp = q->next;
        q->next = p->next;
        p->next = q;
        q = temp;

    }
    
}

main.c

#include"linklist.h"
int main(int argc, char const *argv[])
{
    link_list_t p = CreateEpLinkList();

    for(int i=0;i<5;i++)
        InsertIntoPostLinkList(p,i,i+1);
    ShowLinkList(p);//1 2 3 4 5
    DeletePostLinkList(p,0);
    ShowLinkList(p);//2 3 4 5
    ReverseLinkList(p);
    ShowLinkList(p);//5 4 3 2 
    DeleteDataLinkList(p,3);
    ShowLinkList(p);//5 4 2
    printf("%d post is %d\n",5,SearchDataLinkList(p,5));//0
    while (!IsEpLinkList(p))
       DeletePostLinkList(p,0);
    free(p);
    p=NULL;
    return 0;
}

单向循环链表

解决约瑟夫问题

约瑟夫问题为：设编号为1，2，……n得n个人围坐一圈，约定编号为k（k大于等于1并且小于等于n）的人从1开始报数，数到m的那个人出列。它的下一位继续从1开始报数，数到m的人出列，依次类推，最后剩下一个为猴王。

直接上图展示，初始化状态： 假设n=6，总共有6个人，k=1,从第一个人开始报数，m=5,每次数五个。

  第一次报数：从一号开始，数五个数，1-2-3-4-5，数完五个数，五号被杀死，第一次报数后，剩余人数如下。

第二次报数： 从被杀死的五号的下一位开始报数，也就是六号，数五个数，6-1-2-3-4，数数完毕，四号被杀死，第二次报数后，剩余人数如下

第三次报数： 从被杀死的四号的下一位开始报数，同样是六号，数五个数，6-1-2-3-6，数数完毕，六号被杀死，第三次报数后，剩余人数如下。

第四次报数： 从被杀死的六号的下一位开始报数，也就是一号，数五个数，1-2-3-1-2，数数完毕，二号被杀死，第四次报数后，剩余人数如下。

第五次报数： 从被杀死的二号的下一位开始报数，也就是三号，数五个数，3-1-3-1-3，数数完毕，三号被杀死，只剩下一号

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

typedef struct node_t
{
	int data;
	struct node_t *next;
}link_node_t,*link_list_t;

int main(int argc, const char *argv[])
{
	int i;
	link_list_t pdel = NULL;//用于指向被删除节点
	link_list_t ptail = NULL;//永远指向当前链表的尾 
	link_list_t pnew = NULL;//永远指向新创建的节点
	link_list_t h = NULL;
	int all_num = 7;//猴子总数 
	int start_num = 2; //从几号猴子开始数
	int kill_num = 3;//数到几杀死猴
	// printf("请您入猴子总数 起始号码 数到几杀死:\n");
	// scanf("%d%d%d",&all_num,&start_num,&kill_num);
	//1.创建出一个单向循环链表
	//(1)创建有all_num个节点的单向链表
	h = (link_list_t)malloc(sizeof(link_node_t));
	if(NULL == h)
	{
		perror("malloc failed");
		return -1;
	}
	h->data = 1;
	h->next = NULL;
	ptail = h;//尾指针指向当前的第一个节点
	for(i = 2; i <= all_num; i++)
	{
		//创建新的节点
		pnew = (link_list_t)malloc(sizeof(link_node_t));
		if(NULL == pnew)
		{
			perror("malloc failed");
			return -1;
		}
		//将新节点装上数据
		pnew->data = i;
		pnew->next = NULL;
		//将新节点链接到链表尾 
		ptail->next = pnew;//链接到链表的尾
		ptail = pnew;//尾指针继续指向当前链表的尾 
	}
	//(2)将头指针保存到链表的尾形成单向循环链表
	ptail->next = h;//形成单向循环链表 
#if 0 //用于调试程序
	while(1)
	{
		printf("%d\n",h->data);
		h = h->next;
		sleep(1);
	}
#endif
	//2.开始杀猴子 
	//(1)将头指针移动到开始猴子的号码处 
	for(i = 0; i < start_num-1; i++)
		h = h->next;
	//(2)循环进行杀猴子
	while(h != h->next)//条件不成的时候，就剩一个猴子,只有一个节点
	{
		//将头指针移动到即将删除节点的前一个节点
		for(i = 0; i < kill_num-2; i++)
			h = h->next;

		pdel = h->next;
		//跨过删除节点
		h->next = pdel->next;
		printf("kill is -------------%d\n",pdel->data);
		free(pdel);
		pdel = NULL;
		//杀死猴子猴，从下一个节点开始继续开始数,将头指针移动到开始数的地方
		h = h->next;
	}
	printf("king is=================== %d\n",h->data);
	return 0;
}

总结：

顺序表和链表的区别

(1)顺序表在内存当中连续存储的(数组)，但是链表在内存当中是不连续存储的，通过指针将数据链接在一起

  1. 顺序表的长度是固定的，但是链表长度不固定
  2. 顺序表查找方便，但是插入和删除麻烦，链表，插入和删除方便，查找麻烦
沐泽Mu
关注
2024年网安最新嵌入式学习DAY21 --- 数据结构（双向链表、栈、队列）_队列、栈
2401_84302761的博客
05-01 66
/栈顶元素的下标，初始值：-1，表示没有元素。Int count;//当前队列的元素个数。Int iFront;Int iRear;第三步：main.c。
嵌入式学习--线性表Day01
Xiaomo1536的博客
09-27 247
/位置 代表的是第几个位置，数组元素下标 位置的编号从0开始 position。int n//n代表的是数组中有效的元素个数（非数组的长度size 100）8。下滑线法：create_empty_seqlist。小驼峰法：createEmptySeqList。大驼峰法：CreateEmptySeqList。顺序表的长度是固定的 #define N 5。顺序表的插入和删除麻烦，查找、修改比较简单的。//插入到数组中的数据。int *p //保存的数组的首地址。//1)向数组的第几个位置插入数据。
嵌入式学习-线性表Day03-栈
Xiaomo1536的博客
10-09 76
的线性表（又称为堆栈），进行插入和删除操作的一端称为栈顶，另一端称为栈底。1.存储结构不同，顺序栈相当于数组，连续的，链式栈 链表非连续的。先进后出 FILO first in last out FILO。2.顺序栈的长度受限制，而链栈不会。只能在一端进行插入和删除操作。顺序栈和链式栈的区别是什么？1）逻辑结构：线性结构。2）存储结构：顺序存储。3）操作：入栈、出栈。
嵌入式学习-线性表-Day04-队列
最新发布
Xiaomo1536的博客
10-09 408
队列1 什么是队列？只允许在两端进行插入和删除操作的线性表，在队尾插入，在队头删除插入的一端，被称为队尾，删除的一端被称为队头在队列操作过程中，为了提高效率，以调整指针代替队列元素的移动，并将数组作为循环队列的操作空间。2队列的特点先进先出后进后出LILO last循环队列顺序队列）1逻辑结构线性结构2存储结构顺序存储3操作入队出队int rear;//后面，队尾int front;//前面，队头}sequeue_t；//sequence。
嵌入式学习day16(链表)
m0_37565374的博客
03-16 132
链表概念
嵌入式学习DAY21 --- 数据结构（双向链表、栈、队列）_队列、栈、双向链表
2401_84247617的博客
05-04 748
while(pTmp!第三步：main.cint main()Int count;Int iTop;//栈顶元素的下标，初始值：-1，表示没有元素Int iFront;//队头的下标Int iRear;//队尾的下标Int count;//当前队列的元素个数。
【嵌入式学习】数据结构-Day2-顺序表
BH6AEV的博客
12-21 1539
在链式存储结构中，线性表的元素在内存中可以是不连续的，通过指针来连接各个元素。：数据元素之间存在一对一的逻辑关系(数组，地铁的座位)头节点无直接前驱，尾节点无直接后继，中间节点存储在唯一的前驱唯一的后继。：数据元素之间存在一对多的逻辑关系(族谱，公司架构)头结点无直接前驱，尾节点无直接后继，中间节点存在唯一的直接前驱，多个后继。线性结构是一种元素之间存在一对一的关系，即每个元素都有唯一的直接前驱和直接后继。线性表：顺序表，链表，数组，栈，队列，字符串。数据类型(整数，小数，字符，字符串，汉字)
嵌入式学习DAY21 --- 数据结构（双向链表、栈、队列）
SpringWJN的博客
03-22 318
嵌入式入门学习笔记，遇到的问题以及心得体会！ DAY21 笔记： 1、双向链表 Struct DoubleLinkNode { Struct DoubleLinkNode *pPri; Data_t data; Struct DoubleLinkNode *pNext; }; Struct DoubleLink { Struct DoubleLinkNode *pHead; Int count; } 头插： pNode->pNext = pHead; pHead->pPri = pNod
华清远见嵌入式学习day08——线性表
UemTuBXuR的博客
03-19 335
【线性表】 线性表的特征： 1) 对非空表,a0是表头,无前驱； 2) an-1是表尾,无后继； 3) 其它的每个元素ai有且仅有一个直接前驱(ai-1)和一个直接后继(ai+1)。 【顺序存储结构】 数组 空间先固定好， 连续存储 优点：遍历（查找）方便; 不足：插入和删除时间复杂度差； 一种模型【顺序表】 #define N 10 struct list{ ...
Linux嵌入式开发学习 c++:day5
haogewudi666的博客
07-17 388
【私有继承】 基类的public成员和protected成员被继承后作为派生类的私有成员。 默认的继承是私有继承。 为了保证基类的部分外部接口特征能够在派生类中也存在，就必须在派生类中国重新定义同名的成员函数（重载）。 【保护继承】 基类的public和protected成员都以保护成员的身份出现在派生类中。 保护级别的成员，除了自己的类内可以访问以外，其派生类也可以访问。 【多态】 首先来看面向对象（OOP）的三大特征： 封装wrap：实现细节隐藏，使得代码模块化。把成员..
Linux下C++轻量级Web服务器
qq_40808423的博客
04-06 5950
系统框架 使用线程池 + 非阻塞socket + epoll(ET和LT均实现) + 事件处理(Reactor和模拟Proactor均实现)的并发模型 使用状态机解析HTTP请求报文，支持解析GET和POST请求 访问服务器数据库实现web端用户注册、登录功能，可以请求服务器图片和视频文件 利用单例模式与阻塞队列实现异步的日志系统，记录服务器运行状态； 经Webbench压力测试可以实现上万的并发连接数据交换 利用标准库容器封装char，实现自动增长的缓冲区； ..
笔试面试题集（java）
热门推荐
csdnZCjava的博客
06-29 3万+
前言 本书为自己的面试试题和收藏自认为比极好的题目，整理归类在word文档中。然后复制到csdn中，涵盖了java面试中出现的各个知识点，包括java语言基础、数据库、web编程、框架等。其中每个部分都按小知识点进行笔试面试题整理，并在题后紧跟详细的分析步骤和解答。 目录 前言 第一部分：JAVA基础 1.1 JAVA语言基础 1.2 JAVA面向对象 1.3 JAVA核心API
最新八股文面试题
weixin_44530708的博客
03-01 2549
最新八股文面试题
Django学习笔记三：QuerySet使用详解
软件行业技术文化交流。
10-02 264
Django的QuerySet是Django ORM中用于表示数据库查询结果集合的对象。它提供了丰富的方法来操作和查询数据库。
学习记录：js算法（四十九）：二叉树的层序遍历
weixin_48677331的博客
10-01 428
任重而道远！
10.2学习
2401_87363162的博客
10-02 1168
​ Spring AOP就是基于动态代理的，如果要代理的对象，实现了某个接⼝，那么Spring AOP会使⽤JDKProxy，去创建代理对象，⽽对于没有实现接⼝的对象，就⽆法使⽤ JDK Proxy 去进⾏代理了，这时候Spring AOP会使⽤基于asm框架字节流的Cglib动态代理 ，这时候Spring AOP会使⽤ Cglib ⽣成⼀个被代理对象的⼦类来作为代理。每个线程中都有一个自己的ThreadLocalMap类对象，可以将线程自己的对象保持到其中，各管各的，线程可以正确的访问到自己的对象。
jmeter学习（7）beanshell
daxiashangxian的博客
10-06 320
打开日志选项，beanshell的log可以在日志中查看log.info("deviceId"）举例：获取返回数据中的字段。
关于懒惰学习与渴求学习的一份介绍
2301_79096986的博客
10-04 1196
在这篇文章中，我将介绍些懒惰学习与渴求学习的算法例子，会介绍其概念、优缺点以及其python的运用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值