嵌入式学习DAY20 --- 数据结构（单链表）

最新推荐文章于 2024-07-12 18:22:32 发布

楼台的春风

最新推荐文章于 2024-07-12 18:22:32 发布

阅读量200

点赞数

分类专栏：嵌入式学习文章标签：链表指针数据结构 c语言嵌入式

本文链接：https://blog.csdn.net/SpringWJN/article/details/115091125

版权

嵌入式学习专栏收录该内容

35 篇文章 0 订阅

订阅专栏

嵌入式入门学习笔记，遇到的问题以及心得体会！
DAY20

笔记：
存储结构：不连续的链式存储
逻辑结构：线性一对一
运算：创建、增加、删除、修改、排序、销毁
在这里插入图片描述

Struct LinkNode   //描述每一个节点的
{
Data_t data;
Struct LinkNode *pNext;
};

Struct Link  //描述单链表的
{
Struct LinkNode *pHead;
}

在这里插入图片描述

链表的插入：
在这里插入图片描述

删除一个节点：
在这里插入图片描述

销毁链表：
在这里插入图片描述

代码实现：
第一步：编辑一个link.h文件用来定义点链表及功能

#ifndef _LINK_H_
#define _LINK_H_

typedef int data_t;


enum LINK_OP
{
	TAIL = -1,
	HEAD,
	LINK_ERROR,
	LINK_OK
};
//描述节点的结构体
typedef struct LinkNode
{
	data_t data;  //节点的数据
	struct LinkNode *pNext;//指向下一个节点的指针
} LinkNode;

//描述单链表的结构体，只需要知道第一个节点的首地址就可以
typedef struct Link
{
	LinkNode *pHead;
    int count;  //节点的个数
} Link;

Link *createLink();
int insertItemLink(Link *pLink, int iOffset, data_t tData);
int deleteItemLink(Link *pLink, int iOffset, data_t *pData);
int updateItemLink(Link *pLink, data_t oldData, data_t newData);
void showLink(Link *pLink);
void destroy(Link **ppLink);

#endif

第二步：编辑一个link.c文件，用来具体实现各功能

#include<stdio.h>
#include "link.h"
#include <string.h>
#include <stdlib.h>

//创建一个空链表（一个节点都没有，指向头节点的指针应该是NULL）
//返回值：指向空链表的指针
Link *createLink()
{
	Link *pLink = (Link *)malloc(sizeof(Link));
	if(NULL == pLink)
	{
		return NULL;
	}
	pLink->pHead = NULL; //因为还没有一个节点，所以pHead的初始值就是NULL
	pLink->count = 0;
	return pLink;
}

/*
 * 功能：插入操作
 * 参数：pLink  要操作的单链表
 * iOffset：要插入的位置
 *          如果iOffset的值很大，就可以插在末尾
 *tData:要插入的元素
 * 
 */

int insertItemLink(Link *pLink, int iOffset, data_t tData)
{
	if(NULL == pLink || iOffset < -1)
	{
		return LINK_ERROR;
	}

	//创建一个节点
	LinkNode *pNode = (LinkNode *)malloc(sizeof(LinkNode));
	if(NULL == pNode)
	{
		return LINK_ERROR;
	}
	memset(pNode, 0, sizeof(LinkNode));
	pNode->data = tData;


	//如果是空链表，需要单独进行插入
	if(NULL == pLink->pHead)
	{
		pLink->pHead = pNode;
		pLink->count++;
		return LINK_OK;
	}
	//将新创建的节点进行插入
	LinkNode *pTmp = pLink->pHead;

	switch(iOffset)
	{
		case HEAD:
			pNode->pNext = pLink->pHead;
			pLink->pHead = pNode;
			break;
		case TAIL:
			printf("tail....\n");
			//先找到尾部
			while(pTmp->pNext != NULL)
			{
				pTmp = pTmp->pNext;
			}
			//pTmp就指向了最后一个节点
			pTmp->pNext = pNode;
			break;
		default:
		{
			//移动pTmp，指向要插入位置的前一个位置
			int i;
			for(i = 0; i < iOffset-1; i++)
			{
				//如果pTmp是最后一个节点，就不能再移动了
				if(NULL == pTmp->pNext)
				{
					break;
				}
				pTmp = pTmp->pNext;
			}
			//先连后断 
			pNode->pNext = pTmp->pNext;
			pTmp->pNext = pNode;
		}
	}

	pLink->count++;
	return LINK_OK;
}
int deleteItemLink(Link *pLink, int iOffset, data_t *pData)
{
	if(NULL == pLink || iOffset < 0 || iOffset >= pLink->count || NULL == pData)
	{
		return LINK_ERROR;
	}

	//找到要删除位置的前一个节点
	//pTmp：要删除的节点的前一个节点
	//pDel:要删除的节点

	//如果只有一个节点或者要删除头节点
	if(1 == pLink->count || 0 == iOffset)
	{
		*pData = pLink->pHead->data;
		if(pLink->count > 1)
		{
			LinkNode *pDel = pLink->pHead;
			pLink->pHead = pLink->pHead->pNext;
			free(pDel);
			pDel = NULL;
		}
		else
		{
			free(pLink->pHead);
			pLink->pHead = NULL;
		}
		pLink->count--;
		return LINK_OK;
	}
	LinkNode *pTmp = pLink->pHead;
	int i;
	for(i = 0; i < iOffset-1; i++)
	{
		pTmp = pTmp->pNext;
	}
	LinkNode *pDel = pTmp->pNext;
	pTmp->pNext = pDel->pNext;
	*pData = pDel->data;
	free(pDel);
	pDel = NULL;

	pLink->count--;
	return LINK_OK;
}
int updateItemLink(Link *pLink, data_t oldData, data_t newData)
{
	if(NULL == pLink || NULL == pLink->pHead)
	{
		return LINK_ERROR;
	}
	LinkNode *pTmp = pLink->pHead;
	while(pTmp != NULL)
	{
		if(pTmp->data == oldData)
		{
			pTmp->data = newData;
		}
		pTmp = pTmp->pNext;
	}
	return LINK_OK;
}
void showLink(Link *pLink)
{
	if(NULL == pLink)
	{
		return;
	}

	LinkNode *pTmp = pLink->pHead;
	while(pTmp != NULL)
	{
		printf("%d  ", pTmp->data);
		pTmp = pTmp->pNext;
	}
	printf("\n");
}
void destroy(Link **ppLink)
{
	if(NULL == ppLink || NULL == *ppLink || NULL == (*ppLink)->pHead)
	{
		return;
	}

	LinkNode *pTmp = NULL;
	while((*ppLink)->pHead != NULL)
	{
		pTmp = (*ppLink)->pHead;
		(*ppLink)->pHead = (*ppLink)->pHead->pNext;
		free(pTmp);
	}

	pTmp = NULL;
	free(*ppLink);
	*ppLink = NULL;
}

第三步：编辑一个main.c文件用来具体调用

#include<stdio.h>
#include "link.h"

int main()
{
	//创建一个单链表
	Link *pLink = createLink();
	if(NULL == pLink)
	{
		printf("创建单链表失败!\n");
		return -1;
    }
	
	//插入
	int i;
	for(i = 0; i < 5; i++)
	{
		insertItemLink(pLink, i, i+100);
	}

	int c;
	int iOffset;
	data_t data;
	while(1)
	{
		printf("请输入指令：1 插入  2  删除  3 显示 4 修改\n");
        scanf("%d", &c);
		if(0 == c)
		{
			break;
		}
		switch(c)
		{
			case 1:
				printf("请输入要插入的位置：");
				scanf("%d", &iOffset);
		        printf("iOffset = %d\n", iOffset);
				printf("请输入要插入的值：");
				scanf("%d", &data);
				getchar();
				insertItemLink(pLink, iOffset, data);

			
				break;
			case 2:
				printf("请输入要删除的位置：");
				scanf("%d", &iOffset);
                deleteItemLink(pLink, iOffset, &data);
				
				
				break;
			case 3:
				
				showLink(pLink);
				
				break;
			case 4:
				{

					data_t oldData, newData;
					printf("请输入要修改的值:");
					scanf("%d", &oldData);
					printf("请输入修改后的值:");
					scanf("%d", &newData);
					updateItemLink(pLink, oldData, newData);
				
					break;
				
				}
			default:
				printf("命令不存在，重新输入!\n");
		}
	}
	destroy(&pLink);
	return 0; 
}

作业：
1、练熟代码
2、将插入的元素的值保存到文件中，再次运行时，之前插入的值可以从文件中读出来，继续插入
思路：
1、要将文件中的数据要读入链表
1、可读可写的方式打开文件
2、文件存在，说明之前操作过，读文件，将文件中读到的内容插入链表
3、文件不存在，说明之前没有操作过，创建文件
2、插入操作：只要你往链表中插入数据了，就顺便写入文件就可以了
3、删除操作：因为我们不可能只把文件中的某一个数据给删掉，我们需要先操作链表，把链表中的某个节点给删掉，然后重新以只写的方式打开文件，此时文件原来的东西就没了，再把整个链表写入文件

所以：我们需要做的是在程序刚刚运行起来，还没有对链表有任何操作时，先把文件中的数据先读入链表，然后你可以对链表进行各种操作，等到程序结束之间，你再将链表的全部写入清空后的文件就可以了

3、实现单链表的倒置（头插法）–不是让你逆序打印，也不是让你重新又定义了一个链表，而是只有一个链表，它自己本身发生了倒置

答：将上述要求整合在一块实现，依然是三个文件来实现

第一步：link.h

#ifndef _LINK_H_
#define _LINK_H_

//定义数据结构元素的类型
typedef int data_t;
//定义节点的结构体
typedef struct LinkNode
{
	data_t data;//节点的数据
	struct LinkNode *pNext;//指向下一个节点的指针
}LinkNode;
//定义单链表的结构体
typedef struct Link
{
	LinkNode *pHead;//指向首节点的指针
	int count;//
}Link;

enum LINK_OP
{
	LINK_ERROR = -1,
	LINK_OK
};
//创建
Link *createLink();
//插入
int insertItemLink(Link *pLink,int iOffset,data_t tData);
//删除
int deleteItemLink(Link *pLink,int iOffset,data_t *pData);
//修改
int updataItemLink(Link *pLink,data_t olddata,data_t newdata);
//打印
void showLink(Link *pLink);
//销毁
void destroyLink(Link **ppLink);
//倒置
LinkNode *reserveLink(Link *pLink);
//写入
void write_link(Link *pLink);
//读取
void read_link(Link *pLink);

#endif

第二步：link.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "../include/link.h"

//创建
Link *createLink()
{
	Link *pLink = (Link *)malloc(sizeof(Link));
	if(NULL == pLink)
	{
		return NULL;
	}
	
	pLink->pHead = NULL;
	pLink->count = 0;
	return pLink;
}

//插入
/*
 *功能：实现单链表数据的插入
 *参数：pLink:指向单链表的指针
 *      iOffset:要插入的元素的位置
 *      tData：要插入的数据
 */
int insertItemLink(Link *pLink,int iOffset,data_t tData)
{
	if(NULL == pLink || iOffset < 0)
	{
		return LINK_ERROR;
	}
	//先创建一个节点用来存放要插入的数据
	LinkNode *pNode = (LinkNode *)malloc(sizeof(LinkNode));
	if(NULL == pNode)
	{
		return LINK_ERROR;
	}
	memset(pNode,0,sizeof(LinkNode));
	pNode->data = tData;

	//如果是一个空链表
	if(NULL == pLink->pHead)
	{
		pLink->pHead = pNode;
		pLink->count++;
		return LINK_OK;
	}

	//创建一个节点并指向首节点，然后移动至要插入的前一个节点
	LinkNode *pTemp = pLink->pHead;
	int i;
	for(i=0;i<iOffset-1;i++)
	{
		if(NULL == pTemp->pNext)
		{
			break;
		}
		pTemp = pTemp->pNext;
	}

	//先连后断
	pNode->pNext = pTemp->pNext;
	pTemp->pNext = pNode;
	pLink->count++;
	return LINK_OK;

}
/*void write_link(Link *pLink)
{
	if(NULL == pLink)
	{
		return;
	}

	LinkNode *pTemp = pLink->pHead;
	if(*fp == NULL)
	{
		return;
	}
	while(pTemp->pNext != NULL)
	{
		fwrite(pTemp,1,sizeof(LinkNode) * pLink->count,fp);
		pTemp = pTemp->pNext;
	}
	fclose(*fp);
}*/
/*void read_link(Link *pLink)
{
	if(NULL == pLink)
	{
		return;
	}
	FILE *fp = fopen("mylink","r");
	if(NULL ==  fp)
	{
		puts("创建失败");
	}

	fread(pLink->pHead,1,sizeof(LinkNode) * pLink->count,fp);
	showLink(pLink);
	fclose(fp);
}*/
//删除
int deleteItemLink(Link *pLink,int iOffset,data_t *pData)
{
	if(NULL == pLink || iOffset < 0 || iOffset >= pLink->count || NULL == pData)
	{
		return LINK_ERROR;
	}
	if(1 == pLink->count || 0 == iOffset)
	{
		*pData = pLink->pHead->data;
		if(pLink->count > 1)
		{
			LinkNode *pDel = pLink->pHead;
			pLink->pHead = pLink->pHead->pNext;
			free(pDel);
			pDel = NULL;
		}
		else
		{
			free(pLink->pHead);
			pLink->pHead = NULL;
		}
		pLink->count--;
		return LINK_OK;
	}
	//创建一个节点，移动到要删除的节点的钱一个节点
	LinkNode *pTemp = pLink->pHead;
	int i;
	for(i=0;i<iOffset-1;i++)
	{
		pTemp = pTemp->pNext;
	}
	LinkNode *pDel = pTemp->pNext;
	*pData = pDel->data;
	pTemp->pNext = pDel->pNext;
	free(pDel);
	pDel = NULL;
	pLink->count--;
	return LINK_OK;
	

}
//修改
int updataItemLink(Link *pLink,data_t olddata,data_t newdata)
{
	if(NULL == pLink || NULL == pLink->pHead)
	{
		return LINK_ERROR;
	}
	//创建一个节点指向首节点
	LinkNode *pTemp = pLink->pHead;
	while(pTemp != NULL)
	{
		if(pTemp->data == olddata)
		{
			pTemp->data = newdata;
		}
		pTemp = pTemp->pNext;
	}
	return LINK_OK;

}
//打印
void showLink(Link *pLink)
{
	if(NULL == pLink)
	{
		return;
	}

	LinkNode *pTemp = pLink->pHead;
	while(pTemp != NULL)
	{
		printf("%d ",pTemp->data);
		pTemp = pTemp->pNext;
	}
	printf("\n");
}
//销毁
void destroyLink(Link **ppLink)
{
	if(NULL == ppLink || NULL == *ppLink || (*ppLink)->pHead == NULL)
	{
		return;
	}
	//创建一个节点
	LinkNode *pTemp = NULL;
	while((*ppLink)->pHead != NULL)
	{
		pTemp = (*ppLink)->pHead;
		(*ppLink)->pHead = (*ppLink)->pHead->pNext;
		free(pTemp);
	}
	pTemp = NULL;
	free(*ppLink);
	*ppLink = NULL;
}

//倒置
LinkNode *reserveLink(Link *pLink)
{
	if(NULL == pLink || NULL == pLink->pHead)
	{
		return NULL;
	}
	LinkNode *pCurr;
	LinkNode *pTemp;
	pCurr = pLink->pHead->pNext;//指向当前节点
	pLink->pHead->pNext = NULL;
	while(pCurr != NULL)
	{
		pTemp = pCurr->pNext;//将当前节点的指向保存
		pCurr->pNext = pLink->pHead;//将当前节点指向头节点
		pLink->pHead = pCurr;//头节点指向当前节点
		pCurr = pTemp;//当前节点指向先前保存的节点
	}
	return pLink->pHead;
	
}

第三步：main.c

#include <stdio.h>
#include "../include/link.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
FILE *fp;
int main(int argc, const char *argv[])
{


	Link *pLink = createLink();
	if(NULL == pLink)
	{
		printf("创建失败！\n");
		return -1;
	}
	int c;
	int iOffset;
	data_t data;

	//判断文件存不存在
	int fd = open("1.txt", O_RDWR | O_APPEND);
	if(fd < 0)
	{
		perror("open error!");
		//如果文件不存在，就创建文件
		fd = open("1.txt", O_WRONLY | O_CREAT, 0666);
		if(fd < 0)
		{
			perror("open error!");
			return -1;
		}
	}
	else
	{
		//读文件，将读到的内容插入链表
		while(1)
		{
			data_t tData;
			int ret = read(fd, &tData, sizeof(tData));
			if(ret < 0)
			{
				perror("read error!");
				close(fd);
				return -1;
			}
			else if(0 == ret)
			{
				break;
			}
			insertItemLink(pLink,0,tData);
		}
	}
	while(1)
	{
		printf("1---插入\n2---删除\n3---修改\n4---显示\n5---倒置\n请输入：\n");
		scanf("%d",&c);
		if(0 == c)
		{
			break;
		}
		switch(c)
		{
		case 1:
			printf("请输入要插入的位置：");
			scanf("%d",&iOffset);
			printf("请输入要插入的值：");
			scanf("%d",&data);
			insertItemLink(pLink,iOffset,data);
			write(fd, &data, sizeof(data));
			break;
		case 2:
			printf("请输入要删除的位置：");
			scanf("%d",&iOffset);
			deleteItemLink(pLink,iOffset,&data);
			printf("删除的值为：%d\n",data);
			break;
		case 3:
			{
				data_t oldData,newData;
				printf("请输入要修改的值：");
				scanf("%d",&oldData);
				printf("请输入要修改后的值：");
				scanf("%d",&newData);
				updataItemLink(pLink,oldData,newData);
				break;
			}
		case 4:
			showLink(pLink);
			break;
		case 5:
			reserveLink(pLink);
			printf("倒置的结果为：\n");
			break;
deflaut:
			printf("命令错误，请重新输入！\n");

		}
	}

	close(fd);
	destroyLink(&pLink);
	return 0;
}

楼台的春风

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
嵌入式学习DAY20 --- 数据结构（单链表）

嵌入式入门学习笔记，遇到的问题以及心得体会！DAY18笔记：存储结构：不连续的链式存储逻辑结构：线性一对一运算：创建、增加、删除、修改、排序、销毁Struct LinkNode //描述每一个节点的{Data_t data;Struct LinkNode *pNext;};Struct Link //描述单链表的{Struct LinkNode *pHead;}链表的插入：删除一个节点：销毁链表：代码实现：第一步：编辑一个link.h文件用来定
复制链接

扫一扫